Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
arangodb/arangod/Aql/Expression.cpp

1371 lines
43 KiB
C++
Raw Blame History

////////////////////////////////////////////////////////////////////////////////
/// DISCLAIMER
///
/// Copyright 2014-2016 ArangoDB GmbH, Cologne, Germany
/// Copyright 2004-2014 triAGENS 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 Jan Steemann
////////////////////////////////////////////////////////////////////////////////
#include "Expression.h"
#include "Aql/AqlItemBlock.h"
#include "Aql/AqlValue.h"
#include "Aql/Ast.h"
#include "Aql/AttributeAccessor.h"
#include "Aql/Executor.h"
#include "Aql/Quantifier.h"
#include "Aql/Query.h"
#include "Aql/V8Expression.h"
#include "Aql/Variable.h"
#include "Basics/Exceptions.h"
#include "Basics/JsonHelper.h"
#include "Basics/StringBuffer.h"
#include "Basics/VelocyPackHelper.h"
#include "Basics/json.h"
#include <velocypack/Builder.h>
#include <velocypack/Iterator.h>
#include <velocypack/Slice.h>
#include <velocypack/velocypack-aliases.h>
using namespace arangodb::aql;
using Json = arangodb::basics::Json;
using JsonHelper = arangodb::basics::JsonHelper;
using VelocyPackHelper = arangodb::basics::VelocyPackHelper;
/// @brief register warning
static void RegisterWarning(arangodb::aql::Ast const* ast,
char const* functionName, int code) {
std::string msg;
if (code == TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH) {
msg = arangodb::basics::Exception::FillExceptionString(code, functionName);
} else {
msg.append("in function '");
msg.append(functionName);
msg.append("()': ");
msg.append(TRI_errno_string(code));
}
ast->query()->registerWarning(code, msg.c_str());
}
/// @brief create the expression
Expression::Expression(Ast* ast, AstNode* node)
: _ast(ast),
_executor(_ast->query()->executor()),
_node(node),
_type(UNPROCESSED),
_canThrow(true),
_canRunOnDBServer(false),
_isDeterministic(false),
_hasDeterminedAttributes(false),
_built(false),
_attributes(),
_buffer(TRI_UNKNOWN_MEM_ZONE) {
TRI_ASSERT(_ast != nullptr);
TRI_ASSERT(_executor != nullptr);
TRI_ASSERT(_node != nullptr);
}
/// @brief create an expression from JSON
Expression::Expression(Ast* ast, arangodb::basics::Json const& json)
: Expression(ast, new AstNode(ast, json.get("expression"))) {}
/// @brief destroy the expression
Expression::~Expression() {
if (_built) {
switch (_type) {
case JSON:
TRI_ASSERT(_data != nullptr);
delete[] _data;
break;
case ATTRIBUTE: {
TRI_ASSERT(_accessor != nullptr);
delete _accessor;
break;
}
case V8:
delete _func;
break;
case SIMPLE:
case UNPROCESSED: {
// nothing to do
break;
}
}
}
}
/// @brief return all variables used in the expression
void Expression::variables(std::unordered_set<Variable const*>& result) const {
Ast::getReferencedVariables(_node, result);
}
/// @brief execute the expression
AqlValue Expression::execute(arangodb::AqlTransaction* trx,
AqlItemBlock const* argv, size_t startPos,
std::vector<Variable const*> const& vars,
std::vector<RegisterId> const& regs,
bool& mustDestroy) {
if (!_built) {
buildExpression();
}
TRI_ASSERT(_type != UNPROCESSED);
TRI_ASSERT(_built);
// and execute
switch (_type) {
case JSON: {
mustDestroy = false;
TRI_ASSERT(_data != nullptr);
return AqlValue(_data);
}
case SIMPLE: {
return executeSimpleExpression(_node, trx, argv, startPos,
vars, regs, mustDestroy, true);
}
case ATTRIBUTE: {
TRI_ASSERT(_accessor != nullptr);
return _accessor->get(trx, argv, startPos, vars, regs, mustDestroy);
}
case V8: {
TRI_ASSERT(_func != nullptr);
ISOLATE;
return _func->execute(isolate, _ast->query(), trx, argv, startPos, vars, regs, mustDestroy);
}
case UNPROCESSED: {
// fall-through to exception
}
}
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_INTERNAL,
"invalid simple expression");
}
/// @brief replace variables in the expression with other variables
void Expression::replaceVariables(
std::unordered_map<VariableId, Variable const*> const& replacements) {
_node = _ast->clone(_node);
TRI_ASSERT(_node != nullptr);
_node = _ast->replaceVariables(const_cast<AstNode*>(_node), replacements);
if (_type == ATTRIBUTE && _accessor != nullptr) {
_accessor->replaceVariable(replacements);
}
invalidate();
}
/// @brief replace a variable reference in the expression with another
/// expression (e.g. inserting c = `a + b` into expression `c + 1` so the latter
/// becomes `a + b + 1`
void Expression::replaceVariableReference(Variable const* variable,
AstNode const* node) {
_node = _ast->clone(_node);
TRI_ASSERT(_node != nullptr);
_node = _ast->replaceVariableReference(const_cast<AstNode*>(_node), variable,
node);
invalidate();
if (_type == ATTRIBUTE) {
if (_built) {
delete _accessor;
_accessor = nullptr;
_built = false;
}
// must even set back the expression type so the expression will be analyzed
// again
_type = UNPROCESSED;
} else if (_type == SIMPLE) {
// must rebuild the expression completely, as it may have changed drastically
_built = false;
_type = UNPROCESSED;
}
const_cast<AstNode*>(_node)->clearFlags();
_attributes.clear();
_hasDeterminedAttributes = false;
}
/// @brief invalidates an expression
/// this only has an effect for V8-based functions, which need to be created,
/// used and destroyed in the same context. when a V8 function is used across
/// multiple V8 contexts, it must be invalidated in between
void Expression::invalidate() {
if (_type == V8) {
// V8 expressions need a special handling
if (_built) {
delete _func;
_func = nullptr;
_built = false;
}
}
// we do not need to invalidate the other expression type
// expression data will be freed in the destructor
}
/// @brief find a value in an AQL list node
/// this performs either a binary search (if the node is sorted) or a
/// linear search (if the node is not sorted)
bool Expression::findInArray(AqlValue const& left, AqlValue const& right,
arangodb::AqlTransaction* trx,
AstNode const* node) const {
TRI_ASSERT(right.isArray());
size_t const n = right.length();
if (n > 3 &&
(node->getMember(1)->isSorted() ||
((node->type == NODE_TYPE_OPERATOR_BINARY_IN ||
node->type == NODE_TYPE_OPERATOR_BINARY_NIN) && node->getBoolValue()))) {
// node values are sorted. can use binary search
size_t l = 0;
size_t r = n - 1;
while (true) {
// determine midpoint
size_t m = l + ((r - l) / 2);
bool localMustDestroy;
AqlValue a = right.at(m, localMustDestroy, false);
AqlValueGuard guard(a, localMustDestroy);
int compareResult = AqlValue::Compare(trx, left, a, true);
if (compareResult == 0) {
// item found in the list
return true;
}
if (compareResult < 0) {
if (m == 0) {
// not found
return false;
}
r = m - 1;
} else {
l = m + 1;
}
if (r < l) {
return false;
}
}
}
// if right operand of IN/NOT IN is a range, we can use an optimized search
if (right.isRange()) {
// but only if left operand is a number
if (!left.isNumber()) {
// a non-number will never be contained in the range
return false;
}
// check if conversion to int64 would be lossy
int64_t value = left.toInt64();
if (left.toDouble() == static_cast<double>(value)) {
// no loss
Range const* r = right.range();
TRI_ASSERT(r != nullptr);
return r->isIn(value);
}
// fall-through to linear search
}
// use linear search
for (size_t i = 0; i < n; ++i) {
bool mustDestroy;
AqlValue a = right.at(i, mustDestroy, false);
AqlValueGuard guard(a, mustDestroy);
int compareResult = AqlValue::Compare(trx, left, a, false);
if (compareResult == 0) {
// item found in the list
return true;
}
}
return false;
}
/// @brief analyze the expression (determine its type etc.)
void Expression::analyzeExpression() {
TRI_ASSERT(_type == UNPROCESSED);
TRI_ASSERT(_built == false);
if (_node->isConstant()) {
// expression is a constant value
_type = JSON;
_canThrow = false;
_canRunOnDBServer = true;
_isDeterministic = true;
_data = nullptr;
} else if (_node->isSimple()) {
// expression is a simple expression
_type = SIMPLE;
_canThrow = _node->canThrow();
_canRunOnDBServer = _node->canRunOnDBServer();
_isDeterministic = _node->isDeterministic();
if (_node->type == NODE_TYPE_ATTRIBUTE_ACCESS) {
TRI_ASSERT(_node->numMembers() == 1);
auto member = _node->getMemberUnchecked(0);
std::vector<std::string> parts{_node->getString()};
while (member->type == NODE_TYPE_ATTRIBUTE_ACCESS) {
parts.insert(parts.begin(), member->getString());
member = member->getMemberUnchecked(0);
}
if (member->type == NODE_TYPE_REFERENCE) {
auto v = static_cast<Variable const*>(member->getData());
// specialize the simple expression into an attribute accessor
_accessor = new AttributeAccessor(parts, v);
_type = ATTRIBUTE;
_built = true;
}
}
} else {
// expression is a V8 expression
_type = V8;
_canThrow = _node->canThrow();
_canRunOnDBServer = _node->canRunOnDBServer();
_isDeterministic = _node->isDeterministic();
_func = nullptr;
if (!_hasDeterminedAttributes) {
// determine all top-level attributes used in expression only once
// as this might be expensive
_hasDeterminedAttributes = true;
bool isSafeForOptimization;
_attributes =
Ast::getReferencedAttributes(_node, isSafeForOptimization);
if (!isSafeForOptimization) {
_attributes.clear();
// unfortunately there are not only top-level attribute accesses but
// also other accesses, e.g. the index values or accesses of the whole
// value.
// for example, we cannot optimize LET x = a +1 or LET x = a[0], but LET
// x = a._key
}
}
}
}
/// @brief build the expression
void Expression::buildExpression() {
TRI_ASSERT(!_built);
if (_type == UNPROCESSED) {
analyzeExpression();
}
if (_type == JSON) {
TRI_ASSERT(_data == nullptr);
// generate a constant value
VPackBuilder builder;
_node->toVelocyPackValue(builder);
_data = new uint8_t[builder.size()];
memcpy(_data, builder.data(), builder.size());
} else if (_type == V8) {
// generate a V8 expression
_func = _executor->generateExpression(_node);
// optimizations for the generated function
if (_func != nullptr && !_attributes.empty()) {
// pass which variables do not need to be fully constructed
_func->setAttributeRestrictions(_attributes);
}
}
_built = true;
}
/// @brief execute an expression of type SIMPLE, the convention is that
/// the resulting AqlValue will be destroyed outside eventually
AqlValue Expression::executeSimpleExpression(
AstNode const* node, arangodb::AqlTransaction* trx, AqlItemBlock const* argv, size_t startPos,
std::vector<Variable const*> const& vars,
std::vector<RegisterId> const& regs, bool& mustDestroy, bool doCopy) {
switch (node->type) {
case NODE_TYPE_ATTRIBUTE_ACCESS:
return executeSimpleExpressionAttributeAccess(node, trx, argv, startPos,
vars, regs, mustDestroy);
case NODE_TYPE_INDEXED_ACCESS:
return executeSimpleExpressionIndexedAccess(node, trx, argv, startPos,
vars, regs, mustDestroy);
case NODE_TYPE_ARRAY:
return executeSimpleExpressionArray(node, trx, argv, startPos, vars,
regs, mustDestroy);
case NODE_TYPE_OBJECT:
return executeSimpleExpressionObject(node, trx, argv, startPos, vars,
regs, mustDestroy);
case NODE_TYPE_VALUE:
return executeSimpleExpressionValue(node, mustDestroy);
case NODE_TYPE_REFERENCE:
return executeSimpleExpressionReference(node, trx, argv, startPos,
vars, regs, mustDestroy, doCopy);
case NODE_TYPE_FCALL:
return executeSimpleExpressionFCall(node, trx, argv, startPos, vars,
regs, mustDestroy);
case NODE_TYPE_RANGE:
return executeSimpleExpressionRange(node, trx, argv, startPos, vars,
regs, mustDestroy);
case NODE_TYPE_OPERATOR_UNARY_NOT:
return executeSimpleExpressionNot(node, trx, argv, startPos, vars, regs, mustDestroy);
case NODE_TYPE_OPERATOR_BINARY_AND:
case NODE_TYPE_OPERATOR_BINARY_OR:
return executeSimpleExpressionAndOr(node, trx, argv, startPos, vars,
regs, mustDestroy);
case NODE_TYPE_OPERATOR_BINARY_EQ:
case NODE_TYPE_OPERATOR_BINARY_NE:
case NODE_TYPE_OPERATOR_BINARY_LT:
case NODE_TYPE_OPERATOR_BINARY_LE:
case NODE_TYPE_OPERATOR_BINARY_GT:
case NODE_TYPE_OPERATOR_BINARY_GE:
case NODE_TYPE_OPERATOR_BINARY_IN:
case NODE_TYPE_OPERATOR_BINARY_NIN:
return executeSimpleExpressionComparison(node, trx, argv, startPos, vars,
regs, mustDestroy);
case NODE_TYPE_OPERATOR_BINARY_ARRAY_EQ:
case NODE_TYPE_OPERATOR_BINARY_ARRAY_NE:
case NODE_TYPE_OPERATOR_BINARY_ARRAY_LT:
case NODE_TYPE_OPERATOR_BINARY_ARRAY_LE:
case NODE_TYPE_OPERATOR_BINARY_ARRAY_GT:
case NODE_TYPE_OPERATOR_BINARY_ARRAY_GE:
case NODE_TYPE_OPERATOR_BINARY_ARRAY_IN:
case NODE_TYPE_OPERATOR_BINARY_ARRAY_NIN:
return executeSimpleExpressionArrayComparison(node, trx, argv, startPos, vars,
regs, mustDestroy);
case NODE_TYPE_OPERATOR_TERNARY:
return executeSimpleExpressionTernary(node, trx, argv, startPos, vars,
regs, mustDestroy);
case NODE_TYPE_EXPANSION:
return executeSimpleExpressionExpansion(node, trx, argv, startPos, vars,
regs, mustDestroy);
case NODE_TYPE_ITERATOR:
return executeSimpleExpressionIterator(node, trx, argv,
startPos, vars, regs, mustDestroy);
case NODE_TYPE_OPERATOR_BINARY_PLUS:
case NODE_TYPE_OPERATOR_BINARY_MINUS:
case NODE_TYPE_OPERATOR_BINARY_TIMES:
case NODE_TYPE_OPERATOR_BINARY_DIV:
case NODE_TYPE_OPERATOR_BINARY_MOD:
return executeSimpleExpressionArithmetic(node, trx, argv, startPos, vars,
regs, mustDestroy);
default:
std::string msg("unhandled type '");
msg.append(node->getTypeString());
msg.append("' in executeSimpleExpression()");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_INTERNAL, msg.c_str());
}
}
/// @brief check whether this is an attribute access of any degree (e.g. a.b,
/// a.b.c, ...)
bool Expression::isAttributeAccess() const {
return _node->isAttributeAccessForVariable();
}
/// @brief check whether this is a reference access
bool Expression::isReference() const {
return (_node->type == arangodb::aql::NODE_TYPE_REFERENCE);
}
/// @brief check whether this is a constant node
bool Expression::isConstant() const { return _node->isConstant(); }
/// @brief stringify an expression
/// note that currently stringification is only supported for certain node types
void Expression::stringify(arangodb::basics::StringBuffer* buffer) const {
_node->stringify(buffer, true, false);
}
/// @brief stringify an expression
/// note that currently stringification is only supported for certain node types
void Expression::stringifyIfNotTooLong(
arangodb::basics::StringBuffer* buffer) const {
_node->stringify(buffer, true, true);
}
/// @brief execute an expression of type SIMPLE with ATTRIBUTE ACCESS
/// always creates a copy
AqlValue Expression::executeSimpleExpressionAttributeAccess(
AstNode const* node, arangodb::AqlTransaction* trx,
AqlItemBlock const* argv, size_t startPos,
std::vector<Variable const*> const& vars,
std::vector<RegisterId> const& regs, bool& mustDestroy) {
// object lookup, e.g. users.name
TRI_ASSERT(node->numMembers() == 1);
auto member = node->getMemberUnchecked(0);
auto name = static_cast<char const*>(node->getData());
AqlValue result = executeSimpleExpression(member, trx, argv,
startPos, vars, regs, mustDestroy, false);
AqlValueGuard guard(result, mustDestroy);
return result.get(trx, name, mustDestroy, true);
}
/// @brief execute an expression of type SIMPLE with INDEXED ACCESS
AqlValue Expression::executeSimpleExpressionIndexedAccess(
AstNode const* node, arangodb::AqlTransaction* trx,
AqlItemBlock const* argv, size_t startPos,
std::vector<Variable const*> const& vars,
std::vector<RegisterId> const& regs, bool& mustDestroy) {
// array lookup, e.g. users[0]
// note: it depends on the type of the value whether an array lookup or an
// object lookup is performed
// for example, if the value is an object, then its elements might be accessed
// like this:
// users['name'] or even users['0'] (as '0' is a valid attribute name, too)
// if the value is an array, then string indexes might also be used and will
// be converted to integers, e.g.
// users['0'] is the same as users[0], users['-2'] is the same as users[-2]
// etc.
TRI_ASSERT(node->numMembers() == 2);
auto member = node->getMember(0);
auto index = node->getMember(1);
mustDestroy = false;
AqlValue result = executeSimpleExpression(member, trx, argv,
startPos, vars, regs, mustDestroy, false);
AqlValueGuard guard(result, mustDestroy);
if (result.isArray()) {
AqlValue indexResult = executeSimpleExpression(
index, trx, argv, startPos, vars, regs, mustDestroy, false);
AqlValueGuard guard(indexResult, mustDestroy);
if (indexResult.isNumber()) {
return result.at(indexResult.toInt64(), mustDestroy, true);
}
if (indexResult.isString()) {
std::string const value = indexResult.slice().copyString();
try {
// stoll() might throw an exception if the string is not a number
int64_t position = static_cast<int64_t>(std::stoll(value));
return result.at(position, mustDestroy, true);
} catch (...) {
// no number found.
}
}
// fall-through to returning null
} else if (result.isObject()) {
AqlValue indexResult = executeSimpleExpression(
index, trx, argv, startPos, vars, regs, mustDestroy, false);
AqlValueGuard guard(indexResult, mustDestroy);
if (indexResult.isNumber()) {
std::string const indexString = std::to_string(indexResult.toInt64());
return result.get(trx, indexString, mustDestroy, true);
}
if (indexResult.isString()) {
std::string const indexString = indexResult.slice().copyString();
return result.get(trx, indexString, mustDestroy, true);
}
// fall-through to returning null
}
return AqlValue(VelocyPackHelper::NullValue());
}
/// @brief execute an expression of type SIMPLE with ARRAY
AqlValue Expression::executeSimpleExpressionArray(
AstNode const* node, arangodb::AqlTransaction* trx,
AqlItemBlock const* argv, size_t startPos,
std::vector<Variable const*> const& vars,
std::vector<RegisterId> const& regs, bool& mustDestroy) {
mustDestroy = false;
if (node->isConstant()) {
// this will not create a copy
return AqlValue(node->computeValue().begin());
}
size_t const n = node->numMembers();
VPackBuilder builder;
builder.openArray();
for (size_t i = 0; i < n; ++i) {
auto member = node->getMemberUnchecked(i);
bool localMustDestroy = false;
AqlValue result = executeSimpleExpression(member, trx, argv,
startPos, vars, regs, localMustDestroy, false);
AqlValueGuard guard(result, localMustDestroy);
result.toVelocyPack(trx, builder);
}
builder.close();
mustDestroy = true; // AqlValue contains builder contains dynamic data
return AqlValue(builder);
}
/// @brief execute an expression of type SIMPLE with OBJECT
AqlValue Expression::executeSimpleExpressionObject(
AstNode const* node, arangodb::AqlTransaction* trx,
AqlItemBlock const* argv, size_t startPos,
std::vector<Variable const*> const& vars,
std::vector<RegisterId> const& regs,
bool& mustDestroy) {
mustDestroy = false;
if (node->isConstant()) {
// this will not create a copy
return AqlValue(node->computeValue().begin());
}
VPackBuilder builder;
builder.openObject();
size_t const n = node->numMembers();
for (size_t i = 0; i < n; ++i) {
auto member = node->getMemberUnchecked(i);
TRI_ASSERT(member->type == NODE_TYPE_OBJECT_ELEMENT);
// key
builder.add(VPackValue(member->getString()));
// value
member = member->getMember(0);
bool localMustDestroy;
AqlValue result = executeSimpleExpression(member, trx, argv,
startPos, vars, regs, localMustDestroy, false);
AqlValueGuard guard(result, localMustDestroy);
result.toVelocyPack(trx, builder);
}
builder.close();
mustDestroy = true; // AqlValue contains builder contains dynamic data
return AqlValue(builder);
}
/// @brief execute an expression of type SIMPLE with VALUE
AqlValue Expression::executeSimpleExpressionValue(AstNode const* node,
bool& mustDestroy) {
// this will not create a copy
mustDestroy = false;
return AqlValue(node->computeValue().begin());
}
/// @brief execute an expression of type SIMPLE with REFERENCE
AqlValue Expression::executeSimpleExpressionReference(
AstNode const* node, arangodb::AqlTransaction* trx,
AqlItemBlock const* argv, size_t startPos,
std::vector<Variable const*> const& vars,
std::vector<RegisterId> const& regs, bool& mustDestroy,
bool doCopy) {
mustDestroy = false;
auto v = static_cast<Variable const*>(node->getData());
{
auto it = _variables.find(v);
if (it != _variables.end()) {
return AqlValue((*it).second.begin()); // use only pointer to data
}
}
size_t i = 0;
for (auto it = vars.begin(); it != vars.end(); ++it, ++i) {
if ((*it)->id == v->id) {
if (doCopy) {
mustDestroy = true; // as we are copying
return argv->getValueReference(startPos, regs[i]).clone();
}
return argv->getValueReference(startPos, regs[i]);
}
}
std::string msg("variable not found '");
msg.append(v->name);
msg.append("' in executeSimpleExpression()");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_INTERNAL, msg.c_str());
}
/// @brief execute an expression of type SIMPLE with RANGE
AqlValue Expression::executeSimpleExpressionRange(
AstNode const* node, arangodb::AqlTransaction* trx,
AqlItemBlock const* argv, size_t startPos,
std::vector<Variable const*> const& vars,
std::vector<RegisterId> const& regs, bool& mustDestroy) {
auto low = node->getMember(0);
auto high = node->getMember(1);
mustDestroy = false;
AqlValue resultLow = executeSimpleExpression(low, trx, argv,
startPos, vars, regs, mustDestroy, false);
AqlValueGuard guardLow(resultLow, mustDestroy);
AqlValue resultHigh = executeSimpleExpression(
high, trx, argv, startPos, vars, regs, mustDestroy, false);
AqlValueGuard guardHigh(resultHigh, mustDestroy);
mustDestroy = true; // as we're creating a new range object
return AqlValue(resultLow.toInt64(), resultHigh.toInt64());
}
/// @brief execute an expression of type SIMPLE with FCALL
AqlValue Expression::executeSimpleExpressionFCall(
AstNode const* node, arangodb::AqlTransaction* trx,
AqlItemBlock const* argv, size_t startPos,
std::vector<Variable const*> const& vars,
std::vector<RegisterId> const& regs,
bool& mustDestroy) {
mustDestroy = false;
// some functions have C++ handlers
// check if the called function has one
auto func = static_cast<Function*>(node->getData());
TRI_ASSERT(func->implementation != nullptr);
auto member = node->getMemberUnchecked(0);
TRI_ASSERT(member->type == NODE_TYPE_ARRAY);
VPackBuilder builder;
size_t const n = member->numMembers();
VPackFunctionParameters parameters;
std::vector<bool> destroyParameters;
parameters.reserve(n);
destroyParameters.reserve(n);
try {
for (size_t i = 0; i < n; ++i) {
auto arg = member->getMemberUnchecked(i);
if (arg->type == NODE_TYPE_COLLECTION) {
builder.clear();
builder.add(VPackValue(arg->getString()));
parameters.emplace_back(AqlValue(builder));
destroyParameters.push_back(true);
} else {
bool localMustDestroy;
AqlValue a = executeSimpleExpression(arg, trx, argv,
startPos, vars, regs, localMustDestroy, false);
parameters.emplace_back(a);
destroyParameters.push_back(localMustDestroy);
}
}
TRI_ASSERT(parameters.size() == destroyParameters.size());
AqlValue a = func->implementation(_ast->query(), trx, parameters);
mustDestroy = true; // function result is always dynamic
for (size_t i = 0; i < parameters.size(); ++i) {
if (destroyParameters[i]) {
parameters[i].destroy();
}
}
return a;
} catch (...) {
// prevent leak and rethrow error
for (size_t i = 0; i < parameters.size(); ++i) {
if (destroyParameters[i]) {
parameters[i].destroy();
}
}
throw;
}
}
/// @brief execute an expression of type SIMPLE with NOT
AqlValue Expression::executeSimpleExpressionNot(
AstNode const* node, arangodb::AqlTransaction* trx,
AqlItemBlock const* argv, size_t startPos,
std::vector<Variable const*> const& vars,
std::vector<RegisterId> const& regs, bool& mustDestroy) {
mustDestroy = false;
AqlValue operand =
executeSimpleExpression(node->getMember(0), trx, argv,
startPos, vars, regs, mustDestroy, false);
AqlValueGuard guard(operand, mustDestroy);
bool const operandIsTrue = operand.toBoolean();
mustDestroy = false; // only a boolean
return AqlValue(!operandIsTrue);
}
/// @brief execute an expression of type SIMPLE with AND or OR
AqlValue Expression::executeSimpleExpressionAndOr(
AstNode const* node, arangodb::AqlTransaction* trx,
AqlItemBlock const* argv, size_t startPos,
std::vector<Variable const*> const& vars,
std::vector<RegisterId> const& regs, bool& mustDestroy) {
AqlValue left =
executeSimpleExpression(node->getMember(0), trx, argv,
startPos, vars, regs, mustDestroy, true);
if (node->type == NODE_TYPE_OPERATOR_BINARY_AND) {
// AND
if (left.toBoolean()) {
// left is true => return right
if (mustDestroy) { left.destroy(); }
return executeSimpleExpression(node->getMember(1), trx, argv,
startPos, vars, regs, mustDestroy, true);
}
// left is false, return left
return left;
}
// OR
if (left.toBoolean()) {
// left is true => return left
return left;
}
// left is false => return right
left.destroy();
return executeSimpleExpression(node->getMember(1), trx, argv,
startPos, vars, regs, mustDestroy, true);
}
/// @brief execute an expression of type SIMPLE with COMPARISON
AqlValue Expression::executeSimpleExpressionComparison(
AstNode const* node, arangodb::AqlTransaction* trx,
AqlItemBlock const* argv, size_t startPos,
std::vector<Variable const*> const& vars,
std::vector<RegisterId> const& regs,
bool& mustDestroy) {
AqlValue left =
executeSimpleExpression(node->getMember(0), trx, argv,
startPos, vars, regs, mustDestroy, false);
AqlValueGuard guardLeft(left, mustDestroy);
AqlValue right =
executeSimpleExpression(node->getMember(1), trx, argv,
startPos, vars, regs, mustDestroy, false);
AqlValueGuard guardRight(right, mustDestroy);
mustDestroy = false; // we're returning a boolean only
if (node->type == NODE_TYPE_OPERATOR_BINARY_IN ||
node->type == NODE_TYPE_OPERATOR_BINARY_NIN) {
// IN and NOT IN
if (!right.isArray()) {
// right operand must be an array, otherwise we return false
// do not throw, but return "false" instead
return AqlValue(false);
}
bool result = findInArray(left, right, trx, node);
if (node->type == NODE_TYPE_OPERATOR_BINARY_NIN) {
// revert the result in case of a NOT IN
result = !result;
}
return AqlValue(result);
}
// all other comparison operators...
// for equality and non-equality we can use a binary comparison
bool compareUtf8 = (node->type != NODE_TYPE_OPERATOR_BINARY_EQ &&
node->type != NODE_TYPE_OPERATOR_BINARY_NE);
int compareResult = AqlValue::Compare(trx, left, right, compareUtf8);
switch (node->type) {
case NODE_TYPE_OPERATOR_BINARY_EQ:
return AqlValue(compareResult == 0);
case NODE_TYPE_OPERATOR_BINARY_NE:
return AqlValue(compareResult != 0);
case NODE_TYPE_OPERATOR_BINARY_LT:
return AqlValue(compareResult < 0);
case NODE_TYPE_OPERATOR_BINARY_LE:
return AqlValue(compareResult <= 0);
case NODE_TYPE_OPERATOR_BINARY_GT:
return AqlValue(compareResult > 0);
case NODE_TYPE_OPERATOR_BINARY_GE:
return AqlValue(compareResult >= 0);
default:
std::string msg("unhandled type '");
msg.append(node->getTypeString());
msg.append("' in executeSimpleExpression()");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_INTERNAL, msg.c_str());
}
}
/// @brief execute an expression of type SIMPLE with ARRAY COMPARISON
AqlValue Expression::executeSimpleExpressionArrayComparison(
AstNode const* node, arangodb::AqlTransaction* trx,
AqlItemBlock const* argv, size_t startPos,
std::vector<Variable const*> const& vars,
std::vector<RegisterId> const& regs,
bool& mustDestroy) {
AqlValue left =
executeSimpleExpression(node->getMember(0), trx, argv,
startPos, vars, regs, mustDestroy, false);
AqlValueGuard guardLeft(left, mustDestroy);
AqlValue right =
executeSimpleExpression(node->getMember(1), trx, argv,
startPos, vars, regs, mustDestroy, false);
AqlValueGuard guardRight(right, mustDestroy);
mustDestroy = false; // we're returning a boolean only
if (!left.isArray()) {
// left operand must be an array
// do not throw, but return "false" instead
return AqlValue(false);
}
if (node->type == NODE_TYPE_OPERATOR_BINARY_ARRAY_IN ||
node->type == NODE_TYPE_OPERATOR_BINARY_ARRAY_NIN) {
// IN and NOT IN
if (!right.isArray()) {
// right operand must be an array, otherwise we return false
// do not throw, but return "false" instead
return AqlValue(false);
}
}
size_t const n = left.length();
std::pair<size_t, size_t> requiredMatches = Quantifier::RequiredMatches(n, node->getMember(2));
TRI_ASSERT(requiredMatches.first <= requiredMatches.second);
// for equality and non-equality we can use a binary comparison
bool const compareUtf8 = (node->type != NODE_TYPE_OPERATOR_BINARY_ARRAY_EQ &&
node->type != NODE_TYPE_OPERATOR_BINARY_ARRAY_NE);
bool overallResult = true;
size_t matches = 0;
size_t numLeft = n;
for (size_t i = 0; i < n; ++i) {
bool localMustDestroy;
AqlValue leftItemValue = left.at(i, localMustDestroy, false);
AqlValueGuard guard(leftItemValue, localMustDestroy);
bool result;
// IN and NOT IN
if (node->type == NODE_TYPE_OPERATOR_BINARY_ARRAY_IN ||
node->type == NODE_TYPE_OPERATOR_BINARY_ARRAY_NIN) {
result = findInArray(leftItemValue, right, trx, node);
if (node->type == NODE_TYPE_OPERATOR_BINARY_ARRAY_NIN) {
// revert the result in case of a NOT IN
result = !result;
}
}
else {
// other operators
int compareResult = AqlValue::Compare(trx, leftItemValue, right, compareUtf8);
result = false;
switch (node->type) {
case NODE_TYPE_OPERATOR_BINARY_ARRAY_EQ:
result = (compareResult == 0);
break;
case NODE_TYPE_OPERATOR_BINARY_ARRAY_NE:
result = (compareResult != 0);
break;
case NODE_TYPE_OPERATOR_BINARY_ARRAY_LT:
result = (compareResult < 0);
break;
case NODE_TYPE_OPERATOR_BINARY_ARRAY_LE:
result = (compareResult <= 0);
break;
case NODE_TYPE_OPERATOR_BINARY_ARRAY_GT:
result = (compareResult > 0);
break;
case NODE_TYPE_OPERATOR_BINARY_ARRAY_GE:
result = (compareResult >= 0);
break;
default:
TRI_ASSERT(false);
}
}
--numLeft;
if (result) {
++matches;
if (matches > requiredMatches.second) {
// too many matches
overallResult = false;
break;
}
if (matches >= requiredMatches.first && matches + numLeft <= requiredMatches.second) {
// enough matches
overallResult = true;
break;
}
}
else {
if (matches + numLeft < requiredMatches.first) {
// too few matches
overallResult = false;
break;
}
}
}
TRI_ASSERT(!mustDestroy);
return AqlValue(overallResult);
}
/// @brief execute an expression of type SIMPLE with TERNARY
AqlValue Expression::executeSimpleExpressionTernary(
AstNode const* node, arangodb::AqlTransaction* trx,
AqlItemBlock const* argv, size_t startPos,
std::vector<Variable const*> const& vars,
std::vector<RegisterId> const& regs,
bool& mustDestroy) {
AqlValue condition =
executeSimpleExpression(node->getMember(0), trx, argv,
startPos, vars, regs, mustDestroy, false);
AqlValueGuard guardCondition(condition, mustDestroy);
size_t position;
if (condition.toBoolean()) {
// return true part
position = 1;
}
else {
// return false part
position = 2;
}
return executeSimpleExpression(node->getMember(position), trx, argv,
startPos, vars, regs, mustDestroy, true);
}
/// @brief execute an expression of type SIMPLE with EXPANSION
AqlValue Expression::executeSimpleExpressionExpansion(
AstNode const* node, arangodb::AqlTransaction* trx,
AqlItemBlock const* argv, size_t startPos,
std::vector<Variable const*> const& vars,
std::vector<RegisterId> const& regs,
bool& mustDestroy) {
TRI_ASSERT(node->numMembers() == 5);
// LIMIT
int64_t offset = 0;
int64_t count = INT64_MAX;
auto limitNode = node->getMember(3);
if (limitNode->type != NODE_TYPE_NOP) {
AqlValue subOffset =
executeSimpleExpression(limitNode->getMember(0), trx,
argv, startPos, vars, regs, mustDestroy, false);
offset = subOffset.toInt64();
if (mustDestroy) { subOffset.destroy(); }
AqlValue subCount = executeSimpleExpression(limitNode->getMember(1), trx,
argv, startPos, vars, regs, mustDestroy, false);
count = subCount.toInt64();
if (mustDestroy) { subCount.destroy(); }
}
mustDestroy = false;
if (offset < 0 || count <= 0) {
// no items to return... can already stop here
return AqlValue(VelocyPackHelper::EmptyArrayValue());
}
// FILTER
AstNode const* filterNode = node->getMember(2);
if (filterNode->type == NODE_TYPE_NOP) {
filterNode = nullptr;
} else if (filterNode->isConstant()) {
if (filterNode->isTrue()) {
// filter expression is always true
filterNode = nullptr;
} else {
// filter expression is always false
return AqlValue(VelocyPackHelper::EmptyArrayValue());
}
}
auto iterator = node->getMember(0);
auto variable = static_cast<Variable*>(iterator->getMember(0)->getData());
auto levels = node->getIntValue(true);
AqlValue value;
if (levels > 1) {
// flatten value...
bool localMustDestroy;
AqlValue a = executeSimpleExpression(node->getMember(0), trx,
argv, startPos, vars, regs, localMustDestroy, false);
AqlValueGuard guard(a, localMustDestroy);
if (!a.isArray()) {
TRI_ASSERT(!mustDestroy);
return AqlValue(VelocyPackHelper::EmptyArrayValue());
}
VPackBuilder builder;
builder.openArray();
// generate a new temporary for the flattened array
std::function<void(AqlValue const&, int64_t)> flatten =
[&](AqlValue const& v, int64_t level) {
if (!v.isArray()) {
return;
}
size_t const n = v.length();
for (size_t i = 0; i < n; ++i) {
bool localMustDestroy;
AqlValue item = v.at(i, localMustDestroy, false);
AqlValueGuard guard(item, localMustDestroy);
bool const isArray = item.isArray();
if (!isArray || level == levels) {
builder.add(item.slice());
} else if (isArray && level < levels) {
flatten(item, level + 1);
}
}
};
flatten(a, 1);
builder.close();
mustDestroy = true; // builder = dynamic data
value = AqlValue(builder);
} else {
bool localMustDestroy;
AqlValue a = executeSimpleExpression(node->getMember(0), trx,
argv, startPos, vars, regs, localMustDestroy, false);
AqlValueGuard guard(a, localMustDestroy);
if (!a.isArray()) {
TRI_ASSERT(!mustDestroy);
return AqlValue(VelocyPackHelper::EmptyArrayValue());
}
mustDestroy = localMustDestroy; // maybe we need to destroy...
guard.steal(); // guard is not responsible anymore
value = a;
}
AqlValueGuard guard(value, mustDestroy);
// RETURN
// the default is to return array member unmodified
AstNode const* projectionNode = node->getMember(1);
if (node->getMember(4)->type != NODE_TYPE_NOP) {
// return projection
projectionNode = node->getMember(4);
}
VPackBuilder builder;
builder.openArray();
size_t const n = value.length();
for (size_t i = 0; i < n; ++i) {
bool localMustDestroy;
AqlValue item = value.at(i, localMustDestroy, false);
AqlValueGuard guard(item, localMustDestroy);
AqlValueMaterializer materializer(trx);
setVariable(variable, materializer.slice(item));
bool takeItem = true;
if (filterNode != nullptr) {
// have a filter
bool localMustDestroy;
AqlValue sub = executeSimpleExpression(filterNode, trx,
argv, startPos, vars, regs, localMustDestroy, false);
takeItem = sub.toBoolean();
if (localMustDestroy) { sub.destroy(); }
}
if (takeItem && offset > 0) {
// there is an offset in place
--offset;
takeItem = false;
}
if (takeItem) {
bool localMustDestroy;
AqlValue sub =
executeSimpleExpression(projectionNode, trx, argv,
startPos, vars, regs, localMustDestroy, false);
sub.toVelocyPack(trx, builder);
if (localMustDestroy) { sub.destroy(); }
}
clearVariable(variable);
if (takeItem && count > 0) {
// number of items to pick was restricted
if (--count == 0) {
// done
break;
}
}
}
builder.close();
mustDestroy = true;
return AqlValue(builder); // builder = dynamic data
}
/// @brief execute an expression of type SIMPLE with ITERATOR
AqlValue Expression::executeSimpleExpressionIterator(
AstNode const* node,
arangodb::AqlTransaction* trx, AqlItemBlock const* argv, size_t startPos,
std::vector<Variable const*> const& vars,
std::vector<RegisterId> const& regs, bool& mustDestroy) {
TRI_ASSERT(node != nullptr);
TRI_ASSERT(node->numMembers() == 2);
return executeSimpleExpression(node->getMember(1), trx, argv,
startPos, vars, regs, mustDestroy, true);
}
/// @brief execute an expression of type SIMPLE with BINARY_* (+, -, * , /, %)
AqlValue Expression::executeSimpleExpressionArithmetic(
AstNode const* node, arangodb::AqlTransaction* trx,
AqlItemBlock const* argv, size_t startPos,
std::vector<Variable const*> const& vars,
std::vector<RegisterId> const& regs, bool& mustDestroy) {
AqlValue lhs = executeSimpleExpression(node->getMember(0),
trx, argv, startPos, vars, regs, mustDestroy, true);
AqlValueGuard guardLhs(lhs, mustDestroy);
AqlValue rhs = executeSimpleExpression(node->getMember(1),
trx, argv, startPos, vars, regs, mustDestroy, true);
AqlValueGuard guardRhs(rhs, mustDestroy);
mustDestroy = false;
if (lhs.isObject() || rhs.isObject()) {
TRI_ASSERT(!mustDestroy);
return AqlValue(VelocyPackHelper::NullValue());
}
bool failed = false;
double const l = lhs.toDouble(failed);
if (failed) {
TRI_ASSERT(!mustDestroy);
return AqlValue(VelocyPackHelper::NullValue());
}
double const r = rhs.toDouble(failed);
if (failed) {
TRI_ASSERT(!mustDestroy);
return AqlValue(VelocyPackHelper::NullValue());
}
if (r == 0.0 &&
(node->type == NODE_TYPE_OPERATOR_BINARY_DIV ||
node->type == NODE_TYPE_OPERATOR_BINARY_MOD)) {
TRI_ASSERT(!mustDestroy);
RegisterWarning(_ast, "/", TRI_ERROR_QUERY_DIVISION_BY_ZERO);
return AqlValue(VelocyPackHelper::NullValue());
}
VPackBuilder builder;
mustDestroy = true; // builder = dynamic data
double result;
switch (node->type) {
case NODE_TYPE_OPERATOR_BINARY_PLUS:
result = l + r;
break;
case NODE_TYPE_OPERATOR_BINARY_MINUS:
result = l - r;
break;
case NODE_TYPE_OPERATOR_BINARY_TIMES:
result = l * r;
break;
case NODE_TYPE_OPERATOR_BINARY_DIV:
result = l / r;
break;
case NODE_TYPE_OPERATOR_BINARY_MOD:
result = fmod(l, r);
break;
default:
mustDestroy = false;
return AqlValue(VelocyPackHelper::NullValue());
}
if (std::isnan(result) || !std::isfinite(result) || result == HUGE_VAL || result == -HUGE_VAL) {
// convert NaN, +inf & -inf to 0
mustDestroy = false;
builder.add(VPackValue(0.0));
return AqlValue(builder);
}
builder.add(VPackValue(result));
return AqlValue(builder);
}
Reference in New Issue View Git Blame Copy Permalink