public void testRemove() { // Set up RuleStack stack = new RuleStack(); stack.push(RuleConstants.ACCESS_PATTERN_VALIDATION); stack.push(RuleConstants.COLLAPSE_SOURCE); stack.push(RuleConstants.ACCESS_PATTERN_VALIDATION); // Remove all instances of ASSIGN_OUTPUT_ELEMENTS stack.remove(RuleConstants.ACCESS_PATTERN_VALIDATION); // Verify size and pop'ed values assertEquals(1, stack.size()); assertEquals(RuleConstants.COLLAPSE_SOURCE, stack.pop()); assertEquals(null, stack.pop()); }
/** * @see OptimizerRule#execute(PlanNode, QueryMetadataInterface, RuleStack) */ public PlanNode execute(PlanNode plan, QueryMetadataInterface metadata, CapabilitiesFinder capFinder, RuleStack rules, AnalysisRecord analysisRecord, CommandContext context) throws QueryPlannerException, TeiidComponentException { boolean pushRaiseNull = false; pushRaiseNull = clean(plan, !rules.contains(RuleConstants.COPY_CRITERIA)); if (pushRaiseNull) { rules.push(RuleConstants.RAISE_NULL); } return plan; }
public RuleStack buildRules() { RuleStack rules = new RuleStack(); rules.setPlanner(this); rules.push(RuleConstants.COLLAPSE_SOURCE); rules.push(RuleConstants.PLAN_SORTS); rules.push(new RuleMergeCriteria(idGenerator, capFinder, analysisRecord, context, metadata)); rules.push(RuleConstants.IMPLEMENT_JOIN_STRATEGY); rules.push(RuleConstants.CALCULATE_COST); rules.push(RuleConstants.PUSH_LIMIT); rules.push(new RuleAssignOutputElements(true)); rules.push(RuleConstants.PLAN_PROCEDURES); rules.push(RuleConstants.CHOOSE_DEPENDENT); rules.push(RuleConstants.PUSH_LARGE_IN); rules.push(new RulePushAggregates(idGenerator)); if (hints.hasJoin) { rules.push(new RuleChooseDependent(true)); rules.push(RuleConstants.CHOOSE_JOIN_STRATEGY); rules.push(RuleConstants.PLAN_OUTER_JOINS);
/** * @see OptimizerRule#execute(PlanNode, QueryMetadataInterface, RuleStack) */ public PlanNode execute(PlanNode plan, QueryMetadataInterface metadata, CapabilitiesFinder capFinder, RuleStack rules, AnalysisRecord analysisRecord, CommandContext context) throws QueryPlannerException, TeiidComponentException { dependent = false; processSubqueries(plan); if (dependent) { rules.push(RuleConstants.PUSH_SELECT_CRITERIA); } return plan; }
public void testContains() { // Set up RuleStack stack = new RuleStack(); stack.push(RuleConstants.ACCESS_PATTERN_VALIDATION); stack.push(RuleConstants.COLLAPSE_SOURCE); assertEquals(true, stack.contains(RuleConstants.ACCESS_PATTERN_VALIDATION)); assertEquals(false, stack.contains(RuleConstants.PLACE_ACCESS)); }
project.addFirstChild(indNode); RuleStack ruleCopy = rules.clone(); RuleChooseDependent ruleChooseDependent = new RuleChooseDependent(); ruleChooseDependent.traditionalOnly = true; ruleCopy.push(ruleChooseDependent); project = rules.getPlanner().executeRules(ruleCopy, project); source.setProperty(Info.SYMBOL_MAP, symbolMap); source.setProperty(Info.SUB_PLAN, project);
public PlanNode executeRules(RuleStack rules, PlanNode plan) throws QueryPlannerException, QueryMetadataException, TeiidComponentException { boolean debug = analysisRecord.recordDebug(); while(! rules.isEmpty()) { if(debug) { analysisRecord.println("\n============================================================================"); //$NON-NLS-1$ } OptimizerRule rule = rules.pop(); if(debug) { analysisRecord.println("EXECUTING " + rule); //$NON-NLS-1$ } plan = rule.execute(plan, metadata, capFinder, rules, analysisRecord, context); if(debug) { analysisRecord.println("\nAFTER: \n" + plan.nodeToString(true)); //$NON-NLS-1$ } } return plan; }
@Override public PlanNode execute(PlanNode plan, QueryMetadataInterface metadata, CapabilitiesFinder capabilitiesFinder, RuleStack rules, AnalysisRecord analysisRecord, CommandContext context) throws QueryPlannerException, QueryMetadataException, TeiidComponentException { boolean beforeJoinPlanning = rules.contains(RuleConstants.PLAN_JOINS); while (beforeJoinPlanning? planLeftOuterJoinAssociativityBeforePlanning(plan, metadata, capabilitiesFinder, analysisRecord, context): planLeftOuterJoinAssociativity(plan, metadata, capabilitiesFinder, analysisRecord, context)) { //repeat } return plan; }
public RuleStack clone() { RuleStack clone = new RuleStack(); clone.rules.addAll(this.rules); clone.planner = this.planner; return clone; }
public PlanNode execute(PlanNode plan, QueryMetadataInterface metadata, CapabilitiesFinder capFinder, RuleStack rules, AnalysisRecord analysisRecord, CommandContext context) throws QueryMetadataException, TeiidComponentException, QueryPlannerException { Set<String> groups = context.getGroups(); boolean[] addtionalRules = new boolean[2]; for (PlanNode sourceNode : NodeEditor.findAllNodes(plan, NodeConstants.Types.SOURCE)) { addAccessNode(metadata, sourceNode, capFinder, addtionalRules); addAlias(sourceNode, context, groups, metadata); } if (addtionalRules[0]) { rules.addLast(RuleConstants.ACCESS_PATTERN_VALIDATION); } if (addtionalRules[1]) { rules.addLast(RuleConstants.VALIDATE_WHERE_ALL); } return plan; }
project = RelationalPlanner.createProjectNode(masked); rules.getPlanner().planSubqueries(sourceNode.getGroups(), project, project.getSubqueryContainers(), true); project.addGroups(GroupsUsedByElementsVisitor.getGroups(project.getCorrelatedReferenceElements())); if (!group.isProcedure()) { parent = critNode; rules.getPlanner().planSubqueries(sourceNode.getGroups(), critNode, critNode.getSubqueryContainers(), true); critNode.addGroups(GroupsUsedByElementsVisitor.getGroups(critNode.getCorrelatedReferenceElements())); root.addAsParent(critNode);
public RuleStack buildRules() { RuleStack rules = new RuleStack(); rules.setPlanner(this); rules.push(RuleConstants.COLLAPSE_SOURCE); rules.push(RuleConstants.PLAN_SORTS); rules.push(RuleConstants.MERGE_CRITERIA); rules.push(new RulePlanSubqueries(idGenerator, capFinder, analysisRecord, context, metadata)); rules.push(RuleConstants.IMPLEMENT_JOIN_STRATEGY); rules.push(RuleConstants.CALCULATE_COST); rules.push(RuleConstants.PUSH_LIMIT); rules.push(new RuleAssignOutputElements(true)); rules.push(RuleConstants.PLAN_PROCEDURES); rules.push(RuleConstants.CHOOSE_DEPENDENT); rules.push(RuleConstants.PUSH_LARGE_IN); rules.push(new RulePushAggregates(idGenerator)); if (hints.hasJoin) { rules.push(new RuleChooseDependent(true));
/** * @see OptimizerRule#execute(PlanNode, QueryMetadataInterface, RuleStack) */ public PlanNode execute(PlanNode plan, QueryMetadataInterface metadata, CapabilitiesFinder capFinder, RuleStack rules, AnalysisRecord analysisRecord, CommandContext context) throws QueryPlannerException, TeiidComponentException { dependent = false; processSubqueries(plan); if (dependent) { rules.push(RuleConstants.PUSH_SELECT_CRITERIA); } return plan; }
project.addFirstChild(indNode); RuleStack ruleCopy = rules.clone(); RuleChooseDependent ruleChooseDependent = new RuleChooseDependent(); ruleChooseDependent.traditionalOnly = true; ruleCopy.push(ruleChooseDependent); project = rules.getPlanner().executeRules(ruleCopy, project); source.setProperty(Info.SYMBOL_MAP, symbolMap); source.setProperty(Info.SUB_PLAN, project);
public PlanNode executeRules(RuleStack rules, PlanNode plan) throws QueryPlannerException, QueryMetadataException, TeiidComponentException { boolean debug = analysisRecord.recordDebug(); while(! rules.isEmpty()) { if(debug) { analysisRecord.println("\n============================================================================"); //$NON-NLS-1$ } OptimizerRule rule = rules.pop(); if(debug) { analysisRecord.println("EXECUTING " + rule); //$NON-NLS-1$ } plan = rule.execute(plan, metadata, capFinder, rules, analysisRecord, context); if(debug) { analysisRecord.println("\nAFTER: \n" + plan.nodeToString(true)); //$NON-NLS-1$ } } return plan; }