arangodb/arangod/Aql/InAndOutRowExpressionContext.cpp

////////////////////////////////////////////////////////////////////////////////
/// DISCLAIMER
///
/// Copyright 2019-2019 ArangoDB GmbH, Cologne, Germany
///
/// Licensed under the Apache License, Version 2.0 (the "License");
/// you may not use this file except in compliance with the License.
/// You may obtain a copy of the License at
///
///     http://www.apache.org/licenses/LICENSE-2.0
///
/// Unless required by applicable law or agreed to in writing, software
/// distributed under the License is distributed on an "AS IS" BASIS,
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
/// See the License for the specific language governing permissions and
/// limitations under the License.
///
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
///
/// @author Michael Hackstein
////////////////////////////////////////////////////////////////////////////////

#include "InAndOutRowExpressionContext.h"
#include "Aql/AqlItemBlock.h"
#include "Aql/AqlValue.h"
#include "Aql/Variable.h"
#include "Basics/Exceptions.h"

#include <limits.h>

using namespace arangodb;
using namespace arangodb::aql;

InAndOutRowExpressionContext::InAndOutRowExpressionContext(
    std::vector<Variable const*> const&& vars,
    std::vector<RegisterId> const&& regs, size_t vertexVarIdx,
    size_t edgeVarIdx, size_t pathVarIdx)
    : ExpressionContext(),
      _inputBlock(nullptr),
      _inputRow(0),
      _vars(std::move(vars)),
      _regs(std::move(regs)),
      _vertexVarIdx(vertexVarIdx),
      _edgeVarIdx(edgeVarIdx),
      _pathVarIdx(pathVarIdx) {
  TRI_ASSERT(_vars.size() == _regs.size());
  TRI_ASSERT(_vertexVarIdx < _vars.size() ||
             _vertexVarIdx == std::numeric_limits<std::size_t>::max());
  TRI_ASSERT(_edgeVarIdx < _vars.size() ||
             _edgeVarIdx == std::numeric_limits<std::size_t>::max());
  TRI_ASSERT(_pathVarIdx < _vars.size() ||
             _pathVarIdx == std::numeric_limits<std::size_t>::max());
}

void InAndOutRowExpressionContext::setInputRow(AqlItemBlock const* inputBlock, size_t inputRow) {
  TRI_ASSERT(inputBlock != nullptr);
  TRI_ASSERT(inputBlock->size() > inputRow);
  _inputBlock = inputBlock;
  _inputRow = inputRow;
}

AqlValue const& InAndOutRowExpressionContext::getRegisterValue(size_t i) const {
  TRI_ASSERT(_inputBlock != nullptr);
  TRI_ASSERT(i < _regs.size());
  if (i == _vertexVarIdx) {
    return _vertexValue;
  }
  if (i == _edgeVarIdx) {
    return _edgeValue;
  }
  if (i == _pathVarIdx) {
    return _pathValue;
  }
  // Search InputRow
  RegisterId const& regId = _regs[i];
  TRI_ASSERT(regId < _inputBlock->getNrRegs());
  return _inputBlock->getValueReference(_inputRow, regId);
}

AqlValue InAndOutRowExpressionContext::getVariableValue(Variable const* variable, bool doCopy,
                                                        bool& mustDestroy) const {
  TRI_ASSERT(_inputBlock != nullptr);
  for (size_t i = 0; i < _vars.size(); ++i) {
    auto const& v = _vars[i];
    if (v->id == variable->id) {
      TRI_ASSERT(i < _regs.size());
      if (doCopy) {
        mustDestroy = true;
        if (i == _vertexVarIdx) {
          return _vertexValue.clone();
        }
        if (i == _edgeVarIdx) {
          return _edgeValue.clone();
        }
        if (i == _pathVarIdx) {
          return _pathValue.clone();
        }
        // Search InputRow
        RegisterId const& regId = _regs[i];
        TRI_ASSERT(regId < _inputBlock->getNrRegs());
        return _inputBlock->getValueReference(_inputRow, regId).clone();
      } else {
        mustDestroy = false;
        if (i == _vertexVarIdx) {
          return _vertexValue;
        }
        if (i == _edgeVarIdx) {
          return _edgeValue;
        }
        if (i == _pathVarIdx) {
          return _pathValue;
        }
        // Search InputRow
        RegisterId const& regId = _regs[i];
        TRI_ASSERT(regId < _inputBlock->getNrRegs());
        return _inputBlock->getValue(_inputRow, regId);
      }
    }
  }

  std::string msg("variable not found '");
  msg.append(variable->name);
  // NOTE: PRUNE is the only feature using this context.
  msg.append("' in PRUNE statement");
  THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_INTERNAL, msg.c_str());
}