@Override public boolean isEmpty() { return metadata.getProjection().isEmpty(); }
private GraphQuery createGraphQuery(QueryMetadata md, final Iterable<Bindings> iterable) { List<PatternBlock> patternBlocks = new ArrayList<PatternBlock>(); for (Expression<?> e : md.getProjection()) { if (e instanceof PatternBlock) { patternBlocks.add((PatternBlock) e); } else if (e instanceof ContainerBlock) { for (Block b : ((ContainerBlock) e).getBlocks()) { patternBlocks.add((PatternBlock) b); } } } final List<Function<Bindings, STMT>> transformers = new ArrayList<Function<Bindings, STMT>>(patternBlocks.size()); for (PatternBlock pb : patternBlocks) { transformers.add(createStatementFunction(pb)); } return new GraphQuery() { @SuppressWarnings("unchecked") @Override public CloseableIterator<STMT> getTriples() { List<Iterator<STMT>> iterators = new ArrayList<Iterator<STMT>>(transformers.size()); for (Function<Bindings, STMT> transformer : transformers) { iterators.add(Iterators.transform(iterable.iterator(), transformer)); } return new IteratorAdapter<STMT>(Iterators.concat(iterators.toArray(new Iterator[iterators.size()]))); } }; }
private NumberExpression<Long> count(Operator<Long> operator) { QueryMetadata md = subQueryMixin.getMetadata().clone(); Expression<?> e = null; if (md.getProjection().size() == 1) { e = md.getProjection().get(0); } else if (!md.getProjection().isEmpty()) { e = ExpressionUtils.list(Object.class, md.getProjection()); } md.clearProjection(); if (e != null) { md.addProjection(OperationImpl.create(Long.class, operator, e)); } else if (operator == Ops.AggOps.COUNT_AGG) { md.addProjection(Wildcard.count); } else { md.addProjection(Wildcard.countDistinct); } return new NumberSubQuery<Long>(Long.class, md); }
private List<?> project(QueryMetadata metadata, List<Expression<?>> sources, List<?> list) { Expression<?> projection = metadata.getProjection().get(0); Operator<?> aggregator = null; if (projection instanceof Operation && Ops.aggOps.contains(((Operation)projection).getOperator())) { Operation<?> aggregation = (Operation<?>)projection; aggregator = aggregation.getOperator(); projection = aggregation.getArg(0); } Evaluator projectionEvaluator = evaluatorFactory.create(metadata, sources, projection); EvaluatorFunction transformer = new EvaluatorFunction(projectionEvaluator); List target = new ArrayList(); Iterators.addAll(target, Iterators.transform(list.iterator(), transformer)); if (aggregator != null) { return ImmutableList.of(CollQueryFunctions.aggregate(target, projection, aggregator)); } else { return target; } }
@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 boolean equals(Object o) { if (o instanceof QueryMetadata) { QueryMetadata q = (QueryMetadata)o; return q.getFlags().equals(flags) && q.getGroupBy().equals(groupBy) && Objects.equal(q.getHaving(), having) && q.isDistinct() == distinct && q.isUnique() == unique && q.getJoins().equals(getJoins()) && Objects.equal(q.getModifiers(), modifiers) && q.getOrderBy().equals(orderBy) && q.getParams().equals(params) && q.getProjection().equals(projection) && Objects.equal(q.getWhere(), where); } else { return false; } }
@SuppressWarnings("unchecked") private Query createQuery(String queryString) { logQuery(queryString); List<? extends Expr<?>> projection = queryMixin.getMetadata().getProjection(); Query query; if (projection.get(0) instanceof EntityPath){ if (projection.size() == 1){ query = session.createSQLQuery(queryString, projection.get(0).getType()); }else{ throw new IllegalArgumentException("Only single element entity projections are supported"); } }else{ query = session.createSQLQuery(queryString); } // set constants JPAUtil.setConstants(query, constants, queryMixin.getMetadata().getParams()); return query; }
private void assertProjectionEmpty(JPAQuery query) { assertTrue(query.getMetadata().getProjection().isEmpty()); }
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; }
protected DBCursor createCursor() { QueryMetadata metadata = queryMixin.getMetadata(); Predicate filter = createFilter(metadata); return createCursor(collection, filter, metadata.getProjection(), metadata.getModifiers(), metadata.getOrderBy()); }
private Query createQuery(boolean forCount) { SQLSerializer serializer = new SQLSerializer(configuration); if (union != null) { serializer.serializeUnion(union, queryMixin.getMetadata(), unionAll); } else { serializer.serialize(queryMixin.getMetadata(), forCount); } // create Query if (logger.isDebugEnabled()) { logger.debug(serializer.toString()); } Query query = persistenceManager.newQuery("javax.jdo.query.SQL",serializer.toString()); orderedConstants = serializer.getConstants(); queries.add(query); if (!forCount) { List<? extends Expression<?>> projection = queryMixin.getMetadata().getProjection(); if (projection.get(0) instanceof FactoryExpression) { this.projection = (FactoryExpression<?>)projection.get(0); } } else { query.setResultClass(Long.class); } return query; }
public void serializeForUpdate(QueryMetadata md) { append(UPDATE); handleJoinTarget(md.getJoins().get(0)); append(SET); handle(COMMA, md.getProjection()); if (md.getWhere() != null) { append(WHERE).handle(md.getWhere()); } }
@Test public void Multiple_Projections() { QCat cat = QCat.cat; JPASubQuery query = new JPASubQuery(); query.from(cat); assertEquals(1, query.list(cat).getMetadata().getProjection().size()); assertEquals(1, query.list(cat).getMetadata().getProjection().size()); }
@Test public void Via_Interface() { QCat cat = QCat.cat; JPQLSubQuery query = new JPASubQuery(); query.from(cat); assertEquals(1, query.list(cat).getMetadata().getProjection().size()); assertEquals(1, query.list(cat).getMetadata().getProjection().size()); }
@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; }
@Nullable private Void visit(QueryMetadata md) { // select handle(md.getProjection()); // from for (JoinExpression join : md.getJoins()) { join.getTarget().accept(this, null); } // where handle(md.getWhere()); // group handle(md.getGroupBy()); // having handle(md.getHaving()); return null; }
public static Set<RelationalPath<?>> extract(QueryMetadata md) { Set<RelationalPath<?>> known = ImmutableSet.of(); known = DEFAULT.visitJoins(md.getJoins(), known); for (Expression<?> p : md.getProjection()) { known = p.accept(DEFAULT, known); } for (OrderSpecifier<?> o : md.getOrderBy()) { known = o.getTarget().accept(DEFAULT, known); } for (Expression<?> g : md.getGroupBy()) { known = g.accept(DEFAULT, known); } if (md.getHaving() != null) { known = md.getHaving().accept(DEFAULT, known); } if (md.getWhere() != null) { known = md.getWhere().accept(DEFAULT, known); } return known; }
@Test public void test() throws IOException, ClassNotFoundException{ // create query JPAQuery query = query(); query.from(cat).where(cat.name.eq("Kate")).list(cat); QueryMetadata metadata = query.getMetadata(); assertFalse(metadata.getJoins().isEmpty()); assertTrue(metadata.getWhere() != null); assertTrue(metadata.getProjection().isEmpty()); QueryMetadata metadata2 = Serialization.serialize(metadata); // validate it assertEquals(metadata.getJoins(), metadata2.getJoins()); assertEquals(metadata.getWhere(), metadata2.getWhere()); assertEquals(metadata.getProjection(), metadata2.getProjection()); // create new query JPAQuery query2 = new JPAQuery(entityManager, metadata2); assertEquals("select cat\nfrom Cat cat\nwhere cat.name = ?1", query2.toString()); query2.list(cat); }
@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; }