static TRI_aql_node_t* OptimiseUnaryLogicalOperation (TRI_aql_context_t* const context, TRI_aql_node_t* node) { TRI_aql_node_t* operand = TRI_AQL_NODE_MEMBER(node, 0); assert(node->_type == TRI_AQL_NODE_OPERATOR_UNARY_NOT); if (!operand || !TRI_IsConstantValueNodeAql(operand)) { // node is not a constant value return node; } if (!TRI_IsBooleanValueNodeAql(operand)) { // value type is not boolean => error TRI_SetErrorContextAql(context, TRI_ERROR_QUERY_INVALID_LOGICAL_VALUE, NULL); return node; } // ! (bool value) => evaluate and replace with result node = TRI_CreateNodeValueBoolAql(context, ! TRI_GetBooleanNodeValueAql(operand)); if (!node) { TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL); } LOG_TRACE("optimised away unary logical operation"); return node; }
static TRI_aql_node_t* OptimiseReference (TRI_aql_statement_walker_t* const walker, TRI_aql_node_t* node) { TRI_aql_variable_t* variable; TRI_aql_node_t* definingNode; char* variableName = (char*) TRI_AQL_NODE_STRING(node); size_t scopeCount; // ignored assert(variableName); variable = TRI_GetVariableStatementWalkerAql(walker, variableName, &scopeCount); if (variable == NULL) { return node; } definingNode = variable->_definingNode; if (definingNode == NULL) { return node; } if (definingNode->_type == TRI_AQL_NODE_LET) { // variable is defined via a let TRI_aql_node_t* expressionNode; expressionNode = TRI_AQL_NODE_MEMBER(definingNode, 1); if (expressionNode && TRI_IsConstantValueNodeAql(expressionNode)) { // the source variable is constant, so we can replace the reference with // the source's value return expressionNode; } } return node; }
static TRI_aql_node_t* OptimiseUnaryArithmeticOperation (TRI_aql_context_t* const context, TRI_aql_node_t* node) { TRI_aql_node_t* operand = TRI_AQL_NODE_MEMBER(node, 0); assert(node->_type == TRI_AQL_NODE_OPERATOR_UNARY_PLUS || node->_type == TRI_AQL_NODE_OPERATOR_UNARY_MINUS); if (!operand || !TRI_IsConstantValueNodeAql(operand)) { return node; } if (!TRI_IsNumericValueNodeAql(operand)) { TRI_SetErrorContextAql(context, TRI_ERROR_QUERY_INVALID_ARITHMETIC_VALUE, NULL); return node; } if (node->_type == TRI_AQL_NODE_OPERATOR_UNARY_PLUS) { // + number => number node = operand; } else if (node->_type == TRI_AQL_NODE_OPERATOR_UNARY_MINUS) { // - number => eval! node = TRI_CreateNodeValueDoubleAql(context, - TRI_GetNumericNodeValueAql(operand)); if (node == NULL) { TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL); } } return node; }
static TRI_aql_node_t* OptimiseFilter (TRI_aql_statement_walker_t* const walker, TRI_aql_node_t* node) { aql_optimiser_t* optimiser = (aql_optimiser_t*) walker->_data; TRI_aql_node_t* expression = TRI_AQL_NODE_MEMBER(node, 0); while (true) { TRI_vector_pointer_t* oldRanges; TRI_vector_pointer_t* newRanges; bool changed; if (!expression) { return node; } if (TRI_IsConstantValueNodeAql(expression)) { // filter expression is a constant value return OptimiseConstantFilter(expression); } // filter expression is non-constant oldRanges = TRI_GetCurrentRangesStatementWalkerAql(walker); changed = false; newRanges = TRI_OptimiseRangesAql(optimiser->_context, expression, &changed, oldRanges); if (newRanges) { TRI_SetCurrentRangesStatementWalkerAql(walker, newRanges); } if (!changed) { break; } // expression code was changed, set pointer to new value re-optimise it node->_members._buffer[0] = OptimiseNode(walker, expression); expression = TRI_AQL_NODE_MEMBER(node, 0); // next iteration } return node; }
static TRI_aql_node_t* OptimiseSort (TRI_aql_statement_walker_t* const walker, TRI_aql_node_t* node) { TRI_aql_node_t* list = TRI_AQL_NODE_MEMBER(node, 0); size_t i, n; if (!list) { return node; } i = 0; n = list->_members._length; while (i < n) { // sort element TRI_aql_node_t* element = TRI_AQL_NODE_MEMBER(list, i); TRI_aql_node_t* expression = TRI_AQL_NODE_MEMBER(element, 0); // check if the sort element is constant if (!expression || !TRI_IsConstantValueNodeAql(expression)) { ++i; continue; } // sort element is constant so it can be removed TRI_RemoveVectorPointer(&list->_members, i); --n; LOG_TRACE("optimised away sort element"); } if (n == 0) { // no members left => sort removed LOG_TRACE("optimised away sort"); return TRI_GetDummyNopNodeAql(); } return node; }
static void AttachCollectionHint (TRI_aql_context_t* const context, TRI_aql_node_t* const node) { TRI_aql_node_t* nameNode = TRI_AQL_NODE_MEMBER(node, 0); TRI_vector_pointer_t* availableIndexes; TRI_aql_collection_hint_t* hint; TRI_aql_index_t* idx; TRI_aql_collection_t* collection; char* collectionName; collectionName = TRI_AQL_NODE_STRING(nameNode); assert(collectionName); hint = (TRI_aql_collection_hint_t*) TRI_AQL_NODE_DATA(node); if (hint == NULL) { TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL); return; } if (hint->_ranges == NULL) { // no ranges found to be used as indexes return; } collection = TRI_GetCollectionAql(context, collectionName); if (collection == NULL) { TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL); return; } hint->_collection = collection; availableIndexes = &(((TRI_document_collection_t*) collection->_collection->_collection)->_allIndexes); if (availableIndexes == NULL) { TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL); return; } idx = TRI_DetermineIndexAql(context, availableIndexes, collectionName, hint->_ranges); hint->_index = idx; }
static TRI_aql_node_t* OptimiseTernaryOperation (TRI_aql_context_t* const context, TRI_aql_node_t* node) { TRI_aql_node_t* condition = TRI_AQL_NODE_MEMBER(node, 0); TRI_aql_node_t* truePart = TRI_AQL_NODE_MEMBER(node, 1); TRI_aql_node_t* falsePart = TRI_AQL_NODE_MEMBER(node, 2); assert(node->_type == TRI_AQL_NODE_OPERATOR_TERNARY); if (!condition || !TRI_IsConstantValueNodeAql(condition)) { // node is not a constant value return node; } if (!TRI_IsBooleanValueNodeAql(condition)) { // node is not a boolean value => error TRI_SetErrorContextAql(context, TRI_ERROR_QUERY_INVALID_LOGICAL_VALUE, NULL); return node; } if (!truePart || !falsePart) { // true or false parts not defined // should not happen but we must not continue in this case return node; } LOG_TRACE("optimised away ternary operation"); // evaluate condition if (TRI_GetBooleanNodeValueAql(condition)) { // condition is true, replace with truePart return truePart; } // condition is true, replace with falsePart return falsePart; }
void TRI_GlobalFreeStatementListAql (void) { if (DummyNopNode != NULL) { TRI_DestroyVectorPointer(&DummyNopNode->_members); TRI_Free(TRI_UNKNOWN_MEM_ZONE, DummyNopNode); } if (DummyReturnEmptyNode != NULL) { TRI_aql_node_t* list = TRI_AQL_NODE_MEMBER(DummyReturnEmptyNode, 0); TRI_DestroyVectorPointer(&list->_members); TRI_Free(TRI_UNKNOWN_MEM_ZONE, list); TRI_DestroyVectorPointer(&DummyReturnEmptyNode->_members); TRI_Free(TRI_UNKNOWN_MEM_ZONE, DummyReturnEmptyNode); } }
static TRI_aql_node_t* OptimiseFor (TRI_aql_statement_walker_t* const walker, TRI_aql_node_t* node) { TRI_aql_node_t* expression = TRI_AQL_NODE_MEMBER(node, 1); if (expression->_type == TRI_AQL_NODE_LIST) { // for statement with a list expression if (expression->_members._length == 0) { // list is empty => we can eliminate the for statement LOG_TRACE("optimised away empty for loop"); return TRI_GetDummyReturnEmptyNodeAql(); } } return node; }
static void SetWriteOperation (TRI_aql_context_t* context, TRI_aql_node_t const* collection, TRI_aql_query_type_e type, TRI_aql_node_t* options) { if (context->_writeCollection != nullptr || context->_type != TRI_AQL_QUERY_READ) { TRI_SetErrorContextAql(__FILE__, __LINE__, context, TRI_ERROR_QUERY_MULTI_MODIFY, nullptr); return; } if (context->_subQueries > 0) { TRI_SetErrorContextAql(__FILE__, __LINE__, context, TRI_ERROR_QUERY_MODIFY_IN_SUBQUERY, nullptr); return; } if (collection->_type == TRI_AQL_NODE_COLLECTION) { // collection specified by name TRI_aql_node_t* nameNode = TRI_AQL_NODE_MEMBER(collection, 0); if (nameNode == nullptr) { TRI_SetErrorContextAql(__FILE__, __LINE__, context, TRI_ERROR_OUT_OF_MEMORY, nullptr); return; } context->_writeCollection = TRI_AQL_NODE_STRING(nameNode); } else if (collection->_type == TRI_AQL_NODE_PARAMETER) { // collection specified via bind parameter context->_writeCollection = TRI_AQL_NODE_STRING(collection); } else { TRI_SetErrorContextAql(__FILE__, __LINE__, context, TRI_ERROR_INTERNAL, nullptr); TRI_ASSERT(false); return; } if (options != nullptr) { if (! TRI_IsConstantValueNodeAql(options)) { TRI_SetErrorContextAql(__FILE__, __LINE__, context, TRI_ERROR_QUERY_COMPILE_TIME_OPTIONS, nullptr); return; } } context->_type = type; context->_writeOptions = options; }
static TRI_aql_node_t* FixAttributeAccess (TRI_aql_statement_walker_t* const walker, TRI_aql_node_t* node) { TRI_aql_context_t* context; TRI_aql_node_t* valueNode; char* stringValue; if (node == NULL || node->_type != TRI_AQL_NODE_BOUND_ATTRIBUTE_ACCESS) { return node; } // we found a bound attribute access context = (TRI_aql_context_t*) walker->_data; assert(context); assert(node->_members._length == 2); valueNode = TRI_AQL_NODE_MEMBER(node, 1); if (valueNode == NULL) { TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL); return node; } if (valueNode->_type != TRI_AQL_NODE_VALUE || valueNode->_value._type != TRI_AQL_TYPE_STRING) { TRI_SetErrorContextAql(context, TRI_ERROR_QUERY_BIND_PARAMETER_TYPE, "(unknown)"); return node; } stringValue = TRI_AQL_NODE_STRING(valueNode); if (stringValue == NULL || strlen(stringValue) == 0) { TRI_SetErrorContextAql(context, TRI_ERROR_QUERY_BIND_PARAMETER_TYPE, "(unknown)"); return node; } // remove second node TRI_RemoveVectorPointer(&node->_members, 1); // set attribute name TRI_AQL_NODE_STRING(node) = stringValue; // convert node type node->_type = TRI_AQL_NODE_ATTRIBUTE_ACCESS; return node; }
static bool AppendListValues (TRI_string_buffer_t* const buffer, const TRI_aql_node_t* const node, convert_f func) { size_t i, n; n = node->_members._length; for (i = 0; i < n; ++i) { if (i > 0) { if (TRI_AppendStringStringBuffer(buffer, ", ") != TRI_ERROR_NO_ERROR) { return false; } } if (! func(buffer, TRI_AQL_NODE_MEMBER(node, i))) { return false; } } return true; }
bool TRI_NodeJavascriptAql (TRI_string_buffer_t* const buffer, const TRI_aql_node_t* const node) { switch (node->_type) { case TRI_AQL_NODE_VALUE: return TRI_ValueJavascriptAql(buffer, &node->_value, node->_value._type); case TRI_AQL_NODE_ARRAY_ELEMENT: if (! TRI_ValueJavascriptAql(buffer, &node->_value, TRI_AQL_TYPE_STRING)) { return false; } if (TRI_AppendCharStringBuffer(buffer, ':') != TRI_ERROR_NO_ERROR) { return false; } return TRI_NodeJavascriptAql(buffer, TRI_AQL_NODE_MEMBER(node, 0)); case TRI_AQL_NODE_LIST: if (TRI_AppendCharStringBuffer(buffer, '[') != TRI_ERROR_NO_ERROR) { return false; } if (! AppendListValues(buffer, node, &TRI_NodeJavascriptAql)) { return false; } return (TRI_AppendCharStringBuffer(buffer, ']') == TRI_ERROR_NO_ERROR); case TRI_AQL_NODE_ARRAY: if (TRI_AppendCharStringBuffer(buffer, '{') != TRI_ERROR_NO_ERROR) { return false; } if (! AppendListValues(buffer, node, &TRI_NodeJavascriptAql)) { return false; } return (TRI_AppendCharStringBuffer(buffer, '}') == TRI_ERROR_NO_ERROR); default: return false; } }
static void PatchVariables (TRI_aql_statement_walker_t* const walker) { TRI_aql_context_t* context = ((aql_optimiser_t*) walker->_data)->_context; TRI_vector_pointer_t* ranges; size_t i, n; ranges = TRI_GetCurrentRangesStatementWalkerAql(walker); if (ranges == NULL) { // no ranges defined, exit early return; } // iterate over all ranges found n = ranges->_length; for (i = 0; i < n; ++i) { TRI_aql_field_access_t* fieldAccess; TRI_aql_variable_t* variable; TRI_aql_node_t* definingNode; TRI_aql_node_t* expressionNode; char* variableName; size_t scopeCount; bool isReference; fieldAccess = (TRI_aql_field_access_t*) TRI_AtVectorPointer(ranges, i); assert(fieldAccess); assert(fieldAccess->_fullName); assert(fieldAccess->_variableNameLength > 0); variableName = TRI_DuplicateString2Z(TRI_UNKNOWN_MEM_ZONE, fieldAccess->_fullName, fieldAccess->_variableNameLength); if (variableName == NULL) { // out of memory! TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL); return; } isReference = (fieldAccess->_type == TRI_AQL_ACCESS_REFERENCE); variable = TRI_GetVariableStatementWalkerAql(walker, variableName, &scopeCount); TRI_FreeString(TRI_UNKNOWN_MEM_ZONE, variableName); if (variable == NULL) { continue; } if (isReference && scopeCount > 0) { // unfortunately, the referenced variable is in an outer scope, so we cannot use it continue; } // note: we must not modify outer variables of subqueries // get the node that defines the variable definingNode = variable->_definingNode; assert(definingNode != NULL); expressionNode = NULL; switch (definingNode->_type) { case TRI_AQL_NODE_LET: expressionNode = TRI_AQL_NODE_MEMBER(definingNode, 1); break; case TRI_AQL_NODE_FOR: expressionNode = TRI_AQL_NODE_MEMBER(definingNode, 1); break; default: { } } if (expressionNode != NULL) { if (expressionNode->_type == TRI_AQL_NODE_FCALL) { // the defining node is a function call // get the function name TRI_aql_function_t* function = TRI_AQL_NODE_DATA(expressionNode); if (function->optimise != NULL) { // call the function's optimise callback function->optimise(expressionNode, context, fieldAccess); } } if (expressionNode->_type == TRI_AQL_NODE_COLLECTION) { TRI_aql_collection_hint_t* hint = (TRI_aql_collection_hint_t*) (TRI_AQL_NODE_DATA(expressionNode)); // set new value hint->_ranges = TRI_AddAccessAql(context, hint->_ranges, fieldAccess); } } } }
bool TRI_ValidateArgsFunctionAql (TRI_aql_context_t* const context, const TRI_aql_function_t* const function, const TRI_aql_node_t* const parameters) { param_t allowed; const char* pattern; size_t i, n; bool eof = false; bool repeat = false; assert(function); assert(parameters); assert(parameters->_type == TRI_AQL_NODE_LIST); n = parameters->_members._length; // validate number of arguments if (n < function->_minArgs || n > function->_maxArgs) { // invalid number of arguments TRI_SetErrorContextAql(context, TRI_ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH, function->_externalName); return false; } pattern = function->_argPattern; // validate argument types for (i = 0; i < n; ++i) { TRI_aql_node_t* parameter = (TRI_aql_node_t*) TRI_AQL_NODE_MEMBER(parameters, i); bool parse = true; bool foundArg = false; if (repeat) { // last argument is repeated ARG_CHECK } else { // last argument is not repeated allowed = InitParam(); foundArg = false; while (parse && !eof) { char c = *pattern++; switch (c) { case '\0': parse = false; eof = true; if (foundArg) { ARG_CHECK } break; case '|': // optional marker if (foundArg) { parse = false; ARG_CHECK if (*pattern == '+') { repeat = true; eof = true; } } break; case ',': // next argument assert(foundArg); parse = false; ARG_CHECK break; case '+': // repeat last argument repeat = true; parse = false; eof = true; ARG_CHECK break; case '.': // any type except collections allowed._list = true; allowed._array = true; // break intentionally missing!! case 'p': // primitive types allowed._null = true; allowed._bool = true; allowed._number = true; allowed._string = true; foundArg = true; break; case 'z': // null allowed._null = true; foundArg = true; break; case 'b': // bool allowed._bool = true; foundArg = true; break; case 'n': // number allowed._number = true; foundArg = true; break; case 's': // string allowed._string = true; foundArg = true; break; case 'l': // list allowed._list = true; foundArg = true; break; case 'a': // array allowed._array = true; foundArg = true; break; case 'c': // collection name => list allowed._collection = true; foundArg = true; break; case 'h': // collection name => string allowed._collection = true; foundArg = true; break; } } } }
static TRI_aql_node_t* OptimiseBinaryLogicalOperation (TRI_aql_context_t* const context, TRI_aql_node_t* node) { TRI_aql_node_t* lhs = TRI_AQL_NODE_MEMBER(node, 0); TRI_aql_node_t* rhs = TRI_AQL_NODE_MEMBER(node, 1); bool isEligibleLhs; bool isEligibleRhs; bool lhsValue; if (!lhs || !rhs) { return node; } isEligibleLhs = TRI_IsConstantValueNodeAql(lhs); isEligibleRhs = TRI_IsConstantValueNodeAql(rhs); if (isEligibleLhs && !TRI_IsBooleanValueNodeAql(lhs)) { // value type is not boolean => error TRI_SetErrorContextAql(context, TRI_ERROR_QUERY_INVALID_LOGICAL_VALUE, NULL); return node; } if (isEligibleRhs && !TRI_IsBooleanValueNodeAql(rhs)) { // value type is not boolean => error TRI_SetErrorContextAql(context, TRI_ERROR_QUERY_INVALID_LOGICAL_VALUE, NULL); return node; } if (!isEligibleLhs || !isEligibleRhs) { // node is not a constant value return node; } lhsValue = TRI_GetBooleanNodeValueAql(lhs); assert(node->_type == TRI_AQL_NODE_OPERATOR_BINARY_AND || node->_type == TRI_AQL_NODE_OPERATOR_BINARY_OR); LOG_TRACE("optimised away binary logical operation"); if (node->_type == TRI_AQL_NODE_OPERATOR_BINARY_AND) { if (lhsValue) { // if (true && rhs) => rhs return rhs; } // if (false && rhs) => false return lhs; } else if (node->_type == TRI_AQL_NODE_OPERATOR_BINARY_OR) { if (lhsValue) { // if (true || rhs) => true return lhs; } // if (false || rhs) => rhs return rhs; } assert(false); return node; }
bool TRI_NodeStringAql (TRI_string_buffer_t* const buffer, const TRI_aql_node_t* const node) { switch (node->_type) { case TRI_AQL_NODE_VALUE: { return TRI_ValueStringAql(buffer, &node->_value, node->_value._type); } case TRI_AQL_NODE_ARRAY_ELEMENT: { if (! TRI_ValueStringAql(buffer, &node->_value, TRI_AQL_TYPE_STRING)) { return false; } if (TRI_AppendStringStringBuffer(buffer, " : ") != TRI_ERROR_NO_ERROR) { return false; } return TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 0)); } case TRI_AQL_NODE_LIST: { if (TRI_AppendStringStringBuffer(buffer, "[ ") != TRI_ERROR_NO_ERROR) { return false; } if (! AppendListValues(buffer, node, &TRI_NodeStringAql)) { return false; } return (TRI_AppendStringStringBuffer(buffer, " ]") == TRI_ERROR_NO_ERROR); } case TRI_AQL_NODE_ARRAY: { if (TRI_AppendStringStringBuffer(buffer, "{ ") != TRI_ERROR_NO_ERROR) { return false; } if (! AppendListValues(buffer, node, &TRI_NodeStringAql)) { return false; } return (TRI_AppendStringStringBuffer(buffer, " }") == TRI_ERROR_NO_ERROR); } case TRI_AQL_NODE_OPERATOR_UNARY_PLUS: case TRI_AQL_NODE_OPERATOR_UNARY_MINUS: case TRI_AQL_NODE_OPERATOR_UNARY_NOT: { if (TRI_AppendStringStringBuffer(buffer, GetStringOperator(node->_type)) != TRI_ERROR_NO_ERROR) { return false; } return TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 0)); } case TRI_AQL_NODE_OPERATOR_BINARY_AND: case TRI_AQL_NODE_OPERATOR_BINARY_OR: case TRI_AQL_NODE_OPERATOR_BINARY_PLUS: case TRI_AQL_NODE_OPERATOR_BINARY_MINUS: case TRI_AQL_NODE_OPERATOR_BINARY_TIMES: case TRI_AQL_NODE_OPERATOR_BINARY_DIV: case TRI_AQL_NODE_OPERATOR_BINARY_MOD: case TRI_AQL_NODE_OPERATOR_BINARY_EQ: case TRI_AQL_NODE_OPERATOR_BINARY_NE: case TRI_AQL_NODE_OPERATOR_BINARY_LT: case TRI_AQL_NODE_OPERATOR_BINARY_LE: case TRI_AQL_NODE_OPERATOR_BINARY_GT: case TRI_AQL_NODE_OPERATOR_BINARY_GE: case TRI_AQL_NODE_OPERATOR_BINARY_IN: { if (! TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 0))) { return false; } if (TRI_AppendStringStringBuffer(buffer, GetStringOperator(node->_type)) != TRI_ERROR_NO_ERROR) { return false; } return TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 1)); } case TRI_AQL_NODE_OPERATOR_TERNARY: { if (! TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 0))) { return false; } if (TRI_AppendStringStringBuffer(buffer, " ? ") != TRI_ERROR_NO_ERROR) { return false; } if (! TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 1))) { return false; } if (TRI_AppendStringStringBuffer(buffer, " : ") != TRI_ERROR_NO_ERROR) { return false; } return TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 2)); } case TRI_AQL_NODE_ATTRIBUTE_ACCESS: { if (! TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 0))) { return false; } if (TRI_AppendStringStringBuffer(buffer, ".") != TRI_ERROR_NO_ERROR) { return false; } return TRI_AppendStringStringBuffer(buffer, TRI_AQL_NODE_STRING(node)) == TRI_ERROR_NO_ERROR; } case TRI_AQL_NODE_INDEXED: { if (! TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 0))) { return false; } if (TRI_AppendStringStringBuffer(buffer, "[") != TRI_ERROR_NO_ERROR) { return false; } if (! TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 1))) { return false; } return TRI_AppendStringStringBuffer(buffer, "]") == TRI_ERROR_NO_ERROR; } case TRI_AQL_NODE_FCALL: { TRI_aql_function_t* function = (TRI_aql_function_t*) TRI_AQL_NODE_DATA(node); if (TRI_AppendStringStringBuffer(buffer, function->_externalName) != TRI_ERROR_NO_ERROR) { return false; } if (TRI_AppendStringStringBuffer(buffer, "(") != TRI_ERROR_NO_ERROR) { return false; } if (! TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 0))) { return false; } return TRI_AppendStringStringBuffer(buffer, ")") == TRI_ERROR_NO_ERROR; } case TRI_AQL_NODE_EXPAND: { return TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 3)); } case TRI_AQL_NODE_REFERENCE: { return TRI_AppendStringStringBuffer(buffer, TRI_AQL_NODE_STRING(node)) == TRI_ERROR_NO_ERROR; } case TRI_AQL_NODE_COLLECTION: { TRI_aql_node_t* nameNode = TRI_AQL_NODE_MEMBER(node, 0); char* name = TRI_AQL_NODE_STRING(nameNode); return TRI_AppendStringStringBuffer(buffer, name) == TRI_ERROR_NO_ERROR; } case TRI_AQL_NODE_SORT: { return TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 0)); } case TRI_AQL_NODE_SORT_ELEMENT: { if (! TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 0))) { return false; } return TRI_AppendStringStringBuffer(buffer, (TRI_AQL_NODE_BOOL(node) ? " ASC" : " DESC")) == TRI_ERROR_NO_ERROR; } case TRI_AQL_NODE_ASSIGN: { TRI_aql_node_t* nameNode = TRI_AQL_NODE_MEMBER(node, 0); char* name = TRI_AQL_NODE_STRING(nameNode); if (TRI_AppendStringStringBuffer(buffer, name) != TRI_ERROR_NO_ERROR) { return false; } if (TRI_AppendStringStringBuffer(buffer, " = ") != TRI_ERROR_NO_ERROR) { return false; } return TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 1)); } default: { // nadata } } return true; }
TRI_json_t* TRI_NodeJsonAql (TRI_aql_context_t* const context, const TRI_aql_node_t* const node) { switch (node->_type) { case TRI_AQL_NODE_VALUE: { switch (node->_value._type) { case TRI_AQL_TYPE_FAIL: case TRI_AQL_TYPE_NULL: return TRI_CreateNullJson(TRI_UNKNOWN_MEM_ZONE); case TRI_AQL_TYPE_BOOL: return TRI_CreateBooleanJson(TRI_UNKNOWN_MEM_ZONE, node->_value._value._bool); case TRI_AQL_TYPE_INT: return TRI_CreateNumberJson(TRI_UNKNOWN_MEM_ZONE, (double) node->_value._value._int); case TRI_AQL_TYPE_DOUBLE: return TRI_CreateNumberJson(TRI_UNKNOWN_MEM_ZONE, node->_value._value._double); case TRI_AQL_TYPE_STRING: return TRI_CreateStringCopyJson(TRI_UNKNOWN_MEM_ZONE, node->_value._value._string); } } case TRI_AQL_NODE_LIST: { TRI_json_t* result = TRI_CreateListJson(TRI_UNKNOWN_MEM_ZONE); if (result) { size_t i, n; n = node->_members._length; for (i = 0; i < n; ++i) { TRI_json_t* subValue = TRI_NodeJsonAql(context, TRI_AQL_NODE_MEMBER(node, i)); if (subValue) { TRI_PushBack3ListJson(TRI_UNKNOWN_MEM_ZONE, result, subValue); } } } return result; } case TRI_AQL_NODE_ARRAY: { TRI_json_t* result = TRI_CreateArrayJson(TRI_UNKNOWN_MEM_ZONE); if (result) { size_t i, n; n = node->_members._length; for (i = 0; i < n; ++i) { TRI_aql_node_t* element = TRI_AQL_NODE_MEMBER(node, i); TRI_json_t* subValue = TRI_NodeJsonAql(context, TRI_AQL_NODE_MEMBER(element, 0)); if (subValue) { TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, result, TRI_AQL_NODE_STRING(element), subValue); } } } return result; } default: { return NULL; } } }
static void OptimisePaths (const TRI_aql_node_t* const fcallNode, TRI_aql_context_t* const context, TRI_aql_field_access_t* fieldAccess) { TRI_aql_node_t* args; TRI_aql_node_t* vertexCollection; TRI_aql_node_t* edgeCollection; TRI_aql_node_t* direction; char* directionValue; char* name; size_t n; args = TRI_AQL_NODE_MEMBER(fcallNode, 0); if (args == NULL) { return; } vertexCollection = TRI_AQL_NODE_MEMBER(args, 0); edgeCollection = TRI_AQL_NODE_MEMBER(args, 1); direction = TRI_AQL_NODE_MEMBER(args, 2); assert(vertexCollection); assert(edgeCollection); assert(direction); assert(fieldAccess); n = strlen(fieldAccess->_fullName); name = fieldAccess->_fullName + fieldAccess->_variableNameLength; directionValue = TRI_AQL_NODE_STRING(direction); // try to optimise the vertex collection access if (TRI_EqualString(directionValue, "outbound")) { CheckPathRestriction(fieldAccess, context, vertexCollection, ".source.", name, n); } else if (TRI_EqualString(directionValue, "inbound")) { CheckPathRestriction(fieldAccess, context, vertexCollection, ".source.", name, n); } else if (TRI_EqualString(directionValue, "any")) { // "any" cannot be optimised sanely becuase the conditions would be AND-combined // (but for "any", we'd need them OR-combined) // CheckPathRestriction(fieldAccess, context, vertexCollection, ".source.", name, n); // CheckPathRestriction(fieldAccess, context, vertexCollection, ".destination.", name, n); } // check if we have a filter on LENGTH(edges) if (args->_members._length <= 4 && TRI_EqualString(name, ".edges.LENGTH()")) { // length restriction, can only be applied if length parameters are not already set TRI_json_t* value; double minValue = 0.0; double maxValue = 0.0; bool useMin = false; bool useMax = false; if (fieldAccess->_type == TRI_AQL_ACCESS_EXACT) { value = fieldAccess->_value._value; if (value != NULL && value->_type == TRI_JSON_NUMBER) { // LENGTH(p.edges) == const minValue = maxValue = value->_value._number; useMin = useMax = true; } } else if (fieldAccess->_type == TRI_AQL_ACCESS_RANGE_SINGLE) { value = fieldAccess->_value._singleRange._value; if (value != NULL && value->_type == TRI_JSON_NUMBER) { // LENGTH(p.edges) operator const if (fieldAccess->_value._singleRange._type == TRI_AQL_RANGE_LOWER_INCLUDED) { minValue = value->_value._number; useMin = true; } else if (fieldAccess->_value._singleRange._type == TRI_AQL_RANGE_UPPER_INCLUDED) { maxValue = value->_value._number; useMax = true; } else if (fieldAccess->_value._singleRange._type == TRI_AQL_RANGE_LOWER_EXCLUDED) { if ((double) ((int) value->_value._number) == value->_value._number) { minValue = value->_value._number + 1.0; useMin = true; } } else if (fieldAccess->_value._singleRange._type == TRI_AQL_RANGE_UPPER_EXCLUDED) { if ((double) ((int) value->_value._number) == value->_value._number) { maxValue = value->_value._number - 1.0; useMax = true; } } } } else if (fieldAccess->_type == TRI_AQL_ACCESS_RANGE_DOUBLE) { // LENGTH(p.edges) > const && LENGTH(p.edges) < const value = fieldAccess->_value._between._lower._value; if (value != NULL && value->_type == TRI_JSON_NUMBER) { if (fieldAccess->_value._between._lower._type == TRI_AQL_RANGE_LOWER_INCLUDED) { minValue = value->_value._number; useMin = true; } else if (fieldAccess->_value._between._lower._type == TRI_AQL_RANGE_LOWER_EXCLUDED) { if ((double) ((int) value->_value._number) == value->_value._number) { minValue = value->_value._number + 1.0; useMin = true; } } } value = fieldAccess->_value._between._upper._value; if (value != NULL && value->_type == TRI_JSON_NUMBER) { if (fieldAccess->_value._between._upper._type == TRI_AQL_RANGE_UPPER_INCLUDED) { maxValue = value->_value._number; useMax = true; } else if (fieldAccess->_value._between._upper._type == TRI_AQL_RANGE_UPPER_EXCLUDED) { if ((double) ((int) value->_value._number) == value->_value._number) { maxValue = value->_value._number - 1.0; useMax = true; } } } } if (useMin || useMax) { TRI_aql_node_t* argNode; // minLength and maxLength are parameters 5 & 6 // add as many null value nodes as are missing while (args->_members._length < 4) { argNode = TRI_CreateNodeValueNullAql(context); if (argNode) { TRI_PushBackVectorPointer(&args->_members, (void*) argNode); } } // add min and max values to the function call argument list argNode = TRI_CreateNodeValueIntAql(context, useMin ? (int64_t) minValue : (int64_t) 0); if (argNode) { // min value node TRI_PushBackVectorPointer(&args->_members, (void*) argNode); argNode = TRI_CreateNodeValueIntAql(context, useMax ? (int64_t) maxValue : (int64_t) (1024 * 1024)); if (argNode) { // max value node TRI_PushBackVectorPointer(&args->_members, (void*) argNode); } } } } }
static TRI_aql_node_t* ProcessStatement (TRI_aql_statement_walker_t* const walker, TRI_aql_node_t* node) { TRI_aql_explain_t* explain; TRI_aql_node_type_e type = node->_type; explain = (TRI_aql_explain_t*) walker->_data; switch (type) { case TRI_AQL_NODE_SCOPE_START: { TRI_aql_scope_t* scope = (TRI_aql_scope_t*) TRI_AQL_NODE_DATA(node); assert(scope); if (scope->_type != TRI_AQL_SCOPE_SUBQUERY && scope->_type != TRI_AQL_SCOPE_MAIN) { ++explain->_level; } break; } case TRI_AQL_NODE_SCOPE_END: { TRI_aql_scope_t* scope = (TRI_aql_scope_t*) TRI_AQL_NODE_DATA(node); assert(scope); if (scope->_type != TRI_AQL_SCOPE_SUBQUERY && scope->_type != TRI_AQL_SCOPE_MAIN) { --explain->_level; } break; } case TRI_AQL_NODE_EXPAND: { TRI_json_t* row; row = GetRowProtoType(explain, TRI_AQL_NODE_REFERENCE); if (row != NULL) { TRI_aql_node_t* variableNode = TRI_AQL_NODE_MEMBER(node, 0); TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, row, "resultVariable", TRI_CreateStringCopyJson(TRI_UNKNOWN_MEM_ZONE, TRI_AQL_NODE_STRING(variableNode))); AddNodeValue(row, TRI_AQL_NODE_MEMBER(node, 2)); AddRow(explain, row); } row = GetRowProtoType(explain, TRI_AQL_NODE_EXPAND); if (row != NULL) { TRI_aql_node_t* variableNode = TRI_AQL_NODE_MEMBER(node, 1); TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, row, "resultVariable", TRI_CreateStringCopyJson(TRI_UNKNOWN_MEM_ZONE, TRI_AQL_NODE_STRING(variableNode))); AddNodeValue(row, TRI_AQL_NODE_MEMBER(node, 3)); AddRow(explain, row); } break; } case TRI_AQL_NODE_SUBQUERY: case TRI_AQL_NODE_SUBQUERY_CACHED: { TRI_json_t* row; row = GetRowProtoType(explain, node->_type); if (row != NULL) { TRI_aql_node_t* variableNode = TRI_AQL_NODE_MEMBER(node, 0); TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, row, "resultVariable", TRI_CreateStringCopyJson(TRI_UNKNOWN_MEM_ZONE, TRI_AQL_NODE_STRING(variableNode))); AddRow(explain, row); } break; } case TRI_AQL_NODE_FOR: { TRI_json_t* row; row = GetRowProtoType(explain, node->_type); if (row != NULL) { TRI_aql_node_t* variableNode = TRI_AQL_NODE_MEMBER(node, 0); TRI_aql_node_t* expressionNode = TRI_AQL_NODE_MEMBER(node, 1); TRI_aql_for_hint_t* hint; TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, row, "resultVariable", TRI_CreateStringCopyJson(TRI_UNKNOWN_MEM_ZONE, TRI_AQL_NODE_STRING(variableNode))); hint = TRI_AQL_NODE_DATA(node); if (hint != NULL && hint->_limit._status == TRI_AQL_LIMIT_USE) { TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, row, "limit", TRI_CreateBooleanJson(TRI_UNKNOWN_MEM_ZONE, true)); } AddNodeValue(row, expressionNode); AddRow(explain, row); } break; } case TRI_AQL_NODE_RETURN: case TRI_AQL_NODE_RETURN_EMPTY: { TRI_json_t* row; row = GetRowProtoType(explain, node->_type); if (row != NULL) { TRI_aql_node_t* expressionNode = TRI_AQL_NODE_MEMBER(node, 0); AddNodeValue(row, expressionNode); AddRow(explain, row); } break; } case TRI_AQL_NODE_FILTER: { TRI_json_t* row; row = GetRowProtoType(explain, node->_type); if (row != NULL) { TRI_aql_node_t* expressionNode = TRI_AQL_NODE_MEMBER(node, 0); AddNodeValue(row, expressionNode); AddRow(explain, row); } break; } case TRI_AQL_NODE_LET: { TRI_json_t* row; row = GetRowProtoType(explain, node->_type); if (row != NULL) { TRI_aql_node_t* variableNode = TRI_AQL_NODE_MEMBER(node, 0); TRI_aql_node_t* expressionNode = TRI_AQL_NODE_MEMBER(node, 1); TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, row, "resultVariable", TRI_CreateStringCopyJson(TRI_UNKNOWN_MEM_ZONE, TRI_AQL_NODE_STRING(variableNode))); AddNodeValue(row, expressionNode); AddRow(explain, row); } break; } case TRI_AQL_NODE_SORT: { TRI_json_t* row; row = GetRowProtoType(explain, node->_type); if (row != NULL) { TRI_aql_node_t* listNode = TRI_AQL_NODE_MEMBER(node, 0); AddNodeValue(row, listNode); AddRow(explain, row); } break; } case TRI_AQL_NODE_LIMIT: { TRI_json_t* row; row = GetRowProtoType(explain, node->_type); if (row != NULL) { TRI_aql_node_t* offsetNode = TRI_AQL_NODE_MEMBER(node, 0); TRI_aql_node_t* countNode = TRI_AQL_NODE_MEMBER(node, 1); TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, row, "offset", TRI_NodeJsonAql(explain->_context, offsetNode)); TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, row, "count", TRI_NodeJsonAql(explain->_context, countNode)); AddRow(explain, row); } break; } case TRI_AQL_NODE_COLLECT: { TRI_json_t* row; row = GetRowProtoType(explain, node->_type); if (row != NULL) { TRI_aql_node_t* listNode = TRI_AQL_NODE_MEMBER(node, 0); if (node->_members._length > 1) { TRI_aql_node_t* variableNode = TRI_AQL_NODE_MEMBER(node, 1); TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, row, "resultVariable", TRI_CreateStringCopyJson(TRI_UNKNOWN_MEM_ZONE, TRI_AQL_NODE_STRING(variableNode))); } AddNodeValue(row, listNode); AddRow(explain, row); } break; } default: { } } return NULL; }
static void OptimisePaths (const TRI_aql_node_t* const fcallNode, TRI_aql_context_t* const context, TRI_aql_field_access_t* fieldAccess) { TRI_aql_collection_hint_t* hint; TRI_aql_node_t* args; TRI_aql_node_t* vertexCollection; TRI_aql_node_t* edgeCollection; TRI_aql_node_t* direction; char* directionValue; char* name; const char* lookFor; size_t len; size_t n; args = TRI_AQL_NODE_MEMBER(fcallNode, 0); if (args == NULL) { return; } vertexCollection = TRI_AQL_NODE_MEMBER(args, 0); edgeCollection = TRI_AQL_NODE_MEMBER(args, 1); direction = TRI_AQL_NODE_MEMBER(args, 2); assert(vertexCollection); assert(edgeCollection); assert(direction); assert(fieldAccess); n = strlen(fieldAccess->_fullName); name = fieldAccess->_fullName + fieldAccess->_variableNameLength; directionValue = TRI_AQL_NODE_STRING(direction); // try to optimise the vertex collection access if (TRI_EqualString(directionValue, "outbound")) { lookFor = ".source."; len = strlen(lookFor); } else if (TRI_EqualString(directionValue, "inbound")) { lookFor = ".destination."; len = strlen(lookFor); } else { lookFor = NULL; len = 0; } if (len > 0 && n > fieldAccess->_variableNameLength + len && memcmp((void*) lookFor, (void*) name, len) == 0) { // field name is collection.source.XXX, e.g. users.source._id LOG_DEBUG("optimising PATHS() field access %s", fieldAccess->_fullName); // we can now modify this fieldaccess in place to collection.XXX, e.g. users._id // copy trailing \0 byte as well memmove(name, name + len - 1, n - fieldAccess->_variableNameLength - len + 2); // attach the modified fieldaccess to the collection hint = (TRI_aql_collection_hint_t*) (TRI_AQL_NODE_DATA(vertexCollection)); hint->_ranges = TRI_AddAccessAql(context, hint->_ranges, fieldAccess); } }
static TRI_aql_node_t* OptimiseFcall (TRI_aql_context_t* const context, TRI_aql_node_t* node) { TRI_aql_node_t* args = TRI_AQL_NODE_MEMBER(node, 0); TRI_aql_function_t* function; TRI_js_exec_context_t* execContext; TRI_string_buffer_t* code; TRI_json_t* json; size_t i; size_t n; function = (TRI_aql_function_t*) TRI_AQL_NODE_DATA(node); assert(function); // check if function is deterministic if (!function->_isDeterministic) { return node; } // check if function call arguments are deterministic n = args->_members._length; for (i = 0; i < n; ++i) { TRI_aql_node_t* arg = (TRI_aql_node_t*) args->_members._buffer[i]; if (!arg || !TRI_IsConstantValueNodeAql(arg)) { return node; } } // all arguments are constants // create the function code code = FcallCode(function->_internalName, args); if (!code) { TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL); return node; } // execute the function code execContext = TRI_CreateExecutionContext(code->_buffer); TRI_FreeStringBuffer(TRI_UNKNOWN_MEM_ZONE, code); if (!execContext) { TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL); return node; } json = TRI_ExecuteResultContext(execContext); TRI_FreeExecutionContext(execContext); if (!json) { // cannot optimise the function call due to an internal error // TODO: check whether we can validate the arguments here already and return an error early // TRI_SetErrorContextAql(context, TRI_ERROR_QUERY_SCRIPT, "function optimisation"); return node; } // use the constant values instead of the function call node node = TRI_JsonNodeAql(context, json); if (!node) { TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL); } TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, json); LOG_TRACE("optimised function call"); return node; }
static TRI_aql_node_t* OptimiseBinaryRelationalOperation (TRI_aql_context_t* const context, TRI_aql_node_t* node) { TRI_aql_node_t* lhs = TRI_AQL_NODE_MEMBER(node, 0); TRI_aql_node_t* rhs = TRI_AQL_NODE_MEMBER(node, 1); TRI_js_exec_context_t* execContext; TRI_string_buffer_t* code; TRI_json_t* json; char* func; if (!lhs || !TRI_IsConstantValueNodeAql(lhs) || !rhs || !TRI_IsConstantValueNodeAql(rhs)) { return node; } if (node->_type == TRI_AQL_NODE_OPERATOR_BINARY_EQ) { func = "EQUAL"; } else if (node->_type == TRI_AQL_NODE_OPERATOR_BINARY_NE) { func = "UNEQUAL"; } else if (node->_type == TRI_AQL_NODE_OPERATOR_BINARY_GT) { func = "GREATER"; } else if (node->_type == TRI_AQL_NODE_OPERATOR_BINARY_GE) { func = "GREATEREQUAL"; } else if (node->_type == TRI_AQL_NODE_OPERATOR_BINARY_LT) { func = "LESS"; } else if (node->_type == TRI_AQL_NODE_OPERATOR_BINARY_LE) { func = "LESSEQUAL"; } else if (node->_type == TRI_AQL_NODE_OPERATOR_BINARY_IN) { func = "IN"; } else { // not what we expected, however, simply continue return node; } code = RelationCode(func, lhs, rhs); if (!code) { TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL); return node; } // execute the function code execContext = TRI_CreateExecutionContext(code->_buffer); TRI_FreeStringBuffer(TRI_UNKNOWN_MEM_ZONE, code); if (!execContext) { TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL); return node; } json = TRI_ExecuteResultContext(execContext); TRI_FreeExecutionContext(execContext); if (!json) { TRI_SetErrorContextAql(context, TRI_ERROR_QUERY_SCRIPT, NULL); return NULL; } // use the constant values instead of the function call node node = TRI_JsonNodeAql(context, json); if (!node) { TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL); } LOG_TRACE("optimised away binary relational operation"); TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, json); return node; }
static TRI_aql_node_t* OptimiseBinaryArithmeticOperation (TRI_aql_context_t* const context, TRI_aql_node_t* node) { TRI_aql_node_t* lhs = TRI_AQL_NODE_MEMBER(node, 0); TRI_aql_node_t* rhs = TRI_AQL_NODE_MEMBER(node, 1); bool isEligibleLhs; bool isEligibleRhs; double value; if (!lhs || !rhs) { return node; } isEligibleLhs = TRI_IsConstantValueNodeAql(lhs); isEligibleRhs = TRI_IsConstantValueNodeAql(rhs); if (isEligibleLhs && !TRI_IsNumericValueNodeAql(lhs)) { // node is not a numeric value => error TRI_SetErrorContextAql(context, TRI_ERROR_QUERY_INVALID_ARITHMETIC_VALUE, NULL); return node; } if (isEligibleRhs && !TRI_IsNumericValueNodeAql(rhs)) { // node is not a numeric value => error TRI_SetErrorContextAql(context, TRI_ERROR_QUERY_INVALID_ARITHMETIC_VALUE, NULL); return node; } if (!isEligibleLhs || !isEligibleRhs) { return node; } assert(node->_type == TRI_AQL_NODE_OPERATOR_BINARY_PLUS || node->_type == TRI_AQL_NODE_OPERATOR_BINARY_MINUS || node->_type == TRI_AQL_NODE_OPERATOR_BINARY_TIMES || node->_type == TRI_AQL_NODE_OPERATOR_BINARY_DIV || node->_type == TRI_AQL_NODE_OPERATOR_BINARY_MOD); if (node->_type == TRI_AQL_NODE_OPERATOR_BINARY_PLUS) { value = TRI_GetNumericNodeValueAql(lhs) + TRI_GetNumericNodeValueAql(rhs); } else if (node->_type == TRI_AQL_NODE_OPERATOR_BINARY_MINUS) { value = TRI_GetNumericNodeValueAql(lhs) - TRI_GetNumericNodeValueAql(rhs); } else if (node->_type == TRI_AQL_NODE_OPERATOR_BINARY_TIMES) { value = TRI_GetNumericNodeValueAql(lhs) * TRI_GetNumericNodeValueAql(rhs); } else if (node->_type == TRI_AQL_NODE_OPERATOR_BINARY_DIV) { if (TRI_GetNumericNodeValueAql(rhs) == 0.0) { // division by zero TRI_SetErrorContextAql(context, TRI_ERROR_QUERY_DIVISION_BY_ZERO, NULL); return node; } value = TRI_GetNumericNodeValueAql(lhs) / TRI_GetNumericNodeValueAql(rhs); } else if (node->_type == TRI_AQL_NODE_OPERATOR_BINARY_MOD) { if (TRI_GetNumericNodeValueAql(rhs) == 0.0) { // division by zero TRI_SetErrorContextAql(context, TRI_ERROR_QUERY_DIVISION_BY_ZERO, NULL); return node; } value = fmod(TRI_GetNumericNodeValueAql(lhs), TRI_GetNumericNodeValueAql(rhs)); } else { value = 0.0; } node = TRI_CreateNodeValueDoubleAql(context, value); if (!node) { TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL); return NULL; } LOG_TRACE("optimised away binary arithmetic operation"); return node; }