@SuppressWarnings("unchecked") public final boolean equals(Object o) { if (o == this) { return true; } else if (o instanceof SubQueryExpression) { SubQueryExpression<T> s = (SubQueryExpression<T>)o; return s.getMetadata().equals(metadata); } else { return false; } }
@Override public String visit(SubQueryExpression<?> expr, Templates templates) { return expr.getMetadata().toString(); }
@Override public Integer visit(SubQueryExpression<?> expr, Void context) { return expr.getMetadata().hashCode(); }
@Override public Void visit(SubQueryExpression<?> expr, Void context) { return visit(expr.getMetadata()); }
@SuppressWarnings("unchecked") @Override public TupleExpr visit(SubQueryExpression<?> expr, QueryMetadata md) { for (Map.Entry<ParamExpression<?>, Object> entry : md.getParams().entrySet()) { expr.getMetadata().setParam((ParamExpression) entry.getKey(), entry.getValue()); } return visit(expr.getMetadata(), QueryLanguage.TUPLE); }
@SuppressWarnings("unchecked") @Override public TupleExpr visit(SubQueryExpression<?> expr, QueryMetadata md) { for (Map.Entry<ParamExpression<?>, Object> entry : md.getParams().entrySet()) { expr.getMetadata().setParam((ParamExpression) entry.getKey(), entry.getValue()); } return visit(expr.getMetadata(), QueryLanguage.TUPLE); }
@SuppressWarnings("unchecked") @Override public TupleExpr visit(SubQueryExpression<?> expr, QueryMetadata md) { for (Map.Entry<ParamExpression<?>, Object> entry : md.getParams().entrySet()){ expr.getMetadata().setParam((ParamExpression)entry.getKey(), entry.getValue()); } return visit(expr.getMetadata(), QueryLanguage.TUPLE); }
@Override public SQLInsertClause select(SubQueryExpression<?> sq) { subQuery = sq; for (Map.Entry<ParamExpression<?>, Object> entry : sq.getMetadata().getParams().entrySet()) { metadata.setParam((ParamExpression) entry.getKey(), entry.getValue()); } return this; }
@SuppressWarnings("unchecked") @Override public Void visit(SubQueryExpression<?> expr, Void context) { for (Map.Entry<ParamExpression<?>, Object> entry : metadata.getParams().entrySet()) { expr.getMetadata().setParam((ParamExpression) entry.getKey(), entry.getValue()); } if (!operators.isEmpty() && operators.peek() == Ops.EXISTS) { handle(expr.getMetadata().getWhere()); } else { visit(expr.getMetadata(), QueryLanguage.TUPLE); } return null; }
@SuppressWarnings({ "unchecked", "rawtypes" }) private <T> CollectionExpressionBase<?,T> union(Operator<Object> op, List<? extends SubQueryExpression<?>> sq) { Expression<?> rv = sq.get(0); if (sq.size() == 1 && !CollectionExpression.class.isInstance(rv)) { return new ListSubQuery(rv.getType(), sq.get(0).getMetadata()); } else { Class<?> elementType = sq.get(0).getType(); if (rv instanceof CollectionExpression) { elementType = ((CollectionExpression)rv).getParameter(0); } for (int i = 1; i < sq.size(); i++) { rv = CollectionOperation.create(op, (Class)elementType, rv, sq.get(i)); } return (CollectionExpressionBase<?,T>)rv; } }
@Override public Void visit(SubQueryExpression<?> query, Void context) { if (inUnion && !templates.isUnionsWrapped()) { serialize(query.getMetadata(), false); } else { append("("); serialize(query.getMetadata(), false); append(")"); } return null; }
@Override public Void visit(SubQueryExpression<?> query, Void context) { append("("); serialize(query.getMetadata(), false, null); append(")"); return null; }
@Override public Void visit(SubQueryExpression<?> query, Void context) { append("("); serialize(query.getMetadata(), false, true); append(")"); return null; }
@SuppressWarnings("unchecked") private <RT> Union<RT> innerUnion(SubQueryExpression<?>... sq) { queryMixin.getMetadata().setValidate(false); if (!queryMixin.getMetadata().getJoins().isEmpty()) { throw new IllegalArgumentException("Don't mix union and from"); } this.union = UnionUtils.union(sq, unionAll); this.firstUnionSubQuery = sq[0]; return new UnionImpl<Q ,RT>((Q)this, sq[0].getMetadata().getProjection()); }
@Override public Void visit(SubQueryExpression<?> expr, QueryMetadata context) { QueryMetadata md = expr.getMetadata(); for (Map.Entry<ParamExpression<?>, Object> entry : md.getParams().entrySet()) { context.setParam((ParamExpression)entry.getKey(), entry.getValue()); } visit(md.getGroupBy(), context); visit(md.getHaving(), context); for (JoinExpression join : md.getJoins()) { visit(join.getTarget(), context); visit(join.getCondition(), context); } visit(md.getProjection(), context); visit(md.getWhere(), context); return null; }
protected SQLSerializer serialize(boolean forCountRow) { SQLSerializer serializer = createSerializer(); if (union != null) { if (queryMixin.getMetadata().getProjection().isEmpty() || expandProjection(queryMixin.getMetadata().getProjection()).equals( expandProjection(firstUnionSubQuery.getMetadata().getProjection()))) { serializer.serializeUnion(union, queryMixin.getMetadata(), unionAll); } else { QueryMixin mixin2 = new QueryMixin(queryMixin.getMetadata().clone()); Set<Path<?>> paths = getRootPaths(expandProjection(mixin2.getMetadata().getProjection())); if (paths.isEmpty()) { mixin2.from(ExpressionUtils.as((Expression) union, defaultQueryAlias)); } else if (paths.size() == 1) { mixin2.from(ExpressionUtils.as((Expression) union, paths.iterator().next())); } else { throw new IllegalStateException("Unable to create serialize union"); } serializer.serialize(mixin2.getMetadata(), forCountRow); } } else { serializer.serialize(queryMixin.getMetadata(), forCountRow); } return serializer; }
public Expression<?> visit(SubQueryExpression<?> expr, Filters filters) { QueryMetadata md = expr.getMetadata(); Filters f = new Filters(); // from for (JoinExpression join : md.getJoins()) { f.add(handleRootPath((Path<?>) join.getTarget(), f)); } // where if (md.getWhere() != null) { f.add(transform(md.getWhere(), f)); } // select if (!md.getProjection().isEmpty()) { QueryMetadata rv = new DefaultQueryMetadata().noValidate(); for (Expression<?> e : md.getProjection()) { rv.addProjection(transform(e, f)); } rv.addWhere(f.asBlock()); return new SubQueryExpressionImpl<Object>(Object.class, rv); } else { return f.asBlock(); } }
@Override public Set<Expression<?>> visit(SubQueryExpression<?> expr, Set<Expression<?>> known) { Set<Expression<?>> old = known; final QueryMetadata md = expr.getMetadata(); known = visitJoins(md.getJoins(), known); for (Expression<?> p : md.getProjection()) { known = p.accept(this, known); } for (OrderSpecifier<?> o : md.getOrderBy()) { known = o.getTarget().accept(this, known); } for (Expression<?> g : md.getGroupBy()) { known = g.accept(this, known); } if (md.getHaving() != null) { known = md.getHaving().accept(this, known); } if (md.getWhere() != null) { known = md.getWhere().accept(this, known); } return old; }
@Override public Set<RelationalPath<?>> visit(SubQueryExpression<?> expr, Set<RelationalPath<?>> known) { Set<RelationalPath<?>> old = known; final QueryMetadata md = expr.getMetadata(); known = visitJoins(md.getJoins(), known); for (Expression<?> p : md.getProjection()) { known = p.accept(this, known); } for (OrderSpecifier<?> o : md.getOrderBy()) { known = o.getTarget().accept(this, known); } for (Expression<?> g : md.getGroupBy()) { known = g.accept(this, known); } if (md.getHaving() != null) { known = md.getHaving().accept(this, known); } if (md.getWhere() != null) { md.getWhere().accept(this, known); } return old; }
@Test public void FunctionCall() { //select tab.col from Table tab join TableValuedFunction('parameter') func on tab.col not like func.col QSurvey table = new QSurvey("SURVEY"); RelationalFunctionCall<String> func = RelationalFunctionCall.create(String.class, "TableValuedFunction", "parameter"); PathBuilder<String> funcAlias = new PathBuilder<String>(String.class, "tokFunc"); SQLSubQuery sq = new SQLSubQuery(); SubQueryExpression<?> expr = sq.from(table) .join(func, funcAlias).on(table.name.like(funcAlias.getString("prop")).not()).list(table.name); Configuration conf = new Configuration(new SQLServerTemplates()); SQLSerializer serializer = new NativeSQLSerializer(conf, true); serializer.serialize(expr.getMetadata(), false); assertEquals("select SURVEY.NAME\n" + "from SURVEY SURVEY\n" + "join TableValuedFunction(?1) as tokFunc\n" + "on not (SURVEY.NAME like tokFunc.prop escape '\\')", serializer.toString()); }