void NegativeNodePredicateFilterQP::applyConversionRules(unsigned int maxAlternatives, OptimizationContext &opt, QueryPlans &alternatives)
{
XPath2MemoryManager *mm = opt.getMemoryManager();
// Dissolve useless predicates
if(pred_->getType() == VARIABLE) {
VariableQP *var = (VariableQP*)pred_;
if(XPath2Utils::equals(name_, var->getName()) &&
XPath2Utils::equals(uri_, var->getURI())) {
EmptyQP *empty = new (mm) EmptyQP(0, mm);
empty->setLocationInfo(this);
alternatives.push_back(empty);
return;
}
}
// Dissolve predicates in our predicate expression
if(pred_->getType() == NODE_PREDICATE_FILTER) {
NodePredicateFilterQP *npf = (NodePredicateFilterQP*)pred_;
ContextNodeAndVarReplacer replacer(npf->getURI(), npf->getName());
if((npf->getFlags() & QueryPlan::SKIP_NESTED_PREDICATES) == 0 &&
replacer.test(npf->getPred())) {
string before = logBefore(this);
unsigned int bufferId = GET_CONFIGURATION(opt.getContext())->allocateBufferID();
BufferQP *buffer = new (mm) BufferQP(npf->getArg()->copy(mm), 0, bufferId, 0, mm);
buffer->setLocationInfo(npf->getArg());
buffer->setArg(replacer.run(npf->getPred()->copy(mm), buffer, mm));
pred_ = buffer;
logTransformation(opt.getLog(), "Nested predicates", before, this);
pred_ = npf;
QueryPlans bufferAlts;
buffer->applyConversionRules(maxAlternatives, opt, bufferAlts);
for(QueryPlans::iterator it = bufferAlts.begin(); it != bufferAlts.end(); ++it) {
NegativeNodePredicateFilterQP *result = new (mm) NegativeNodePredicateFilterQP(arg_->copy(mm), *it, uri_, name_, flags_, mm);
result->setLocationInfo(this);
result->applyConversionRules(maxAlternatives, opt, alternatives);
}
release();
return;
}
}
alternatives.push_back(this);
{
AutoRelease<QueryPlan> result(ReverseJoin().run(this, opt, mm));
if(result.get() != 0) result->createAlternatives(maxAlternatives, opt, alternatives);
}
addFlag(SKIP_REVERSE_JOIN);
}
void IntersectQP::applyConversionRules(unsigned int maxAlternatives, OptimizationContext &opt, QueryPlans &alternatives)
{
XPath2MemoryManager *mm = opt.getMemoryManager();
removeSupersets(opt);
// Return if we only have one argument
if(args_.size() == 1) {
alternatives.push_back(args_[0]);
return;
}
// TBD remove the need for QueryExecutionContext here - jpcs
QueryExecutionContext qec(GET_CONFIGURATION(opt.getContext())->getQueryContext(),
/*debugging*/false);
qec.setContainerBase(opt.getContainerBase());
qec.setDynamicContext(opt.getContext());
// Sort the arguments based on how many keys we think they'll return
sort(args_.begin(), args_.end(), keys_compare_less(opt.getOperationContext(), qec));
alternatives.push_back(this);
for(Vector::const_iterator it = args_.begin(); it != args_.end(); ++it) {
for(Vector::const_iterator it2 = it + 1; it2 != args_.end(); ++it2) {
QueryPlans alts;
applyConversionRules2Args(maxAlternatives, *it, *it2, opt, alts);
for(QueryPlans::iterator it3 = alts.begin(); it3 != alts.end(); ++it3) {
IntersectQP *newIntersect = new (mm) IntersectQP(flags_, mm);
newIntersect->setLocationInfo(this);
Vector::const_iterator it4;
// Copy args before "it"
for(it4 = args_.begin(); it4 != it; ++it4) {
newIntersect->addArg((*it4)->copy(mm));
}
// Add new alternative
newIntersect->addArg(*it3);
// Copy args from after "it" to before "it2"
for(++it4; it4 != it2; ++it4) {
newIntersect->addArg((*it4)->copy(mm));
}
// Copy args from after "it2"
for(++it4; it4 != args_.end(); ++it4) {
newIntersect->addArg((*it4)->copy(mm));
}
newIntersect->applyConversionRules(maxAlternatives, opt, alternatives);
}
}
}
}
void DecisionPointQP::createCombinations(unsigned int maxAlternatives, OptimizationContext &opt, QueryPlans &combinations) const
{
// DecisionPointQP doesn't participate in any of the optimisations of it's parents,
// so we make the decision of what to pick here.
XPath2MemoryManager *mm = opt.getMemoryManager();
DecisionPointQP *result = new (mm) DecisionPointQP(this, opt, mm);
result->setLocationInfo(this);
combinations.push_back(result);
}
void DescendantOrSelfJoinQP::applyConversionRules(unsigned int maxAlternatives, OptimizationContext &opt, QueryPlans &alternatives)
{
XPath2MemoryManager *mm = opt.getMemoryManager();
if(containsAllDocumentNodes(left_)) {
// Any node is a descendant-or-self of all document nodes
logTransformation(opt.getLog(), "Redundant descendant-or-self", this, right_);
alternatives.push_back(right_->copy(mm));
}
StructuralJoinQP::applyConversionRules(maxAlternatives, opt, alternatives);
}
void DescendantJoinQP::applyConversionRules(unsigned int maxAlternatives, OptimizationContext &opt, QueryPlans &alternatives)
{
XPath2MemoryManager *mm = opt.getMemoryManager();
if(containsAllDocumentNodes(left_)) {
ImpliedSchemaNode::Type rType = findType(right_);
if(rType != (ImpliedSchemaNode::Type)-1 && rType != ImpliedSchemaNode::METADATA) {
// Any node except a document node is a descendant of all document nodes
logTransformation(opt.getLog(), "Redundant descendant", this, right_);
alternatives.push_back(right_->copy(mm));
}
}
StructuralJoinQP::applyConversionRules(maxAlternatives, opt, alternatives);
}
void IntersectQP::combineAltArgs(vector<QueryPlans>::iterator argIt, vector<QueryPlans>::iterator argEnd,
vector<QueryPlan*> &newArgs, OptimizationContext &opt, QueryPlans &combinations) const
{
XPath2MemoryManager *mm = opt.getMemoryManager();
if(argIt != argEnd) {
for(QueryPlans::iterator it3 = argIt->begin(); it3 != argIt->end(); ++it3) {
newArgs.push_back(*it3);
combineAltArgs(argIt + 1, argEnd, newArgs, opt, combinations);
newArgs.pop_back();
}
} else {
// Construct the new IntersectQP
IntersectQP *newIntersect = new (mm) IntersectQP(flags_, mm);
newIntersect->setLocationInfo(this);
for(vector<QueryPlan*>::iterator it = newArgs.begin(); it != newArgs.end(); ++it) {
newIntersect->addArg((*it)->copy(mm));
}
// Add this IntersectQP to the combinations vector
combinations.push_back(newIntersect);
}
}
void NegativeNodePredicateFilterQP::createCombinations(unsigned int maxAlternatives, OptimizationContext &opt, QueryPlans &combinations) const
{
XPath2MemoryManager *mm = opt.getMemoryManager();
// Generate the alternatives for the arguments
QueryPlans argAltArgs;
arg_->createReducedAlternatives(ARGUMENT_CUTOFF_FACTOR, maxAlternatives, opt, argAltArgs);
QueryPlans predAltArgs;
pred_->createReducedAlternatives(ARGUMENT_CUTOFF_FACTOR, maxAlternatives, opt, predAltArgs);
// Generate the combinations of all the alternatives for the arguments
QueryPlans::iterator it;
for(it = argAltArgs.begin(); it != argAltArgs.end(); ++it) {
for(QueryPlans::iterator it2 = predAltArgs.begin(); it2 != predAltArgs.end(); ++it2) {
NegativeNodePredicateFilterQP *newPred = new (mm) NegativeNodePredicateFilterQP((*it)->copy(mm),
(*it2)->copy(mm), uri_, name_, flags_, mm);
newPred->setLocationInfo(this);
combinations.push_back(newPred);
}
}
// Release the alternative arguments, since they've been copied
for(it = argAltArgs.begin(); it != argAltArgs.end(); ++it) {
(*it)->release();
}
for(it = predAltArgs.begin(); it != predAltArgs.end(); ++it) {
(*it)->release();
}
}