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

578 lines
19 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 Michael Hackstein
////////////////////////////////////////////////////////////////////////////////
#include "TraversalConditionFinder.h"
#include "Aql/Ast.h"
#include "Aql/ExecutionPlan.h"
#include "Aql/Quantifier.h"
#include "Aql/TraversalNode.h"
using namespace arangodb::aql;
using EN = arangodb::aql::ExecutionNode;
static AstNode* createGlobalCondition(Ast* ast, AstNode const* condition) {
TRI_ASSERT(condition->numMembers() == 3);
AstNodeType type = NODE_TYPE_ROOT;
switch (condition->type) {
case NODE_TYPE_OPERATOR_BINARY_ARRAY_EQ:
type = NODE_TYPE_OPERATOR_BINARY_EQ;
break;
case NODE_TYPE_OPERATOR_BINARY_ARRAY_NE:
type = NODE_TYPE_OPERATOR_BINARY_NE;
break;
case NODE_TYPE_OPERATOR_BINARY_ARRAY_LT:
type = NODE_TYPE_OPERATOR_BINARY_LT;
break;
case NODE_TYPE_OPERATOR_BINARY_ARRAY_LE:
type = NODE_TYPE_OPERATOR_BINARY_LE;
break;
case NODE_TYPE_OPERATOR_BINARY_ARRAY_GT:
type = NODE_TYPE_OPERATOR_BINARY_GT;
break;
case NODE_TYPE_OPERATOR_BINARY_ARRAY_GE:
type = NODE_TYPE_OPERATOR_BINARY_GE;
break;
case NODE_TYPE_OPERATOR_BINARY_ARRAY_IN:
type = NODE_TYPE_OPERATOR_BINARY_IN;
break;
case NODE_TYPE_OPERATOR_BINARY_ARRAY_NIN:
type = NODE_TYPE_OPERATOR_BINARY_NIN;
break;
default:
THROW_ARANGO_EXCEPTION(TRI_ERROR_INTERNAL);
}
auto quantifier = condition->getMemberUnchecked(2);
TRI_ASSERT(quantifier->type == NODE_TYPE_QUANTIFIER);
int64_t val = quantifier->getIntValue(true);
TRI_ASSERT(val != Quantifier::ANY);
if (val == Quantifier::NONE) {
auto it = Ast::NegatedOperators.find(type);
if (it == Ast::NegatedOperators.end()) {
THROW_ARANGO_EXCEPTION(TRI_ERROR_INTERNAL);
}
type = it->second;
}
auto left = condition->getMemberUnchecked(0);
TRI_ASSERT(left->numMembers() >= 2);
// This is the part appended to each element in the expansion.
left = left->getMemberUnchecked(1);
auto right = condition->getMemberUnchecked(1);
return ast->createNodeBinaryOperator(type, left, right);
}
static bool matchesArrayAccessPattern(AstNode const* testee,
Variable const* findme,
bool& isEdge,
VariableId& tmpVar) {
// The search pattern is:
// expansion{levels: 1} -> iterator -2> attributeAccess -> reference
// Where reference has to be equal to var
if (testee->type != NODE_TYPE_EXPANSION) {
return false;
}
TRI_ASSERT(testee->numMembers() == 5);
auto levels = testee->getIntValue(true);
if (levels != 1) {
// This expression is too complicated for now.
return false;
}
if (testee->getMemberUnchecked(2)->type != NODE_TYPE_NOP ||
testee->getMemberUnchecked(3)->type != NODE_TYPE_NOP ||
testee->getMemberUnchecked(4)->type != NODE_TYPE_NOP) {
// Some complex transformation in subqueries happening.
// Do not optimize now.
return false;
}
testee = testee->getMemberUnchecked(0);
TRI_ASSERT(testee->type == NODE_TYPE_ITERATOR); // Expansion always has iterator
TRI_ASSERT(testee->numMembers() == 2);
auto varNode = testee->getMemberUnchecked(0);
auto v = static_cast<Variable*>(varNode->getData());
tmpVar = v->id;
testee = testee->getMemberUnchecked(1);
if (testee->type != NODE_TYPE_ATTRIBUTE_ACCESS) {
return false;
}
// Ok up to here, Check if it is edges or vertices
if (testee->stringEquals("edges", false)) {
// Ok this could be an edge access
isEdge = true;
} else if (testee->stringEquals("vertices", false)) {
// Ok this could be a vertex access
isEdge = false;
} else {
// This is indexed access on sth. completely different.
return false;
}
// Advance to the Variable
TRI_ASSERT(testee->numMembers() == 1);
testee = testee->getMemberUnchecked(0);
if (testee->type != NODE_TYPE_REFERENCE &&
testee->type != NODE_TYPE_VARIABLE // Do we actually allow this case?
) {
return false;
}
// Check if it really is the variable
auto variable = static_cast<Variable*>(testee->getData());
TRI_ASSERT(variable != nullptr);
if (variable->id == findme->id) {
return true;
}
return false;
}
static bool checkPathVariableAccessFeasible(CalculationNode const* cn,
TraversalNode* tn,
Variable const* var,
bool& conditionIsImpossible) {
auto node = cn->expression()->node();
if (node->containsNodeType(NODE_TYPE_OPERATOR_BINARY_OR)) {
return false;
}
std::vector<AstNode const*> currentPath;
std::vector<std::vector<AstNode const*>> paths;
node->findVariableAccess(currentPath, paths, var);
for (auto const& onePath : paths) {
size_t len = onePath.size();
bool isEdgeAccess = false;
for (auto const & node : onePath) {
if (node->type == NODE_TYPE_FCALL) {
return false;
}
if (node->type == NODE_TYPE_OPERATOR_BINARY_IN ||
node->type == NODE_TYPE_OPERATOR_BINARY_NIN) {
if (!node->getMember(0)->isAttributeAccessForVariable(var, true)) {
return false;
}
}
}
if (onePath[len - 2]->type == NODE_TYPE_ATTRIBUTE_ACCESS) {
isEdgeAccess = onePath[len - 2]->stringEquals("edges", false);
if (!isEdgeAccess &&
!onePath[len - 2]->stringEquals("vertices", false)) {
/* We can't catch all cases in which this error would occur, so we don't
throw here.
std::string message("TRAVERSAL: path only knows 'edges' and
'vertices', not ");
message += onePath[len - 2]->getString();
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_QUERY_PARSE, message);
*/
return false;
}
}
// we now need to check for p.edges[n] whether n is >= 0
if (onePath[len - 3]->type == NODE_TYPE_INDEXED_ACCESS) {
auto indexAccessNode = onePath[len - 3]->getMember(1);
if ((indexAccessNode->type != NODE_TYPE_VALUE) ||
(indexAccessNode->value.type != VALUE_TYPE_INT) ||
(indexAccessNode->value.value._int < 0)) {
return false;
}
conditionIsImpossible =
!tn->isInRange(indexAccessNode->value.value._int, isEdgeAccess);
} else if ((onePath[len - 3]->type == NODE_TYPE_ITERATOR) &&
(onePath[len - 4]->type == NODE_TYPE_EXPANSION)) {
// we now need to check for p.edges[*] which becomes a fancy structure
return false;
} else {
return false;
}
}
return true;
}
static bool matchesPathAccessPattern(AstNode const* testee,
Variable const* findme, size_t& idx,
bool& isEdge) {
// The search pattern is:
// indexedAccess -> attributeAccess -> reference
// Where reference has to be equal to var
// Testee has to be IndexedAccess
if (testee->type != NODE_TYPE_INDEXED_ACCESS) {
return false;
}
TRI_ASSERT(testee->numMembers() == 2);
// Ok up to here, read the idx already.
AstNode const* idxNode = testee->getMemberUnchecked(1);
idx = idxNode->value.value._int;
// Advance to the AttributeAccess
testee = testee->getMemberUnchecked(0);
if (testee->type != NODE_TYPE_ATTRIBUTE_ACCESS) {
return false;
}
// Ok up to here, Check if it is edges or vertices
if (testee->stringEquals("edges", false)) {
// Ok this could be an edge access
isEdge = true;
} else if (testee->stringEquals("vertices", false)) {
// Ok this could be a vertex access
isEdge = false;
} else {
// This is indexed access on sth. completely different.
return false;
}
// Advance to the Variable
TRI_ASSERT(testee->numMembers() == 1);
testee = testee->getMemberUnchecked(0);
if (testee->type != NODE_TYPE_REFERENCE &&
testee->type != NODE_TYPE_VARIABLE // Do we actually allow this case?
) {
return false;
}
// Check if it really is the variable
auto variable = static_cast<Variable*>(testee->getData());
TRI_ASSERT(variable != nullptr);
if (variable->id == findme->id) {
return true;
}
return false;
}
static void transformCondition(AstNode const* node, Variable const* pvar,
Ast* ast, TraversalNode* tn) {
TRI_ASSERT(node->type == NODE_TYPE_OPERATOR_NARY_OR);
// We do not support OR conditions for pruning
TRI_ASSERT(node->numMembers() == 1);
node = node->getMemberUnchecked(0);
AstNode* result = node->clone(ast);
AstNode* varRefNode = tn->getTemporaryRefNode();
size_t const n = result->numMembers();
for (size_t i = 0; i < n; ++i) {
AstNode* baseCondition = result->getMemberUnchecked(i);
#ifdef ARANGODB_ENABLE_MAINTAINER_MODE
switch (baseCondition->type) {
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:
case NODE_TYPE_INDEXED_ACCESS:
TRI_ASSERT(baseCondition->numMembers() == 2);
break;
case NODE_TYPE_ATTRIBUTE_ACCESS:
TRI_ASSERT(baseCondition->numMembers() == 1);
break;
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:
TRI_ASSERT(baseCondition->numMembers() == 3);
break;
default:
TRI_ASSERT(false);
break;
}
#endif
if (!baseCondition->isSimple()) {
// We would need v8 for this condition.
// This will not be used.
continue;
}
auto op = baseCondition->type;
AstNode* top = baseCondition;
bool isEdge = false;
if (op >= NODE_TYPE_OPERATOR_BINARY_ARRAY_EQ &&
op <= NODE_TYPE_OPERATOR_BINARY_ARRAY_NIN) {
// We have to handle this differently iff the left side is path access
AstNode* testee = baseCondition->getMemberUnchecked(0);
VariableId toReplace;
if (matchesArrayAccessPattern(testee, pvar, isEdge, toReplace)) {
auto quantifier = baseCondition->getMemberUnchecked(2);
TRI_ASSERT(quantifier->type == NODE_TYPE_QUANTIFIER);
int64_t val = quantifier->getIntValue(true);
if (val == Quantifier::ANY) {
// Nono optimize for ANY
continue;
}
AstNode* newCondition = createGlobalCondition(ast, baseCondition);
std::unordered_map<VariableId, Variable const*> replacements;
replacements.emplace(toReplace, tn->getTemporaryVariable());
newCondition = ast->replaceVariables(newCondition, replacements);
tn->registerGlobalCondition(isEdge, newCondition);
result->changeMember(i, newCondition);
continue;
}
}
size_t idx = 0;
if (op == NODE_TYPE_ATTRIBUTE_ACCESS) {
// We only have a single attribute access. Identical to attr == true
AstNode* testee = baseCondition;
while(true) {
if (testee->numMembers() == 0) {
// Ok we barked up the wrong tree. Give up
break;
}
if (matchesPathAccessPattern(testee, pvar, idx, isEdge)) {
// On top level we may change a different member:
// cond == p.edges[x]
// Otherwise we always switch the 0 member.
top->changeMember(0, varRefNode);
tn->registerCondition(isEdge, idx, baseCondition);
break;
}
top = testee;
testee = testee->getMemberUnchecked(0);
}
continue;
}
bool foundVar = false;
TRI_ASSERT(baseCondition->numMembers() >= 2);
for (size_t i = 0; i < 2; ++i) {
bool firstRun = true;
AstNode* testee = baseCondition->getMemberUnchecked(i);
while(true) {
if (testee->numMembers() == 0) {
// Ok we barked up the wrong tree. Give up
break;
}
if (matchesPathAccessPattern(testee, pvar, idx, isEdge)) {
// We only find one!
TRI_ASSERT(!foundVar);
foundVar = true;
// On top level we may change a different member:
// cond == p.edges[x]
// Otherwise we always switch the 0 member.
top->changeMember(firstRun ? i : 0, varRefNode);
tn->registerCondition(isEdge, idx, baseCondition);
break;
}
top = testee;
testee = testee->getMemberUnchecked(0);
firstRun = false;
}
if (foundVar) {
// We have an access. Can only be one.
break;
}
}
}
}
bool TraversalConditionFinder::before(ExecutionNode* en) {
if (!_variableDefinitions.empty() && en->canThrow()) {
// we already found a FILTER and
// something that can throw is not safe to optimize
_filters.clear();
return true;
}
switch (en->getType()) {
case EN::ENUMERATE_LIST:
case EN::COLLECT:
case EN::SCATTER:
case EN::DISTRIBUTE:
case EN::GATHER:
case EN::REMOTE:
case EN::SUBQUERY:
case EN::INDEX:
case EN::INSERT:
case EN::REMOVE:
case EN::REPLACE:
case EN::UPDATE:
case EN::UPSERT:
case EN::RETURN:
case EN::SORT:
case EN::ENUMERATE_COLLECTION:
case EN::LIMIT:
case EN::SHORTEST_PATH:
// in these cases we simply ignore the intermediate nodes, note
// that we have taken care of nodes that could throw exceptions
// above.
break;
case EN::SINGLETON:
case EN::NORESULTS:
case EN::ILLEGAL:
// in all these cases we better abort
return true;
case EN::FILTER: {
std::vector<Variable const*>&& invars = en->getVariablesUsedHere();
TRI_ASSERT(invars.size() == 1);
// register which variable is used in a FILTER
_filters.emplace(invars[0]->id, en);
break;
}
case EN::CALCULATION: {
auto outvars = en->getVariablesSetHere();
TRI_ASSERT(outvars.size() == 1);
_variableDefinitions.emplace(outvars[0]->id,
static_cast<CalculationNode const*>(en));
TRI_IF_FAILURE("ConditionFinder::variableDefinition") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
break;
}
case EN::TRAVERSAL: {
auto node = static_cast<TraversalNode*>(en);
auto condition = std::make_unique<Condition>(_plan->getAst());
bool foundCondition = false;
auto const& varsValidInTraversal = node->getVarsValid();
std::unordered_set<Variable const*> varsUsedByCondition;
bool conditionIsImpossible = false;
for (auto& it : _variableDefinitions) {
auto f = _filters.find(it.first);
if (f != _filters.end()) {
// a variable used in a FILTER
auto outVar = node->getVariablesSetHere();
if (outVar.size() != 1 || outVar[0]->id == f->first) {
// now we know, this filter is used for our traversal node.
auto cn = it.second;
// check whether variables that are not in scope of the condition
// are used:
varsUsedByCondition.clear();
Ast::getReferencedVariables(cn->expression()->node(),
varsUsedByCondition);
bool unknownVariableFound = false;
for (auto const& conditionVar : varsUsedByCondition) {
bool found = false;
for (auto const& traversalKnownVar : varsValidInTraversal) {
if (conditionVar->id == traversalKnownVar->id) {
found = true;
break;
}
}
if (!found) {
unknownVariableFound = true;
break;
}
}
if (unknownVariableFound) {
continue;
}
for (auto const& conditionVar : varsUsedByCondition) {
// check whether conditionVar is one of those we emit
int variableType = node->checkIsOutVariable(conditionVar->id);
if (variableType >= 0) {
if ((variableType == 2) &&
checkPathVariableAccessFeasible(cn, node, conditionVar,
conditionIsImpossible)) {
condition->andCombine(
it.second->expression()->node()->clone(_plan->getAst()));
foundCondition = true;
}
if (conditionIsImpossible) {
break;
}
}
}
}
}
if (conditionIsImpossible) {
break;
}
}
// TODO: we can't execute if we condition->normalize(_plan); in
// generateCodeNode
if (!conditionIsImpossible) {
// right now we're not clever enough to find impossible conditions...
conditionIsImpossible = (foundCondition && condition->isEmpty());
}
if (conditionIsImpossible) {
// condition is always false
for (auto const& x : node->getParents()) {
auto noRes = new NoResultsNode(_plan, _plan->nextId());
_plan->registerNode(noRes);
_plan->insertDependency(x, noRes);
*_planAltered = true;
}
break;
}
if (foundCondition) {
condition->normalize();
TRI_IF_FAILURE("ConditionFinder::normalizePlan") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
transformCondition(condition->root(), node->pathOutVariable(), _plan->getAst(), node);
node->setCondition(condition.release());
*_planAltered = true;
}
break;
}
}
return false;
}
bool TraversalConditionFinder::enterSubquery(ExecutionNode*, ExecutionNode*) {
return false;
}
Reference in New Issue View Git Blame Copy Permalink