Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
arangodb/Ahuacatl/ahuacatl-access-optimizer.c

1576 lines
53 KiB
C
Raw Blame History

////////////////////////////////////////////////////////////////////////////////
/// @brief Ahuacatl, access optimizer
///
/// @file
///
/// DISCLAIMER
///
/// Copyright 2010-2012 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 triAGENS GmbH, Cologne, Germany
///
/// @author Jan Steemann
/// @author Copyright 2012, triagens GmbH, Cologne, Germany
////////////////////////////////////////////////////////////////////////////////
#include "Ahuacatl/ahuacatl-access-optimizer.h"
// -----------------------------------------------------------------------------
// --SECTION-- private functions
// -----------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @addtogroup Ahuacatl
/// @{
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/// @brief hash a field name
////////////////////////////////////////////////////////////////////////////////
static uint64_t HashFieldAccess (TRI_associative_pointer_t* array,
void const* element) {
TRI_aql_field_access_t* fieldAccess = (TRI_aql_field_access_t*) element;
return TRI_FnvHashString(fieldAccess->_fieldName);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief comparison function used to determine field name equality
////////////////////////////////////////////////////////////////////////////////
static bool EqualFieldAccess (TRI_associative_pointer_t* array,
void const* key,
void const* element) {
TRI_aql_field_access_t* fieldAccess = (TRI_aql_field_access_t*) element;
return TRI_EqualString(key, fieldAccess->_fieldName);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief return the logical type for a sub operation
////////////////////////////////////////////////////////////////////////////////
static inline TRI_aql_logical_e SubOperator (const TRI_aql_logical_e preferredType,
const TRI_aql_logical_e parentType) {
if (parentType == TRI_AQL_LOGICAL_NOT) {
// logical NOT is sticky
return parentType;
}
// all other operators are not
return preferredType;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief return the name of an access type
////////////////////////////////////////////////////////////////////////////////
static char* AccessName (const TRI_aql_access_e type) {
switch (type) {
case TRI_AQL_ACCESS_ALL:
return "all";
case TRI_AQL_ACCESS_IMPOSSIBLE:
return "impossible";
case TRI_AQL_ACCESS_EXACT:
return "exact";
case TRI_AQL_ACCESS_LIST:
return "list";
case TRI_AQL_ACCESS_RANGE_SINGLE:
return "single range";
case TRI_AQL_ACCESS_RANGE_DOUBLE:
return "double range";
default:
return "unknown";
}
}
////////////////////////////////////////////////////////////////////////////////
/// @brief free access member data, but do not free the access struct itself
////////////////////////////////////////////////////////////////////////////////
static void FreeAccessMembers (TRI_aql_field_access_t* const fieldAccess) {
assert(fieldAccess);
switch (fieldAccess->_type) {
case TRI_AQL_ACCESS_EXACT:
case TRI_AQL_ACCESS_LIST:
if (fieldAccess->_value._value) {
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, fieldAccess->_value._value);
}
break;
case TRI_AQL_ACCESS_RANGE_SINGLE:
if (fieldAccess->_value._singleRange._value) {
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, fieldAccess->_value._singleRange._value);
}
break;
case TRI_AQL_ACCESS_RANGE_DOUBLE:
if (fieldAccess->_value._between._lower._value) {
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, fieldAccess->_value._between._lower._value);
}
if (fieldAccess->_value._between._upper._value) {
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, fieldAccess->_value._between._upper._value);
}
break;
case TRI_AQL_ACCESS_ALL:
case TRI_AQL_ACCESS_IMPOSSIBLE:
default: {
// nada
}
}
}
////////////////////////////////////////////////////////////////////////////////
/// @brief free access structure with its members and the pointer
////////////////////////////////////////////////////////////////////////////////
static void FreeAccess (TRI_aql_context_t* const context,
TRI_aql_field_access_t* const fieldAccess) {
assert(fieldAccess);
FreeAccessMembers(fieldAccess);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, fieldAccess->_fieldName);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, fieldAccess);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief merge two access structures using a logical NOT
///
/// this always returns the all items range because we cannot evaluate the
/// negated condition
////////////////////////////////////////////////////////////////////////////////
static TRI_aql_field_access_t* MergeNot (TRI_aql_context_t* const context,
TRI_aql_field_access_t* lhs,
TRI_aql_field_access_t* rhs) {
// always returns all
FreeAccess(context, rhs);
FreeAccessMembers(lhs);
lhs->_type = TRI_AQL_ACCESS_ALL;
return lhs;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief merge two access structures using a logical AND
///
/// left hand operand is an impossible range, so the result is also the
/// impossible range
////////////////////////////////////////////////////////////////////////////////
static TRI_aql_field_access_t* MergeAndImpossible (TRI_aql_context_t* const context,
TRI_aql_field_access_t* lhs,
TRI_aql_field_access_t* rhs) {
// impossible merged with anything just returns impossible
assert(lhs->_type == TRI_AQL_ACCESS_IMPOSSIBLE);
FreeAccess(context, rhs);
return lhs;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief merge two access structures using a logical AND
///
/// left hand operand is all items, so the result is the other operand
////////////////////////////////////////////////////////////////////////////////
static TRI_aql_field_access_t* MergeAndAll (TRI_aql_context_t* const context,
TRI_aql_field_access_t* lhs,
TRI_aql_field_access_t* rhs) {
// all merged with anything just returns the other side
assert(lhs->_type == TRI_AQL_ACCESS_ALL);
FreeAccess(context, lhs);
return rhs;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief merge two access structures using a logical AND
///
/// left hand operand is the exact match, the result type depends on the right
/// hand operand type
////////////////////////////////////////////////////////////////////////////////
static TRI_aql_field_access_t* MergeAndExact (TRI_aql_context_t* const context,
TRI_aql_field_access_t* lhs,
TRI_aql_field_access_t* rhs) {
assert(lhs->_type == TRI_AQL_ACCESS_EXACT);
if (rhs->_type == TRI_AQL_ACCESS_EXACT) {
// check if values are identical
bool isSame = TRI_CheckSameValueJson(lhs->_value._value, rhs->_value._value);
FreeAccess(context, rhs);
if (!isSame) {
// lhs and rhs values are non-identical, return impossible
FreeAccessMembers(lhs);
lhs->_type = TRI_AQL_ACCESS_IMPOSSIBLE;
}
return lhs;
}
if (rhs->_type == TRI_AQL_ACCESS_LIST) {
// check if lhs is contained in rhs list
bool inList = TRI_CheckInListJson(lhs->_value._value, rhs->_value._value);
FreeAccess(context, rhs);
if (!inList) {
// lhs value is not in rhs list, return impossible
FreeAccessMembers(lhs);
lhs->_type = TRI_AQL_ACCESS_IMPOSSIBLE;
}
return lhs;
}
if (rhs->_type == TRI_AQL_ACCESS_RANGE_SINGLE) {
// check if value is in range
int result = TRI_CompareValuesJson(lhs->_value._value, rhs->_value._singleRange._value);
bool contained = ((rhs->_value._singleRange._type == TRI_AQL_RANGE_LOWER_EXCLUDED && result > 0) ||
(rhs->_value._singleRange._type == TRI_AQL_RANGE_LOWER_INCLUDED && result >= 0) ||
(rhs->_value._singleRange._type == TRI_AQL_RANGE_UPPER_EXCLUDED && result < 0) ||
(rhs->_value._singleRange._type == TRI_AQL_RANGE_UPPER_INCLUDED && result <= 0));
if (!contained) {
// lhs value is not contained in rhs range, return impossible
FreeAccess(context, rhs);
FreeAccessMembers(lhs);
lhs->_type = TRI_AQL_ACCESS_IMPOSSIBLE;
return lhs;
}
// lhs value is contained in rhs range, simply return rhs
FreeAccess(context, lhs);
return rhs;
}
if (rhs->_type == TRI_AQL_ACCESS_RANGE_DOUBLE) {
// check if value is in range
int result;
bool contained;
// compare lower end
result = TRI_CompareValuesJson(lhs->_value._value, rhs->_value._between._lower._value);
contained = ((rhs->_value._between._lower._type == TRI_AQL_RANGE_LOWER_EXCLUDED && result > 0) ||
(rhs->_value._between._lower._type == TRI_AQL_RANGE_LOWER_INCLUDED && result >= 0));
if (!contained) {
// lhs value is not contained in rhs range, return impossible
FreeAccess(context, rhs);
FreeAccessMembers(lhs);
lhs->_type = TRI_AQL_ACCESS_IMPOSSIBLE;
return lhs;
}
// compare upper end
result = TRI_CompareValuesJson(lhs->_value._value, rhs->_value._between._upper._value);
contained = ((rhs->_value._between._upper._type == TRI_AQL_RANGE_UPPER_EXCLUDED && result < 0) ||
(rhs->_value._between._upper._type == TRI_AQL_RANGE_UPPER_INCLUDED && result <= 0));
if (!contained) {
// lhs value is not contained in rhs range, return impossible
FreeAccess(context, rhs);
FreeAccessMembers(lhs);
lhs->_type = TRI_AQL_ACCESS_IMPOSSIBLE;
return lhs;
}
// lhs value is contained in rhs range, return rhs
FreeAccess(context, lhs);
return rhs;
}
assert(false);
return NULL;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief merge two access structures using a logical AND
///
/// left hand operand is a value list, the result type depends on the right
/// hand operand type
////////////////////////////////////////////////////////////////////////////////
static TRI_aql_field_access_t* MergeAndList (TRI_aql_context_t* const context,
TRI_aql_field_access_t* lhs,
TRI_aql_field_access_t* rhs) {
assert(lhs->_type == TRI_AQL_ACCESS_LIST);
if (rhs->_type == TRI_AQL_ACCESS_LIST) {
// make a list of both
TRI_json_t* merged = TRI_IntersectListsJson(lhs->_value._value, rhs->_value._value, true);
if (!merged) {
// OOM
TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL);
return lhs;
}
FreeAccessMembers(lhs);
FreeAccess(context, rhs);
if (merged->_value._objects._length > 0) {
// merged list is not empty
lhs->_value._value = merged;
}
else {
// merged list is empty
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, merged);
lhs->_type = TRI_AQL_ACCESS_IMPOSSIBLE;
}
return lhs;
}
if (rhs->_type == TRI_AQL_ACCESS_RANGE_SINGLE) {
TRI_json_t* listInRange;
if (rhs->_value._singleRange._type == TRI_AQL_RANGE_LOWER_INCLUDED ||
rhs->_value._singleRange._type == TRI_AQL_RANGE_LOWER_EXCLUDED) {
listInRange = TRI_BetweenListJson(lhs->_value._singleRange._value,
rhs->_value._singleRange._value,
rhs->_value._singleRange._type == TRI_AQL_RANGE_LOWER_INCLUDED,
NULL,
true);
}
else {
listInRange = TRI_BetweenListJson(lhs->_value._singleRange._value,
NULL,
true,
rhs->_value._singleRange._value,
rhs->_value._singleRange._type == TRI_AQL_RANGE_UPPER_INCLUDED);
}
if (!listInRange) {
// OOM
TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL);
FreeAccessMembers(rhs);
return lhs;
}
FreeAccessMembers(lhs);
FreeAccess(context, rhs);
if (listInRange->_value._objects._length > 0) {
// merged list is not empty
lhs->_value._value = listInRange;
}
else {
// merged list is empty
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, listInRange);
lhs->_type = TRI_AQL_ACCESS_IMPOSSIBLE;
}
return lhs;
}
if (rhs->_type == TRI_AQL_ACCESS_RANGE_DOUBLE) {
// check if value in range
TRI_json_t* listInRange;
listInRange = TRI_BetweenListJson(lhs->_value._singleRange._value,
rhs->_value._between._lower._value,
rhs->_value._between._lower._type == TRI_AQL_RANGE_LOWER_INCLUDED,
rhs->_value._between._upper._value,
rhs->_value._between._upper._type == TRI_AQL_RANGE_UPPER_INCLUDED);
if (!listInRange) {
// OOM
TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL);
FreeAccessMembers(rhs);
return lhs;
}
FreeAccessMembers(lhs);
FreeAccess(context, rhs);
if (listInRange->_value._objects._length > 0) {
// merged list is not empty
lhs->_value._value = listInRange;
}
else {
// merged list is empty
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, listInRange);
lhs->_type = TRI_AQL_ACCESS_IMPOSSIBLE;
}
return lhs;
}
assert(false);
return NULL;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief merge two access structures using a logical AND
///
/// left hand operand is a single range, the result type depends on the right
/// hand operand type
////////////////////////////////////////////////////////////////////////////////
static TRI_aql_field_access_t* MergeAndRangeSingle (TRI_aql_context_t* const context,
TRI_aql_field_access_t* lhs,
TRI_aql_field_access_t* rhs) {
assert(lhs->_type == TRI_AQL_ACCESS_RANGE_SINGLE);
if (rhs->_type == TRI_AQL_ACCESS_RANGE_SINGLE) {
TRI_json_t* lhsValue;
TRI_json_t* rhsValue;
TRI_aql_range_e lhsType;
TRI_aql_range_e rhsType;
int compareResult;
if (lhs->_value._singleRange._type > rhs->_value._singleRange._type) {
// swap operands so they are always sorted
TRI_aql_field_access_t* tmp = lhs;
lhs = rhs;
rhs = tmp;
}
compareResult = TRI_CompareValuesJson(lhs->_value._singleRange._value, rhs->_value._singleRange._value);
lhsType = lhs->_value._singleRange._type;
rhsType = rhs->_value._singleRange._type;
lhsValue = lhs->_value._singleRange._value;
rhsValue = rhs->_value._singleRange._value;
// check if ranges overlap
if ((lhsType == TRI_AQL_RANGE_LOWER_EXCLUDED && rhsType == TRI_AQL_RANGE_LOWER_EXCLUDED) ||
(lhsType == TRI_AQL_RANGE_LOWER_INCLUDED && rhsType == TRI_AQL_RANGE_LOWER_INCLUDED)) {
// > && >
// >= && >=
if (compareResult > 0) {
// lhs > rhs
FreeAccess(context, rhs);
return lhs;
}
else {
FreeAccess(context, lhs);
return rhs;
}
}
else if ((lhsType == TRI_AQL_RANGE_UPPER_EXCLUDED && rhsType == TRI_AQL_RANGE_UPPER_EXCLUDED) ||
(lhsType == TRI_AQL_RANGE_UPPER_INCLUDED && rhsType == TRI_AQL_RANGE_UPPER_INCLUDED)) {
// < && <
// <= && <=
if (compareResult > 0) {
// lhs > rhs
FreeAccess(context, lhs);
return rhs;
}
else {
FreeAccess(context, rhs);
return lhs;
}
}
else if (lhsType == TRI_AQL_RANGE_LOWER_EXCLUDED && rhsType == TRI_AQL_RANGE_LOWER_INCLUDED) {
// > && >=
if (compareResult >= 0) {
// lhs > rhs
FreeAccess(context, rhs);
return lhs;
}
else {
FreeAccess(context, lhs);
return rhs;
}
}
else if (lhsType == TRI_AQL_RANGE_LOWER_EXCLUDED && rhsType == TRI_AQL_RANGE_UPPER_EXCLUDED) {
// > && <
if (compareResult < 0) {
// save pointers
lhsValue = lhs->_value._singleRange._value;
rhsValue = rhs->_value._singleRange._value;
rhs->_value._singleRange._value = NULL;
FreeAccess(context, rhs);
lhs->_type = TRI_AQL_ACCESS_RANGE_DOUBLE;
lhs->_value._between._lower._type = lhsType;
lhs->_value._between._lower._value = lhsValue;
lhs->_value._between._upper._type = rhsType;
lhs->_value._between._upper._value = rhsValue;
return lhs;
}
else {
FreeAccess(context, rhs);
FreeAccessMembers(lhs);
lhs->_type = TRI_AQL_ACCESS_IMPOSSIBLE;
return lhs;
}
}
else if ((lhsType == TRI_AQL_RANGE_LOWER_EXCLUDED && rhsType == TRI_AQL_RANGE_UPPER_INCLUDED) ||
(lhsType == TRI_AQL_RANGE_LOWER_INCLUDED && rhsType == TRI_AQL_RANGE_UPPER_EXCLUDED)) {
// > && <=
// >= && <
if (compareResult < 0) {
// save pointers
lhsValue = lhs->_value._singleRange._value;
rhsValue = rhs->_value._singleRange._value;
rhs->_value._singleRange._value = NULL;
FreeAccess(context, rhs);
lhs->_type = TRI_AQL_ACCESS_RANGE_DOUBLE;
lhs->_value._between._lower._type = lhsType;
lhs->_value._between._lower._value = lhsValue;
lhs->_value._between._upper._type = rhsType;
lhs->_value._between._upper._value = rhsValue;
return lhs;
}
else {
FreeAccess(context, rhs);
FreeAccessMembers(lhs);
lhs->_type = TRI_AQL_ACCESS_IMPOSSIBLE;
return lhs;
}
}
else if (lhsType == TRI_AQL_RANGE_LOWER_INCLUDED && rhsType == TRI_AQL_RANGE_UPPER_INCLUDED) {
// >= && <=
if (compareResult < 0) {
// save pointers
lhsValue = lhs->_value._singleRange._value;
rhsValue = rhs->_value._singleRange._value;
rhs->_value._singleRange._value = NULL;
FreeAccess(context, rhs);
lhs->_type = TRI_AQL_ACCESS_RANGE_DOUBLE;
lhs->_value._between._lower._type = lhsType;
lhs->_value._between._lower._value = lhsValue;
lhs->_value._between._upper._type = rhsType;
lhs->_value._between._upper._value = rhsValue;
return lhs;
}
else if (compareResult == 0) {
FreeAccess(context, rhs);
// save pointer
lhsValue = lhs->_value._singleRange._value;
lhs->_type = TRI_AQL_ACCESS_EXACT;
lhs->_value._value = lhsValue;
return lhs;
}
else {
FreeAccess(context, rhs);
FreeAccessMembers(lhs);
lhs->_type = TRI_AQL_ACCESS_IMPOSSIBLE;
return lhs;
}
}
else if (lhsType == TRI_AQL_RANGE_UPPER_EXCLUDED && rhsType == TRI_AQL_RANGE_UPPER_INCLUDED) {
// < && <=
if (compareResult <= 0) {
FreeAccess(context, rhs);
return lhs;
}
else {
FreeAccess(context, lhs);
return rhs;
}
}
}
if (rhs->_type == TRI_AQL_ACCESS_RANGE_DOUBLE) {
int compareResult;
if (lhs->_value._singleRange._type == TRI_AQL_RANGE_LOWER_EXCLUDED) {
compareResult = TRI_CompareValuesJson(lhs->_value._singleRange._value, rhs->_value._between._upper._value);
if (compareResult >= 0) {
// lhs value is bigger than rhs upper bound
FreeAccess(context, rhs);
FreeAccessMembers(lhs);
lhs->_type = TRI_AQL_ACCESS_IMPOSSIBLE;
return lhs;
}
compareResult = TRI_CompareValuesJson(lhs->_value._singleRange._value, rhs->_value._between._lower._value);
if (compareResult > 0) {
// lhs value is bigger than rhs lower bound
rhs->_value._between._lower._type = lhs->_value._singleRange._type;
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, rhs->_value._between._lower._value);
rhs->_value._between._lower._value = lhs->_value._singleRange._value;
lhs->_value._singleRange._value = NULL;
}
else if (compareResult == 0) {
// lhs value is equal to rhs lower bound
if (rhs->_value._between._lower._type == TRI_AQL_RANGE_LOWER_INCLUDED) {
rhs->_value._between._lower._type = TRI_AQL_RANGE_LOWER_EXCLUDED;
}
}
// else intentionally left out
FreeAccess(context, lhs);
return rhs;
}
if (lhs->_value._singleRange._type == TRI_AQL_RANGE_LOWER_INCLUDED) {
compareResult = TRI_CompareValuesJson(lhs->_value._singleRange._value, rhs->_value._between._upper._value);
if (compareResult > 0 || (compareResult == 0 && rhs->_value._between._upper._type == TRI_AQL_RANGE_UPPER_EXCLUDED)) {
// lhs value is bigger than rhs upper bound
FreeAccess(context, rhs);
FreeAccessMembers(lhs);
lhs->_type = TRI_AQL_ACCESS_IMPOSSIBLE;
return lhs;
}
else if (compareResult == 0) {
// save pointer
TRI_json_t* value = lhs->_value._singleRange._value;
FreeAccess(context, rhs);
lhs->_value._singleRange._value = NULL;
FreeAccessMembers(lhs);
lhs->_value._singleRange._type = TRI_AQL_ACCESS_EXACT;
lhs->_value._singleRange._value = value;
return lhs;
}
compareResult = TRI_CompareValuesJson(lhs->_value._singleRange._value, rhs->_value._between._lower._value);
if (compareResult > 0) {
// lhs value is bigger than rhs lower bound
rhs->_value._between._lower._type = lhs->_value._singleRange._type;
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, rhs->_value._between._lower._value);
rhs->_value._between._lower._value = lhs->_value._singleRange._value;
lhs->_value._singleRange._value = NULL;
}
// else intentionally left out
FreeAccess(context, lhs);
return rhs;
}
if (lhs->_value._singleRange._type == TRI_AQL_RANGE_UPPER_EXCLUDED) {
compareResult = TRI_CompareValuesJson(lhs->_value._singleRange._value, rhs->_value._between._lower._value);
if (compareResult <= 0) {
// lhs value is smaller than rhs lower bound
FreeAccess(context, rhs);
FreeAccessMembers(lhs);
lhs->_type = TRI_AQL_ACCESS_IMPOSSIBLE;
return lhs;
}
compareResult = TRI_CompareValuesJson(lhs->_value._singleRange._value, rhs->_value._between._upper._value);
if (compareResult < 0) {
// lhs value is smaller than rhs upper bound
rhs->_value._between._upper._type = lhs->_value._singleRange._type;
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, rhs->_value._between._upper._value);
rhs->_value._between._upper._value = lhs->_value._singleRange._value;
lhs->_value._singleRange._value = NULL;
}
else if (compareResult == 0) {
// lhs value is equal to rhs lower bound
if (rhs->_value._between._upper._type == TRI_AQL_RANGE_UPPER_INCLUDED) {
rhs->_value._between._upper._type = TRI_AQL_RANGE_UPPER_EXCLUDED;
}
}
// else intentionally left out
FreeAccess(context, lhs);
return rhs;
}
if (lhs->_value._singleRange._type == TRI_AQL_RANGE_UPPER_INCLUDED) {
compareResult = TRI_CompareValuesJson(lhs->_value._singleRange._value, rhs->_value._between._lower._value);
if (compareResult < 0 || (compareResult == 0 && rhs->_value._between._lower._type == TRI_AQL_RANGE_LOWER_EXCLUDED)) {
// lhs value is smaller than rhs lower bound
FreeAccess(context, rhs);
FreeAccessMembers(lhs);
lhs->_type = TRI_AQL_ACCESS_IMPOSSIBLE;
return lhs;
}
else if (compareResult == 0) {
// save pointer
TRI_json_t* value = lhs->_value._singleRange._value;
FreeAccess(context, rhs);
lhs->_value._singleRange._value = NULL;
FreeAccessMembers(lhs);
lhs->_value._singleRange._type = TRI_AQL_ACCESS_EXACT;
lhs->_value._singleRange._value = value;
return lhs;
}
compareResult = TRI_CompareValuesJson(lhs->_value._singleRange._value, rhs->_value._between._upper._value);
if (compareResult < 0) {
// lhs value is smaller than rhs upper bound
rhs->_value._between._upper._type = lhs->_value._singleRange._type;
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, rhs->_value._between._upper._value);
rhs->_value._between._upper._value = lhs->_value._singleRange._value;
lhs->_value._singleRange._value = NULL;
}
// else intentionally left out
FreeAccess(context, lhs);
return rhs;
}
return lhs;
}
assert(false);
return NULL;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief merge two access structures using a logical AND
///
/// left hand operand is a double range, the result type depends on the right
/// hand operand type
////////////////////////////////////////////////////////////////////////////////
static TRI_aql_field_access_t* MergeAndRangeDouble (TRI_aql_context_t* const context,
TRI_aql_field_access_t* lhs,
TRI_aql_field_access_t* rhs) {
assert(false);
/* this should never be called. let's see if this assumption is true or not */
assert(lhs->_type == TRI_AQL_ACCESS_RANGE_DOUBLE);
return lhs;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief merge two access structures using a logical OR
///
/// left hand operand is an impossible range, so the result is the right hand
/// operator
////////////////////////////////////////////////////////////////////////////////
static TRI_aql_field_access_t* MergeOrImpossible (TRI_aql_context_t* const context,
TRI_aql_field_access_t* lhs,
TRI_aql_field_access_t* rhs) {
// impossible merged with anything just returns the other side
assert(lhs->_type == TRI_AQL_ACCESS_IMPOSSIBLE);
FreeAccess(context, lhs);
return rhs;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief merge two access structures using a logical OR
///
/// left hand operand is all items, so the result is also all
////////////////////////////////////////////////////////////////////////////////
static TRI_aql_field_access_t* MergeOrAll (TRI_aql_context_t* const context,
TRI_aql_field_access_t* lhs,
TRI_aql_field_access_t* rhs) {
// all merged with anything just returns all
assert(lhs->_type == TRI_AQL_ACCESS_ALL);
FreeAccess(context, rhs);
return lhs;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief merge two access structures using a logical OR
///
/// left hand operand is the exact match, the result type depends on the right
/// hand operand type
////////////////////////////////////////////////////////////////////////////////
static TRI_aql_field_access_t* MergeOrExact (TRI_aql_context_t* const context,
TRI_aql_field_access_t* lhs,
TRI_aql_field_access_t* rhs) {
assert(lhs->_type == TRI_AQL_ACCESS_EXACT);
if (rhs->_type == TRI_AQL_ACCESS_EXACT) {
TRI_json_t* result;
// check if values are identical
if ( TRI_CheckSameValueJson(lhs->_value._value, rhs->_value._value)) {
// lhs and rhs values are identical, return lhs
FreeAccess(context, rhs);
return lhs;
}
// make a list with both values
result = TRI_CreateListJson(TRI_UNKNOWN_MEM_ZONE);
if (!result) {
// OOM
TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL);
FreeAccess(context, rhs);
return lhs;
}
TRI_PushBackListJson(TRI_UNKNOWN_MEM_ZONE, result, lhs->_value._value);
TRI_PushBackListJson(TRI_UNKNOWN_MEM_ZONE, result, rhs->_value._value);
TRI_SortListJson(result);
FreeAccess(context, lhs);
FreeAccessMembers(rhs);
rhs->_type = TRI_AQL_ACCESS_LIST;
rhs->_value._value = result;
return rhs;
}
if (rhs->_type == TRI_AQL_ACCESS_LIST) {
// check if lhs is contained in rhs list
if (TRI_CheckInListJson(lhs->_value._value, rhs->_value._value)) {
// lhs is contained in rhs, we can return rhs
FreeAccess(context, lhs);
return rhs;
}
// lhs is not contained, we need to add it to the list
TRI_PushBackListJson(TRI_UNKNOWN_MEM_ZONE, rhs->_value._value, lhs->_value._value);
TRI_SortListJson(rhs->_value._value);
FreeAccess(context, lhs);
return rhs;
}
if (rhs->_type == TRI_AQL_ACCESS_RANGE_SINGLE) {
// check if value is in range
int result = TRI_CompareValuesJson(lhs->_value._value, rhs->_value._singleRange._value);
bool contained = ((rhs->_value._singleRange._type == TRI_AQL_RANGE_LOWER_EXCLUDED && result > 0) ||
(rhs->_value._singleRange._type == TRI_AQL_RANGE_LOWER_INCLUDED && result >= 0) ||
(rhs->_value._singleRange._type == TRI_AQL_RANGE_UPPER_EXCLUDED && result < 0) ||
(rhs->_value._singleRange._type == TRI_AQL_RANGE_UPPER_INCLUDED && result <= 0));
if (!contained) {
// lhs value is not contained in rhs range, return all
FreeAccess(context, rhs);
FreeAccessMembers(lhs);
lhs->_type = TRI_AQL_ACCESS_ALL;
return lhs;
}
// lhs value is contained in rhs range, simply return rhs
FreeAccess(context, lhs);
return rhs;
}
if (rhs->_type == TRI_AQL_ACCESS_RANGE_DOUBLE) {
// check if value is in range
int result;
bool contained;
// compare lower end
result = TRI_CompareValuesJson(lhs->_value._value, rhs->_value._between._lower._value);
contained = ((rhs->_value._between._lower._type == TRI_AQL_RANGE_LOWER_EXCLUDED && result > 0) ||
(rhs->_value._between._lower._type == TRI_AQL_RANGE_LOWER_INCLUDED && result >= 0));
if (!contained) {
// lhs value is not contained in rhs range, return all
FreeAccess(context, rhs);
FreeAccessMembers(lhs);
lhs->_type = TRI_AQL_ACCESS_ALL;
return lhs;
}
// compare upper end
result = TRI_CompareValuesJson(lhs->_value._value, rhs->_value._between._upper._value);
contained = ((rhs->_value._between._upper._type == TRI_AQL_RANGE_UPPER_EXCLUDED && result < 0) ||
(rhs->_value._between._upper._type == TRI_AQL_RANGE_UPPER_INCLUDED && result <= 0));
if (!contained) {
// lhs value is not contained in rhs range, return all
FreeAccess(context, rhs);
FreeAccessMembers(lhs);
lhs->_type = TRI_AQL_ACCESS_ALL;
return lhs;
}
// lhs value is contained in rhs range, return rhs
FreeAccess(context, lhs);
return rhs;
}
assert(false);
return NULL;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief merge two access structures using a logical OR
///
/// left hand operand is a value list, the result type depends on the right
/// hand operand type
////////////////////////////////////////////////////////////////////////////////
static TRI_aql_field_access_t* MergeOrList (TRI_aql_context_t* const context,
TRI_aql_field_access_t* lhs,
TRI_aql_field_access_t* rhs) {
assert(lhs->_type == TRI_AQL_ACCESS_LIST);
if (rhs->_type == TRI_AQL_ACCESS_LIST) {
// make a list of both
TRI_json_t* merged = TRI_UnionizeListsJson(lhs->_value._value, rhs->_value._value, true);
if (!merged) {
// OOM
TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL);
return lhs;
}
FreeAccessMembers(lhs);
FreeAccess(context, rhs);
if (merged->_value._objects._length > 0) {
// merged list is not empty
lhs->_value._value = merged;
}
else {
// merged list is empty
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, merged);
lhs->_type = TRI_AQL_ACCESS_IMPOSSIBLE;
}
return lhs;
}
// for all other combinations, we give up
FreeAccess(context, rhs);
FreeAccessMembers(lhs);
lhs->_type = TRI_AQL_ACCESS_ALL;
return lhs;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief merge two access structures using a logical OR
///
/// left hand operand is a single range, the result type depends on the right
/// hand operand type
////////////////////////////////////////////////////////////////////////////////
static TRI_aql_field_access_t* MergeOrRangeSingle (TRI_aql_context_t* const context,
TRI_aql_field_access_t* lhs,
TRI_aql_field_access_t* rhs) {
assert(lhs->_type == TRI_AQL_ACCESS_RANGE_SINGLE);
if (rhs->_type == TRI_AQL_ACCESS_RANGE_SINGLE) {
TRI_aql_range_e lhsType;
TRI_aql_range_e rhsType;
int compareResult;
if (lhs->_value._singleRange._type > rhs->_value._singleRange._type) {
// swap operands so they are always sorted
TRI_aql_field_access_t* tmp = lhs;
lhs = rhs;
rhs = tmp;
}
compareResult = TRI_CompareValuesJson(lhs->_value._singleRange._value, rhs->_value._singleRange._value);
lhsType = lhs->_value._singleRange._type;
rhsType = rhs->_value._singleRange._type;
// check if ranges overlap
if ((lhsType == TRI_AQL_RANGE_LOWER_EXCLUDED && rhsType == TRI_AQL_RANGE_LOWER_EXCLUDED) ||
(lhsType == TRI_AQL_RANGE_LOWER_INCLUDED && rhsType == TRI_AQL_RANGE_LOWER_INCLUDED)) {
// > && >
// >= && >=
if (compareResult > 0) {
// lhs > rhs
FreeAccess(context, lhs);
return rhs;
}
else {
FreeAccess(context, rhs);
return lhs;
}
}
else if ((lhsType == TRI_AQL_RANGE_UPPER_EXCLUDED && rhsType == TRI_AQL_RANGE_UPPER_EXCLUDED) ||
(lhsType == TRI_AQL_RANGE_UPPER_INCLUDED && rhsType == TRI_AQL_RANGE_UPPER_INCLUDED)) {
// < && <
// <= && <=
if (compareResult > 0) {
// lhs > rhs
FreeAccess(context, rhs);
return lhs;
}
else {
FreeAccess(context, lhs);
return rhs;
}
}
else if (lhsType == TRI_AQL_RANGE_LOWER_EXCLUDED && rhsType == TRI_AQL_RANGE_LOWER_INCLUDED) {
// > && >=
if (compareResult >= 0) {
// lhs > rhs
FreeAccess(context, lhs);
return rhs;
}
else {
FreeAccess(context, rhs);
return lhs;
}
}
else if (lhsType == TRI_AQL_RANGE_UPPER_EXCLUDED && rhsType == TRI_AQL_RANGE_UPPER_INCLUDED) {
// < && <=
if (compareResult <= 0) {
// lhs < rhs
FreeAccess(context, lhs);
return rhs;
}
else {
FreeAccess(context, rhs);
return lhs;
}
}
}
// for all other combinations, we give up
FreeAccess(context, rhs);
FreeAccessMembers(lhs);
lhs->_type = TRI_AQL_ACCESS_ALL;
return lhs;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief merge two access structures using a logical OR
///
/// left hand operand is a double range, the result type depends on the right
/// hand operand type
////////////////////////////////////////////////////////////////////////////////
static TRI_aql_field_access_t* MergeOrRangeDouble (TRI_aql_context_t* const context,
TRI_aql_field_access_t* lhs,
TRI_aql_field_access_t* rhs) {
assert(false);
/* this should never be called. let's see if this assumption is true or not */
assert(lhs->_type == TRI_AQL_ACCESS_RANGE_DOUBLE);
return lhs;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief merge two access structures using either logical AND or OR
////////////////////////////////////////////////////////////////////////////////
static TRI_aql_field_access_t* MergeAccess (TRI_aql_context_t* const context,
const TRI_aql_logical_e logicalType,
TRI_aql_field_access_t* lhs,
TRI_aql_field_access_t* rhs) {
assert(context);
assert(lhs);
assert(rhs);
assert(logicalType == TRI_AQL_LOGICAL_AND ||
logicalType == TRI_AQL_LOGICAL_OR ||
logicalType == TRI_AQL_LOGICAL_NOT);
assert(lhs->_fieldName != NULL);
assert(rhs->_fieldName != NULL);
if (logicalType == TRI_AQL_LOGICAL_NOT) {
// logical NOT is simple. we simply turn everything into an all range
return MergeNot(context, lhs, rhs);
}
if (lhs->_type > rhs->_type) {
// swap operands so they are always sorted
TRI_aql_field_access_t* tmp = lhs;
lhs = rhs;
rhs = tmp;
}
assert(lhs->_type <= rhs->_type);
if (logicalType == TRI_AQL_LOGICAL_AND) {
// logical AND
switch (lhs->_type) {
case TRI_AQL_ACCESS_IMPOSSIBLE:
return MergeAndImpossible(context, lhs, rhs);
case TRI_AQL_ACCESS_ALL:
return MergeAndAll(context, lhs, rhs);
case TRI_AQL_ACCESS_EXACT:
return MergeAndExact(context, lhs, rhs);
case TRI_AQL_ACCESS_LIST:
return MergeAndList(context, lhs, rhs);
case TRI_AQL_ACCESS_RANGE_SINGLE:
return MergeAndRangeSingle(context, lhs, rhs);
case TRI_AQL_ACCESS_RANGE_DOUBLE:
return MergeAndRangeDouble(context, lhs, rhs);
}
}
else {
// logical OR
switch (lhs->_type) {
case TRI_AQL_ACCESS_IMPOSSIBLE:
return MergeOrImpossible(context, lhs, rhs);
case TRI_AQL_ACCESS_ALL:
return MergeOrAll(context, lhs, rhs);
case TRI_AQL_ACCESS_EXACT:
return MergeOrExact(context, lhs, rhs);
case TRI_AQL_ACCESS_LIST:
return MergeOrList(context, lhs, rhs);
case TRI_AQL_ACCESS_RANGE_SINGLE:
return MergeOrRangeSingle(context, lhs, rhs);
case TRI_AQL_ACCESS_RANGE_DOUBLE:
return MergeOrRangeDouble(context, lhs, rhs);
}
}
assert(false);
return NULL;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief create an access structure for the given node and operator
////////////////////////////////////////////////////////////////////////////////
static TRI_aql_field_access_t* CreateAccessForNode (TRI_aql_context_t* const context,
const TRI_aql_attribute_name_t* const field,
const TRI_aql_node_type_e operator,
const TRI_aql_node_t* const node) {
TRI_aql_field_access_t* fieldAccess;
TRI_json_t* value;
assert(context);
assert(field);
assert(field->_name._buffer);
assert(node);
value = TRI_NodeJsonAql(context, node);
if (!value) {
TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL);
return NULL;
}
fieldAccess = (TRI_aql_field_access_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_aql_field_access_t), false);
if (fieldAccess == NULL) {
// OOM
TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL);
return NULL;
}
fieldAccess->_fieldName = TRI_DuplicateString(field->_name._buffer);
if (fieldAccess->_fieldName == NULL) {
TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, fieldAccess);
return NULL;
}
if (operator == AQL_NODE_OPERATOR_BINARY_EQ) {
// create an exact value access
fieldAccess->_type = TRI_AQL_ACCESS_EXACT;
fieldAccess->_value._value = value;
}
else if (operator == AQL_NODE_OPERATOR_BINARY_LT) {
// create a single range access
fieldAccess->_type = TRI_AQL_ACCESS_RANGE_SINGLE;
fieldAccess->_value._singleRange._type = TRI_AQL_RANGE_UPPER_EXCLUDED;
fieldAccess->_value._singleRange._value = value;
}
else if (operator == AQL_NODE_OPERATOR_BINARY_LE) {
// create a single range access
fieldAccess->_type = TRI_AQL_ACCESS_RANGE_SINGLE;
fieldAccess->_value._singleRange._type = TRI_AQL_RANGE_UPPER_INCLUDED;
fieldAccess->_value._singleRange._value = value;
}
else if (operator == AQL_NODE_OPERATOR_BINARY_GT) {
// create a single range access
fieldAccess->_type = TRI_AQL_ACCESS_RANGE_SINGLE;
fieldAccess->_value._singleRange._type = TRI_AQL_RANGE_LOWER_EXCLUDED;
fieldAccess->_value._singleRange._value = value;
}
else if (operator == AQL_NODE_OPERATOR_BINARY_GE) {
// create a single range access
fieldAccess->_type = TRI_AQL_ACCESS_RANGE_SINGLE;
fieldAccess->_value._singleRange._type = TRI_AQL_RANGE_LOWER_INCLUDED;
fieldAccess->_value._singleRange._value = value;
}
else if (operator == AQL_NODE_OPERATOR_BINARY_IN) {
TRI_json_t* list;
// create a list access
fieldAccess->_type = TRI_AQL_ACCESS_LIST;
fieldAccess->_value._value = value;
// sort values in list
TRI_SortListJson(fieldAccess->_value._value);
// make list values unique
list = TRI_UniquifyListJson(fieldAccess->_value._value);
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, fieldAccess->_value._value);
fieldAccess->_value._value = list;
}
else {
assert(false);
}
return fieldAccess;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief create an access structure for the given node and operator,
/// merge it with potential others already found for the same variable
////////////////////////////////////////////////////////////////////////////////
static void NoteAttributeAccess (TRI_aql_context_t* const context,
const TRI_aql_logical_e logicalType,
const TRI_aql_attribute_name_t* const field,
const TRI_aql_node_type_e operator,
const TRI_aql_node_t* const node) {
TRI_aql_field_access_t* previous;
TRI_aql_field_access_t* fieldAccess;
assert(context);
assert(logicalType == TRI_AQL_LOGICAL_AND ||
logicalType == TRI_AQL_LOGICAL_OR ||
logicalType == TRI_AQL_LOGICAL_NOT);
assert(node);
if (!field || !field->_name._buffer) {
return;
}
fieldAccess = CreateAccessForNode(context, field, operator, node);
if (!fieldAccess) {
// OOM
TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL);
return;
}
// look up previous range first
previous = (TRI_aql_field_access_t*) TRI_LookupByKeyAssociativePointer(context->_ranges, fieldAccess->_fieldName);
if (previous) {
TRI_aql_field_access_t* merged;
// previous range exists, now merge new access type with previous one
// remove from hash first
TRI_RemoveKeyAssociativePointer(context->_ranges, fieldAccess->_fieldName);
// MergeAccess() will free previous and/or fieldAccess
merged = MergeAccess(context, logicalType, fieldAccess, previous);
if (!merged) {
// OOM
TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL);
return;
}
TRI_InsertKeyAssociativePointer(context->_ranges, merged->_fieldName, merged, true);
}
else {
// no previous access exists, no need to merge
TRI_InsertKeyAssociativePointer(context->_ranges, fieldAccess->_fieldName, fieldAccess, false);
}
}
////////////////////////////////////////////////////////////////////////////////
/// @brief set up the name of an attribute, including the variable name and
/// '.'s (e.g. u.birthday.day) for a given node
////////////////////////////////////////////////////////////////////////////////
static TRI_aql_attribute_name_t* GetAttributeName (TRI_aql_context_t* const context,
const TRI_aql_node_t* const node) {
assert(context);
assert(node);
if (node->_type == AQL_NODE_ATTRIBUTE_ACCESS) {
TRI_aql_attribute_name_t* field = GetAttributeName(context, TRI_AQL_NODE_MEMBER(node, 0));
if (!field) {
return NULL;
}
TRI_AppendCharStringBuffer(&field->_name, '.');
TRI_AppendStringStringBuffer(&field->_name, TRI_AQL_NODE_STRING(node));
return field;
}
else if (node->_type == AQL_NODE_REFERENCE) {
TRI_aql_attribute_name_t* field;
field = (TRI_aql_attribute_name_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_aql_attribute_name_t), false);
if (!field) {
// OOM
TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL);
return NULL;
}
field->_variable = TRI_AQL_NODE_STRING(node);
TRI_InitStringBuffer(&field->_name, TRI_UNKNOWN_MEM_ZONE);
TRI_AppendStringStringBuffer(&field->_name, TRI_AQL_NODE_STRING(node));
return field;
}
return NULL;
}
////////////////////////////////////////////////////////////////////////////////
/// @}
////////////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------------
// --SECTION-- constructors / destructors
// -----------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @addtogroup Ahuacatl
/// @{
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/// @brief init the optimizer
////////////////////////////////////////////////////////////////////////////////
bool TRI_InitOptimizerAql (TRI_aql_context_t* const context) {
assert(context);
assert(context->_ranges == NULL);
context->_ranges = (TRI_associative_pointer_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_associative_pointer_t), false);
if (!context->_ranges) {
TRI_SetErrorContextAql(context, TRI_ERROR_OUT_OF_MEMORY, NULL);
return false;
}
TRI_InitAssociativePointer(context->_ranges,
TRI_UNKNOWN_MEM_ZONE,
&TRI_HashStringKeyAssociativePointer,
&HashFieldAccess,
&EqualFieldAccess,
NULL);
return true;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief shutdown the optimizer
////////////////////////////////////////////////////////////////////////////////
void TRI_FreeOptimizerAql (TRI_aql_context_t* const context) {
assert(context);
if (context->_ranges) {
size_t i, n;
// free all remaining access elements
n = context->_ranges->_nrAlloc;
for (i = 0; i < n; ++i) {
TRI_aql_field_access_t* fieldAccess = (TRI_aql_field_access_t*) context->_ranges->_table[i];
if (!fieldAccess) {
continue;
}
FreeAccess(context, fieldAccess);
}
// free hash array
TRI_FreeAssociativePointer(TRI_UNKNOWN_MEM_ZONE, context->_ranges);
context->_ranges = NULL;
}
}
////////////////////////////////////////////////////////////////////////////////
/// @}
////////////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------------
// --SECTION-- public functions
// -----------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @addtogroup Ahuacatl
/// @{
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/// @brief dump ranges found for debugging purposes
////////////////////////////////////////////////////////////////////////////////
void TRI_DumpRangesAql (TRI_aql_context_t* const context) {
size_t i;
assert(context);
for (i = 0; i < context->_ranges->_nrAlloc; ++i) {
TRI_aql_field_access_t* fieldAccess = context->_ranges->_table[i];
if (!fieldAccess) {
continue;
}
printf("\nFIELD ACCESS\n- FIELD: %s\n",fieldAccess->_fieldName);
printf("- TYPE: %s\n", AccessName(fieldAccess->_type));
if (fieldAccess->_type == TRI_AQL_ACCESS_EXACT || fieldAccess->_type == TRI_AQL_ACCESS_LIST) {
TRI_string_buffer_t b;
TRI_InitStringBuffer(&b, TRI_UNKNOWN_MEM_ZONE);
TRI_StringifyJson(&b, fieldAccess->_value._value);
printf("- VALUE: %s\n", b._buffer);
TRI_DestroyStringBuffer(&b);
}
else if (fieldAccess->_type == TRI_AQL_ACCESS_RANGE_SINGLE) {
TRI_string_buffer_t b;
TRI_InitStringBuffer(&b, TRI_UNKNOWN_MEM_ZONE);
TRI_StringifyJson(&b, fieldAccess->_value._singleRange._value);
printf("- VALUE: %s\n", b._buffer);
TRI_DestroyStringBuffer(&b);
}
else if (fieldAccess->_type == TRI_AQL_ACCESS_RANGE_DOUBLE) {
TRI_string_buffer_t b;
TRI_InitStringBuffer(&b, TRI_UNKNOWN_MEM_ZONE);
TRI_StringifyJson(&b, fieldAccess->_value._between._lower._value);
TRI_AppendStringStringBuffer(&b, ", ");
TRI_StringifyJson(&b, fieldAccess->_value._between._upper._value);
printf("- VALUE: %s\n", b._buffer);
TRI_DestroyStringBuffer(&b);
}
}
}
////////////////////////////////////////////////////////////////////////////////
/// @brief inspect a condition and note all accesses found for it
////////////////////////////////////////////////////////////////////////////////
void TRI_InspectConditionAql (TRI_aql_context_t* const context,
const TRI_aql_logical_e logicalType,
TRI_aql_node_t* node) {
assert(context);
assert(logicalType == TRI_AQL_LOGICAL_AND ||
logicalType == TRI_AQL_LOGICAL_OR ||
logicalType == TRI_AQL_LOGICAL_NOT);
if (node->_type == AQL_NODE_OPERATOR_UNARY_NOT) {
TRI_aql_node_t* lhs = TRI_AQL_NODE_MEMBER(node, 0);
assert(lhs);
TRI_InspectConditionAql(context, TRI_AQL_LOGICAL_NOT, lhs);
return;
}
if (node->_type == AQL_NODE_OPERATOR_BINARY_OR) {
TRI_aql_node_t* lhs = TRI_AQL_NODE_MEMBER(node, 0);
TRI_aql_node_t* rhs = TRI_AQL_NODE_MEMBER(node, 1);
TRI_aql_logical_e nextOperator;
assert(lhs);
assert(rhs);
// recurse into next level
nextOperator = SubOperator(TRI_AQL_LOGICAL_OR, logicalType);
TRI_InspectConditionAql(context, nextOperator, lhs);
TRI_InspectConditionAql(context, nextOperator, rhs);
return;
}
if (node->_type == AQL_NODE_OPERATOR_BINARY_AND) {
TRI_aql_node_t* lhs = TRI_AQL_NODE_MEMBER(node, 0);
TRI_aql_node_t* rhs = TRI_AQL_NODE_MEMBER(node, 1);
TRI_aql_logical_e nextOperator;
assert(lhs);
assert(rhs);
// recurse into next level
nextOperator = SubOperator(TRI_AQL_LOGICAL_AND, logicalType);
TRI_InspectConditionAql(context, nextOperator, lhs);
TRI_InspectConditionAql(context, nextOperator, rhs);
return;
}
if (node->_type == AQL_NODE_OPERATOR_BINARY_EQ ||
// node->_type == AQL_NODE_OPERATOR_BINARY_NE ||
node->_type == AQL_NODE_OPERATOR_BINARY_LT ||
node->_type == AQL_NODE_OPERATOR_BINARY_LE ||
node->_type == AQL_NODE_OPERATOR_BINARY_GT ||
node->_type == AQL_NODE_OPERATOR_BINARY_GE ||
node->_type == AQL_NODE_OPERATOR_BINARY_IN) {
TRI_aql_node_t* lhs = TRI_AQL_NODE_MEMBER(node, 0);
TRI_aql_node_t* rhs = TRI_AQL_NODE_MEMBER(node, 1);
if (lhs->_type == AQL_NODE_ATTRIBUTE_ACCESS) {
TRI_aql_attribute_name_t* field = GetAttributeName(context, lhs);
if (field) {
NoteAttributeAccess(context, logicalType, field, node->_type, rhs);
TRI_DestroyStringBuffer(&field->_name);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, field);
}
}
else if (rhs->_type == AQL_NODE_ATTRIBUTE_ACCESS) {
TRI_aql_attribute_name_t* field = GetAttributeName(context, rhs);
if (field) {
NoteAttributeAccess(context, logicalType, field, node->_type, lhs);
TRI_DestroyStringBuffer(&field->_name);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, field);
}
}
}
}
////////////////////////////////////////////////////////////////////////////////
/// @}
////////////////////////////////////////////////////////////////////////////////
// Local Variables:
// mode: outline-minor
// outline-regexp: "^\\(/// @brief\\|/// {@inheritDoc}\\|/// @addtogroup\\|// --SECTION--\\|/// @\\}\\)"
// End:
Reference in New Issue View Git Blame Copy Permalink