public static org.teiid.query.sql.lang.SetQuery helpExampleSetQuery() { org.teiid.query.sql.lang.SetQuery setQuery = new org.teiid.query.sql.lang.SetQuery(Operation.UNION); setQuery.setAll(false); setQuery.setLeftQuery(TestQueryImpl.helpExample(true)); setQuery.setRightQuery(TestQueryImpl.helpExample(true)); setQuery.setOrderBy(TestOrderByImpl.helpExample()); return setQuery; }
public Query getProjectedQuery() { if (leftQuery instanceof SetQuery) { return ((SetQuery)leftQuery).getProjectedQuery(); } return (Query)leftQuery; }
protected void validateSetQuery(SetQuery query) { // Walk through sub queries - validate each one separately and // also check the columns of each for comparability for (QueryCommand subQuery : query.getQueryCommands()) { if (subQuery instanceof Query && ((Query)subQuery).getInto() != null) { handleValidationError(QueryPlugin.Util.getString("ValidationVisitor.union_insert"), query); //$NON-NLS-1$ } } if (!query.isAll() || query.getOperation() == Operation.EXCEPT || query.getOperation() == Operation.INTERSECT) { validateSortable(query.getProjectedSymbols()); } if (query.isAll() && (query.getOperation() == Operation.EXCEPT || query.getOperation() == Operation.INTERSECT)) { handleValidationError(QueryPlugin.Util.getString("ValidationVisitor.excpet_intersect_all"), query); //$NON-NLS-1$ } }
/** * Get the ordered list of all elements returned by this query. These elements * may be ElementSymbols or ExpressionSymbols but in all cases each represents a * single column. * @return Ordered list of SingleElementSymbol */ public List getProjectedSymbols() { Query query = getProjectedQuery(); List projectedSymbols = query.getProjectedSymbols(); if (projectedTypes != null) { return getTypedProjectedSymbols(projectedSymbols, projectedTypes, metadata); } return projectedSymbols; }
private SetQuery rewriteSetQuery(SetQuery setQuery) throws TeiidComponentException, TeiidProcessingException{ if (setQuery.getProjectedTypes() != null) { for (QueryCommand command : setQuery.getQueryCommands()) { if (!(command instanceof Query)) { continue; } correctProjectedTypes(setQuery.getProjectedTypes(), (Query)command); } setQuery.setProjectedTypes(null, null); } setQuery.setLeftQuery((QueryCommand)rewriteCommand(setQuery.getLeftQuery(), true)); setQuery.setRightQuery((QueryCommand)rewriteCommand(setQuery.getRightQuery(), true)); rewriteOrderBy(setQuery); if (setQuery.getLimit() != null) { setQuery.setLimit(rewriteLimitClause(setQuery.getLimit())); } return setQuery; }
/** * Deep clone this object to produce a new identical query. * @return Deep clone */ public Object clone() { SetQuery copy = new SetQuery(this.operation); this.copyMetadataState(copy); copy.leftQuery = (QueryCommand)this.leftQuery.clone(); copy.rightQuery = (QueryCommand)this.rightQuery.clone(); copy.setAll(this.all); if(this.getOrderBy() != null) { copy.setOrderBy(this.getOrderBy().clone()); } if(this.getLimit() != null) { copy.setLimit( (Limit) this.getLimit().clone() ); } copy.setWith(LanguageObject.Util.deepClone(this.getWith(), WithQueryCommand.class)); if (this.projectedTypes != null) { copy.setProjectedTypes(new ArrayList<Class<?>>(projectedTypes), this.metadata); } return copy; }
public void visit(SetQuery obj) { preVisitVisitor(obj); visitNodes(obj.getWith()); visitNodes(obj.getQueryCommands()); visitNode(obj.getOrderBy()); visitNode(obj.getLimit()); visitNode(obj.getOption()); postVisitVisitor(obj); }
SetQuery query = (SetQuery)command; SourceHint previous = this.sourceHint; this.sourceHint = SourceHint.combine(previous, query.getProjectedQuery().getSourceHint()); PlanNode leftPlan = createQueryPlan( query.getLeftQuery(), parentOrderBys); if (command.getOrderBy() != null) { parentOrderBys.remove(parentOrderBys.size()-1); PlanNode rightPlan = createQueryPlan( query.getRightQuery(), null); node = NodeFactory.getNewNode(NodeConstants.Types.SET_OP); node.setProperty(NodeConstants.Info.SET_OPERATION, query.getOperation()); node.setProperty(NodeConstants.Info.USE_ALL, query.isAll()); this.sourceHint = previous; attachLast(node, leftPlan);
private void setProjectedTypes(SetQuery setQuery, List<Class<?>> firstProjectTypes, QueryMetadataInterface metadata) throws QueryResolverException { for (QueryCommand subCommand : setQuery.getQueryCommands()) { if (!(subCommand instanceof SetQuery)) { continue; } SetQuery child = (SetQuery)subCommand; List projectedSymbols = child.getProjectedSymbols(); if (child.getOrderBy() != null) { for (int j = 0; j < projectedSymbols.size(); j++) { Expression ses = (Expression)projectedSymbols.get(j); Class<?> targetType = firstProjectTypes.get(j); if (ses.getType() != targetType && orderByContainsVariable(child.getOrderBy(), ses, j)) { String sourceTypeName = DataTypeManager.getDataTypeName(ses.getType()); String targetTypeName = DataTypeManager.getDataTypeName(targetType); throw new QueryResolverException(QueryPlugin.Util.getString("UnionQueryResolver.type_conversion", //$NON-NLS-1$ new Object[] {ses, sourceTypeName, targetTypeName})); } } } child.setProjectedTypes(firstProjectTypes, metadata); setProjectedTypes(child, firstProjectTypes, metadata); } }
private QueryCommand minimizeWithProjection(WithQueryCommand with, QueryCommand subCommand, TempMetadataID tid, Collection<TempMetadataID> accessed) throws QueryMetadataException, QueryResolverException, TeiidComponentException { List<TempMetadataID> elements = tid.getElements(); List<Integer> toRemove = new ArrayList<Integer>(); for (int i = elements.size()-1; i >= 0; i--) { TempMetadataID elem = elements.get(i); if (!accessed.contains(elem)) { toRemove.add(i); } } //the strategy here is to replace the actual projections with null. this keeps //the definition of the with clause consistent if (!toRemove.isEmpty()) { if (with.isRecursive()) { SetQuery setQuery = (SetQuery) subCommand; setQuery.setLeftQuery(removeUnusedProjection(with, setQuery.getLeftQuery(), elements, toRemove)); setQuery.setRightQuery(removeUnusedProjection(with, setQuery.getRightQuery(), elements, toRemove)); } else { subCommand = removeUnusedProjection(with, subCommand, elements, toRemove); with.setCommand(subCommand); } } return subCommand; }
SetQuery addQueryToSetOperation(QueryCommand query, QueryCommand rightQuery, SetQuery.Operation type, boolean all) { SetQuery setQuery = new SetQuery(type, all, query, rightQuery); return setQuery; }
/** SELECT x FROM g UNION ALL SELECT y FROM h */ public static final SetQuery sample1() { Query q1 = new Query(); Select select = new Select(); select.addSymbol(new ElementSymbol("x")); //$NON-NLS-1$ q1.setSelect(select); From from = new From(); from.addGroup(new GroupSymbol("g")); //$NON-NLS-1$ q1.setFrom(from); Query q2 = new Query(); select = new Select(); select.addSymbol(new ElementSymbol("y")); //$NON-NLS-1$ q2.setSelect(select); from = new From(); from.addGroup(new GroupSymbol("h")); //$NON-NLS-1$ q2.setFrom(from); SetQuery sq = new SetQuery(Operation.UNION); sq.setLeftQuery(q1); sq.setRightQuery(q2); return sq; }
private boolean isPushdownValid(WithQueryCommand with, SetQuery setQuery, Object modelID, QueryCommand withCommand, RelationalPlan subPlan1) throws QueryMetadataException, TeiidComponentException { AccessNode aNode1 = CriteriaCapabilityValidatorVisitor.getAccessNode(subPlan1); if (aNode1 == null) { return false; } Object modelID1 = CriteriaCapabilityValidatorVisitor.validateCommandPushdown(null, metadata, capFinder, aNode1, false); QueryCommand withCommand1 = CriteriaCapabilityValidatorVisitor.getQueryCommand(aNode1); if (modelID1 == null || withCommand1 == null) { return false; } //if we are the same connector for each, then we should be good to proceed if (CapabilitiesUtil.isSameConnector(modelID, modelID1, metadata, capFinder)) { SetQuery pushdownSetQuery = new SetQuery(Operation.UNION, setQuery.isAll(), withCommand, withCommand1); WithQueryCommand wqc = new WithQueryCommand(with.getGroupSymbol(), with.getColumns(), pushdownSetQuery); wqc.setRecursive(true); this.withPlanningState.pushdownWith.put(with.getGroupSymbol().getName(), wqc); return true; } return false; }
@Test public void testSetQueryLimit() { Query query = new Query(); Select select = new Select(Arrays.asList(new MultipleElementSymbol())); From from = new From(Arrays.asList(new UnaryFromClause(new GroupSymbol("a")))); //$NON-NLS-1$ query.setSelect(select); query.setFrom(from); SetQuery setQuery = new SetQuery(Operation.UNION, true, query, query); setQuery.setLimit(new Limit(new Reference(0), new Reference(1))); helpTest("Select * from a union all Select * from a limit ?,?", "SELECT * FROM a UNION ALL SELECT * FROM a LIMIT ?, ?", setQuery); //$NON-NLS-1$ //$NON-NLS-2$ }
@Test public void testSetQuery3() { Select s1 = new Select(); s1.addSymbol(new ElementSymbol("e1")); //$NON-NLS-1$ From f1 = new From(); f1.addGroup(new GroupSymbol("m.g1")); //$NON-NLS-1$ Query q1 = new Query(); q1.setSelect(s1); q1.setFrom(f1); Select s2 = new Select(); s2.addSymbol(new ElementSymbol("e1")); //$NON-NLS-1$ From f2 = new From(); f2.addGroup(new GroupSymbol("m.g2")); //$NON-NLS-1$ Query q2 = new Query(); q2.setSelect(s2); q2.setFrom(f2); OrderBy orderBy = new OrderBy(); orderBy.addVariable(new ElementSymbol("e1")); //$NON-NLS-1$ SetQuery sq = new SetQuery(Operation.UNION, false, q1, q2); sq.setOrderBy(orderBy); helpTest(sq, "SELECT e1 FROM m.g1 UNION SELECT e1 FROM m.g2 ORDER BY e1"); //$NON-NLS-1$ }
private void verifyProjectedTypesOnUnionBranches(String unionQuery, Class<?>[] types) throws TeiidComponentException, TeiidProcessingException { SetQuery union = (SetQuery)QueryParser.getQueryParser().parseCommand(unionQuery); QueryResolver.resolveCommand(union, RealMetadataFactory.example1Cached()); union = (SetQuery)QueryRewriter.rewrite(union, RealMetadataFactory.example1Cached(), null); for (QueryCommand query : union.getQueryCommands()) { List<Expression> projSymbols = query.getProjectedSymbols(); for(int i=0; i<projSymbols.size(); i++) { assertEquals("Found type mismatch at column " + i, types[i], projSymbols.get(i).getType()); //$NON-NLS-1$ } } }
@Test public void testUnionQueryClone() throws Exception{ SetQuery command = (SetQuery)helpResolve("SELECT e2, e3 FROM pm1.g1 UNION SELECT e3, e2 from pm1.g1"); //$NON-NLS-1$ assertEquals(DataTypeManager.DefaultDataClasses.INTEGER, ((Expression)command.getProjectedSymbols().get(1)).getType()); command = (SetQuery)command.clone(); assertEquals(DataTypeManager.DefaultDataClasses.INTEGER, ((Expression)command.getProjectedSymbols().get(1)).getType()); }
((SetQuery)queryCommand).setAll(false); } else if (CapabilitiesUtil.supports(Capability.QUERY_SELECT_DISTINCT, RuleRaiseAccess.getModelIDFromAccess(accessNode, metadata), metadata, capFinder)) { Query query = (Query)queryCommand;
@Test public void testCacheHintUnion() { String sql = "/*+ cache( pref_mem) */ SELECT * FROM t1 union select * from t2"; //$NON-NLS-1$ Query query = new Query(); Select select = new Select(); select.addSymbol(new MultipleElementSymbol()); query.setSelect(select); From from = new From(); UnaryFromClause ufc = new UnaryFromClause(); from.addClause(ufc); ufc.setGroup(new GroupSymbol("t1")); //$NON-NLS-1$ query.setFrom(from); Query query1 = new Query(); select = new Select(); select.addSymbol(new MultipleElementSymbol()); query1.setSelect(select); from = new From(); ufc = new UnaryFromClause(); from.addClause(ufc); ufc.setGroup(new GroupSymbol("t2")); //$NON-NLS-1$ query1.setFrom(from); SetQuery sq = new SetQuery(Operation.UNION, false, query, query1); CacheHint hint = new CacheHint(); hint.setPrefersMemory(true); sq.setCacheHint(hint); TestParser.helpTest(sql, "/*+ cache(pref_mem) */ SELECT * FROM t1 UNION SELECT * FROM t2", sq); //$NON-NLS-1$ }
@Test public void testNestedUnionQueryWithNull() throws Exception{ SetQuery command = (SetQuery)helpResolve("SELECT e2, e3 FROM pm1.g1 UNION (SELECT null, e3 FROM pm1.g2 UNION SELECT null, e3 from pm1.g1)"); //$NON-NLS-1$ assertEquals(DataTypeManager.DefaultDataClasses.INTEGER, ((Expression)command.getProjectedSymbols().get(0)).getType()); }