/** * Attach DUP_REMOVE node at top of tree. The DUP_REMOVE may be pushed down * to a source (or sources) if possible by the optimizer. * @param plan Existing plan * @return Updated plan */ private static PlanNode attachDupRemoval(PlanNode plan) { PlanNode dupNode = NodeFactory.getNewNode(NodeConstants.Types.DUP_REMOVE); attachLast(dupNode, plan); return dupNode; }
private static PlanNode newLimit(PlanNode limitNode) { PlanNode newLimit = NodeFactory.getNewNode(NodeConstants.Types.TUPLE_LIMIT); if (limitNode.hasBooleanProperty(Info.IS_NON_STRICT)) { newLimit.setProperty(Info.IS_NON_STRICT, Boolean.TRUE); } return newLimit; }
private static PlanNode createSortNode(List<Expression> orderSymbols, Collection<Expression> outputElements) { PlanNode sortNode = NodeFactory.getNewNode(NodeConstants.Types.SORT); OrderBy order = new OrderBy(orderSymbols); sortNode.setProperty(NodeConstants.Info.SORT_ORDER, order); sortNode.setProperty(NodeConstants.Info.OUTPUT_COLS, new ArrayList<Expression>(outputElements)); return sortNode; }
private void addEmptyFilter(Collection<AggregateSymbol> aggregates, PlanNode stageGroup, QueryMetadataInterface metadata, CapabilitiesFinder capFinder, Object modelId) throws QueryMetadataException, TeiidComponentException { PlanNode selectNode = NodeFactory.getNewNode(NodeConstants.Types.SELECT); AggregateSymbol count = new AggregateSymbol(NonReserved.COUNT, false, null); aggregates.add(count); //consider the count aggregate for the push down call below Criteria crit = new CompareCriteria(count, CompareCriteria.GT, new Constant(new Integer(0))); selectNode.setProperty(NodeConstants.Info.SELECT_CRITERIA, crit); selectNode.setProperty(NodeConstants.Info.IS_HAVING, Boolean.TRUE); stageGroup.addAsParent(selectNode); }
private void addEmptyFilter(Collection<AggregateSymbol> aggregates, PlanNode stageGroup, QueryMetadataInterface metadata, CapabilitiesFinder capFinder, Object modelId) throws QueryMetadataException, TeiidComponentException { PlanNode selectNode = NodeFactory.getNewNode(NodeConstants.Types.SELECT); AggregateSymbol count = new AggregateSymbol(NonReserved.COUNT, false, null); aggregates.add(count); //consider the count aggregate for the push down call below Criteria crit = new CompareCriteria(count, CompareCriteria.GT, new Constant(new Integer(0))); selectNode.setProperty(NodeConstants.Info.SELECT_CRITERIA, crit); selectNode.setProperty(NodeConstants.Info.IS_HAVING, Boolean.TRUE); stageGroup.addAsParent(selectNode); }
private void addEmptyFilter(Collection<AggregateSymbol> aggregates, PlanNode stageGroup, QueryMetadataInterface metadata, CapabilitiesFinder capFinder, Object modelId) throws QueryMetadataException, TeiidComponentException { PlanNode selectNode = NodeFactory.getNewNode(NodeConstants.Types.SELECT); AggregateSymbol count = new AggregateSymbol(NonReserved.COUNT, false, null); aggregates.add(count); //consider the count aggregate for the push down call below Criteria crit = new CompareCriteria(count, CompareCriteria.GT, new Constant(new Integer(0))); selectNode.setProperty(NodeConstants.Info.SELECT_CRITERIA, crit); selectNode.setProperty(NodeConstants.Info.IS_HAVING, Boolean.TRUE); stageGroup.addAsParent(selectNode); }
public static PlanNode createProjectNode(List<? extends Expression> select) { PlanNode projectNode = NodeFactory.getNewNode(NodeConstants.Types.PROJECT); projectNode.setProperty(NodeConstants.Info.PROJECT_COLS, select); // Set groups projectNode.addGroups(GroupsUsedByElementsVisitor.getGroups(select)); return projectNode; }
public static PlanNode createProjectNode(List<? extends Expression> select) { PlanNode projectNode = NodeFactory.getNewNode(NodeConstants.Types.PROJECT); projectNode.setProperty(NodeConstants.Info.PROJECT_COLS, select); // Set groups projectNode.addGroups(GroupsUsedByElementsVisitor.getGroups(select)); return projectNode; }
private static PlanNode createSortNode(List<Expression> orderSymbols, Collection<Expression> outputElements) { PlanNode sortNode = NodeFactory.getNewNode(NodeConstants.Types.SORT); OrderBy order = new OrderBy(orderSymbols); order.setUserOrdering(false); sortNode.setProperty(NodeConstants.Info.SORT_ORDER, order); sortNode.setProperty(NodeConstants.Info.OUTPUT_COLS, new ArrayList<Expression>(outputElements)); return sortNode; }
private static PlanNode createSortNode(List<Expression> orderSymbols, Collection<Expression> outputElements) { PlanNode sortNode = NodeFactory.getNewNode(NodeConstants.Types.SORT); OrderBy order = new OrderBy(orderSymbols); order.setUserOrdering(false); sortNode.setProperty(NodeConstants.Info.SORT_ORDER, order); sortNode.setProperty(NodeConstants.Info.OUTPUT_COLS, new ArrayList<Expression>(outputElements)); return sortNode; }
private static PlanNode helpGetJoinNode(float childCost1, float childCost2, JoinType joinType){ PlanNode joinNode = NodeFactory.getNewNode(NodeConstants.Types.JOIN); PlanNode child1 = NodeFactory.getNewNode(NodeConstants.Types.ACCESS); PlanNode child2 = NodeFactory.getNewNode(NodeConstants.Types.ACCESS); joinNode.addLastChild(child1); joinNode.addLastChild(child2); child1.setProperty(NodeConstants.Info.EST_CARDINALITY, new Float(childCost1)); child2.setProperty(NodeConstants.Info.EST_CARDINALITY, new Float(childCost2)); joinNode.setProperty(NodeConstants.Info.JOIN_TYPE, joinType); return joinNode; }
@Test public void testFindNoAllUnion1() { PlanNode projNode = NodeFactory.getNewNode(NodeConstants.Types.PROJECT); PlanNode accessNode = NodeFactory.getNewNode(NodeConstants.Types.ACCESS); projNode.addLastChild(accessNode); helpTestIsUnionNoAll(projNode, false); }
@Test public void testFindNoAllUnion3() { PlanNode unionNode = NodeFactory.getNewNode(NodeConstants.Types.SET_OP); unionNode.setProperty(NodeConstants.Info.SET_OPERATION, Operation.UNION); unionNode.setProperty(NodeConstants.Info.USE_ALL, Boolean.FALSE); PlanNode projNode1 = NodeFactory.getNewNode(NodeConstants.Types.PROJECT); PlanNode accessNode1 = NodeFactory.getNewNode(NodeConstants.Types.ACCESS); PlanNode projNode2 = NodeFactory.getNewNode(NodeConstants.Types.PROJECT); PlanNode accessNode2 = NodeFactory.getNewNode(NodeConstants.Types.ACCESS); unionNode.addLastChild(projNode1); projNode1.addLastChild(accessNode1); unionNode.addLastChild(projNode2); projNode2.addLastChild(accessNode2); helpTestIsUnionNoAll(unionNode, true); }
public static PlanNode createSelectNode(final Criteria crit, boolean isHaving) { PlanNode critNode = NodeFactory.getNewNode(NodeConstants.Types.SELECT); critNode.setProperty(NodeConstants.Info.SELECT_CRITERIA, crit); //TODO: we should check for grouping expression correlations, but those are not yet set when this is // called in the planner, so we look for any subquery if (isHaving && (!ElementCollectorVisitor.getAggregates(crit, false).isEmpty() || !ValueIteratorProviderCollectorVisitor.getValueIteratorProviders(crit).isEmpty())) { critNode.setProperty(NodeConstants.Info.IS_HAVING, Boolean.TRUE); } // Add groups to crit node critNode.addGroups(GroupsUsedByElementsVisitor.getGroups(crit)); critNode.addGroups(GroupsUsedByElementsVisitor.getGroups(critNode.getCorrelatedReferenceElements())); return critNode; }
public static PlanNode createSortNode(OrderBy orderBy) { PlanNode sortNode = NodeFactory.getNewNode(NodeConstants.Types.SORT); sortNode.setProperty(NodeConstants.Info.SORT_ORDER, orderBy); if (orderBy.hasUnrelated()) { sortNode.setProperty(Info.UNRELATED_SORT, true); } sortNode.addGroups(GroupsUsedByElementsVisitor.getGroups(orderBy)); return sortNode; }
static PlanNode createSource(GroupSymbol group, PlanNode child, List<ElementSymbol> newProject) { PlanNode branchSource = NodeFactory.getNewNode(NodeConstants.Types.SOURCE); branchSource.addGroup(group); PlanNode projectNode = NodeEditor.findNodePreOrder(child, NodeConstants.Types.PROJECT); branchSource.setProperty(Info.SYMBOL_MAP, SymbolMap.createSymbolMap(newProject, (List<? extends Expression>)projectNode.getProperty(Info.PROJECT_COLS))); child.addAsParent(branchSource); return branchSource; }
static PlanNode createSource(GroupSymbol group, PlanNode child, List<ElementSymbol> newProject) { PlanNode branchSource = NodeFactory.getNewNode(NodeConstants.Types.SOURCE); branchSource.addGroup(group); PlanNode projectNode = NodeEditor.findNodePreOrder(child, NodeConstants.Types.PROJECT); branchSource.setProperty(Info.SYMBOL_MAP, SymbolMap.createSymbolMap(newProject, (List<? extends Expression>)projectNode.getProperty(Info.PROJECT_COLS))); child.addAsParent(branchSource); return branchSource; }
@Test public void testValidJoin1() throws Exception { PlanNode accessNode = NodeFactory.getNewNode(NodeConstants.Types.ACCESS); accessNode.addGroup(getPhysicalGroup(1)); PlanNode joinNode = NodeFactory.getNewNode(NodeConstants.Types.JOIN); joinNode.setProperty(NodeConstants.Info.JOIN_TYPE, JoinType.JOIN_CROSS); joinNode.addFirstChild(accessNode); helpTestValidJoin(joinNode, accessNode, false); }
/** * Simple test to ensure that the reconstruction logic doesn't fail with a single source */ public void testReconstructionOf1Source() { PlanNode source = NodeFactory.getNewNode(NodeConstants.Types.SOURCE); PlanNode accessNode = NodeFactory.getNewNode(NodeConstants.Types.ACCESS); source.addFirstChild(accessNode); JoinRegion region = new JoinRegion(); region.addJoinSourceNode(accessNode); region.reconstructJoinRegoin(); assertEquals(NodeConstants.Types.ACCESS, region.getJoinRoot().getType()); }
@Test public void testProjectLiteral4() throws Exception { PlanNode project = NodeFactory.getNewNode(NodeConstants.Types.PROJECT); project.setProperty(Info.PROJECT_COLS, Arrays.asList(new Constant(1))); PlanNode access = NodeFactory.getNewNode(NodeConstants.Types.ACCESS); project.addFirstChild(access); access.setProperty(NodeConstants.Info.EST_CARDINALITY, NewCalculateCostUtil.UNKNOWN_VALUE); PlanNode dup = NodeFactory.getNewNode(NodeConstants.Types.DUP_REMOVE); dup.addFirstChild(project); float cost = NewCalculateCostUtil.computeCostForTree(dup, RealMetadataFactory.example1Cached()); assertEquals(NewCalculateCostUtil.UNKNOWN_VALUE, cost, 0); ColStats colStats = (ColStats)dup.getProperty(Info.EST_COL_STATS); assertEquals("{1=[1.0, 1.0, 0.0]}", colStats.toString()); }