SelectQuery replacement = new SelectQuery(); replacement.setRoot(entityType); } else if (entityName != null) { replacement.setRoot(entity); } else if (dbEntityName != null) { replacement.setRoot(entity); } else { throw new CayenneRuntimeException("Undefined root entity of the query"); replacement.setName(name); replacement.setQualifier(where); replacement.addOrderings(orderings); replacement.setPrefetchTree(prefetches); replacement.setCacheStrategy(cacheStrategy); replacement.setCacheGroup(cacheGroup); replacement.setFetchLimit(limit); replacement.setFetchOffset(offset); replacement.setPageSize(pageSize); replacement.setStatementFetchSize(statementFetchSize);
@Override public void addOrdering(Ordering ordering) { query.addOrdering(ordering); }
@Override public List<Ordering> getOrderings() { return query.getOrderings(); }
protected Object create(String name, Object namingContext) { SelectQuery query = new SelectQuery(); query.setName(name); return query; }
private void init(Object root, Expression qualifier) { this.setRoot(root); this.setQualifier(qualifier); }
SelectQuery<Object> createSelectQuery(List<Expression> expressions) { SelectQuery<Object> query = new SelectQuery<>(rootEntity, ExpressionFactory.joinExp(Expression.OR, expressions)); query.setFetchingDataRows(internalQuery.isFetchingDataRows()); if (!query.isFetchingDataRows()) { query.setPrefetchTree(internalQuery.getPrefetchTree()); } return query; }
/** * Creates a SelectQuery. */ public Query getQuery() { SelectQuery query = new SelectQuery(); query.setRoot(getRoot()); query.setName(name); query.setQualifier(qualifier); if (orderings != null && !orderings.isEmpty()) { query.addOrderings(orderings); } if (prefetches != null && !prefetches.isEmpty()) { Iterator it = prefetches.iterator(); while(it.hasNext()) { query.addPrefetch((String) it.next()); } } // init properties query.initWithProperties(properties); return query; } }
SelectQuery query = new SelectQuery(); query.setDistinct(distinct); query.setParentObjEntityName(parentObjEntityName); query.setParentQualifier(parentQualifier); query.setRoot(root); query.setName(buffer.toString()); query.addOrderings(orderings); query.addCustomDbAttributes(customDbAttributes); query.setQualifier(qualifier.expWithParameters(parameters, pruneMissing));
@SuppressWarnings("deprecation") @Override protected Query createReplacementQuery(EntityResolver resolver) { ObjEntity entity = resolveEntity(resolver); Map<String, ?> id = resolveId(entity); SelectQuery<Object> query = new SelectQuery<>(); query.setRoot(entity); query.setFetchingDataRows(fetchingDataRows); query.setQualifier(matchAllDbExp(id, Expression.EQUAL_TO)); // note on caching... this hits query cache instead of object cache... // until we merge the two this may result in not using the cache // optimally - object cache may have an object, but query cache will not query.setCacheGroup(cacheGroup); query.setCacheStrategy(cacheStrategy); query.setPrefetchTree(prefetches); return query; }
this.internalQuery = new SelectQuery(rootEntity); this.internalQuery.setFetchingDataRows(metadata.isFetchingDataRows()); this.internalQuery.setResolvingInherited(metadata.isResolvingInherited()); SelectQuery select = (SelectQuery) query; this.internalQuery.setPrefetchTree(select.getPrefetchTree()); if (select.getPrefetchTree() != null) { SelectQuery clone = select.queryWithParameters( Collections.EMPTY_MAP, true); clone.clearPrefetches(); query = clone;
/** * Returns a query built using this query as a prototype, using a set of * parameters to build the qualifier. * * @see org.apache.cayenne.exp.Expression#expWithParameters(java.util.Map, * boolean) parameter substitution. */ public SelectQuery<T> queryWithParameters(Map<String, ?> parameters, boolean pruneMissing) { // create a query replica SelectQuery<T> query = new SelectQuery<T>(); query.setDistinct(distinct); query.metaData.copyFromInfo(this.metaData); query.setRoot(root); if (orderings != null) { query.addOrderings(orderings); } // substitute qualifier parameters if (qualifier != null) { query.setQualifier(qualifier.params(parameters, pruneMissing)); } return query; }
/** * Creates a SelectQuery that selects objects of a given persistent class. * * @param rootClass * the Class of objects fetched by this query. * * @since 4.0 */ public static <T> SelectQuery<T> query(Class<T> rootClass) { return new SelectQuery<T>(rootClass); }
/** * Retrieves fresh snapshot for the failed row. Null row indicates that it was * deleted. * * @since 3.0 */ public Map<?, ?> getFreshSnapshot(ObjectContext context) { Expression qualifier = null; for (DbAttribute attribute : rootEntity.getPrimaryKeys()) { Expression attributeQualifier = ExpressionFactory.matchDbExp( attribute.getName(), qualifierSnapshot.get(attribute.getName())); qualifier = (qualifier != null) ? qualifier.andExp(attributeQualifier) : attributeQualifier; } SelectQuery<DataRow> query = new SelectQuery<DataRow>(rootEntity, qualifier); query.setFetchingDataRows(true); return (Map<?, ?>) Cayenne.objectForQuery(context, query); }
if(query.getColumns() != null && !query.getColumns().isEmpty()) { traversalHandler = new ToCacheKeyTraversalHandler(resolver.getValueObjectTypeRegistry(), key); for(Property<?> property : query.getColumns()) { key.append("/c:"); property.getExpression().traverse(traversalHandler); if (query.getQualifier() != null) { key.append('/'); if(traversalHandler == null) { traversalHandler = new ToCacheKeyTraversalHandler(resolver.getValueObjectTypeRegistry(), key); query.getQualifier().traverse(traversalHandler); if (!query.getOrderings().isEmpty()) { for (Ordering o : query.getOrderings()) { key.append('/').append(o.getSortSpecString()); if (!o.isAscending()) { if (query.getFetchOffset() > 0 || query.getFetchLimit() > 0) { key.append('/'); if (query.getFetchOffset() > 0) { key.append('o').append(query.getFetchOffset()); if (query.getFetchLimit() > 0) { key.append('l').append(query.getFetchLimit()); if(query.getPrefetchTree() != null) { query.getPrefetchTree().traverse(new ToCacheKeyPrefetchProcessor(key));
@Test public void testBuildQuery_Ordering() { Ordering o1 = E1.NAME.asc(); Ordering o2 = E1.NAME.desc(); SelectQuery<E1> query = new SelectQuery<E1>(E1.class); query.addOrdering(o1); ResourceEntity<E1> resourceEntity = getResourceEntity(E1.class); resourceEntity.getOrderings().add(o2); SelectContext<E1> context = new SelectContext<E1>(E1.class); context.setSelect(query); context.setEntity(resourceEntity); SelectQuery<E1> amended = makeQueryStage.buildQuery(context); assertSame(query, amended); assertEquals(2, amended.getOrderings().size()); assertSame(o1, amended.getOrderings().get(0)); assertSame(o2, amended.getOrderings().get(1)); }
SelectQuery<Persistent> createSelectQuery(ObjEntity entity, List<Expression> expressions) { SelectQuery<Persistent> query = new SelectQuery<>(entity, ExpressionFactory.joinExp(Expression.OR, expressions)); if (entity.equals(rootEntity)) { query.setPrefetchTree(internalQuery.getPrefetchTree()); } return query; }
SelectQuery query = new SelectQuery(clazz, expression); SelectQuery countQuery = new SelectQuery(clazz, expression); query.addOrdering(ordering); if (this.getLimit() != null) query.setFetchLimit(this.getLimit()); if (this.getStart() != null) query.setFetchOffset(this.getStart().intValue()); for (Object entity : objectContext.performQuery(query)) { data.add(new ModelInstance(extConfig, entity).getData());
int limit = context.getEntity().getFetchLimit(); if (limit > 0) { query.setPageSize(limit); query.andQualifier(qualifier); query.andQualifier(entity.getQualifier()); query.addOrdering(o); query.setPrefetchTree(root);
/** * Creates and returns a select query that can be used to fetch a list of objects * given a list of ObjectIds. All ObjectIds must belong to the same entity. */ public static SelectQuery selectQueryForIds(List oids) { if (oids == null || oids.size() == 0) { throw new IllegalArgumentException("List must contain at least one ObjectId"); } SelectQuery sel = new SelectQuery(); sel.setRoot(((ObjectId) oids.get(0)).getEntityName()); Iterator it = oids.iterator(); ObjectId firstId = (ObjectId) it.next(); Expression exp = ExpressionFactory.matchAllDbExp( firstId.getIdSnapshot(), Expression.EQUAL_TO); while (it.hasNext()) { ObjectId anId = (ObjectId) it.next(); exp = exp.orExp(ExpressionFactory.matchAllDbExp( anId.getIdSnapshot(), Expression.EQUAL_TO)); } sel.setQualifier(exp); return sel; }
@Test public void testBuildQuery_Qualifier() { Expression extraQualifier = E1.NAME.eq("X"); ResourceEntity<E1> resourceEntity = getResourceEntity(E1.class); resourceEntity.andQualifier(extraQualifier); SelectContext<E1> c1 = new SelectContext<>(E1.class); c1.setEntity(resourceEntity); SelectQuery<E1> query = makeQueryStage.buildQuery(c1); assertEquals(extraQualifier, query.getQualifier()); SelectQuery<E1> query2 = new SelectQuery<E1>(E1.class); query2.setQualifier(E1.NAME.in("a", "b")); SelectContext<E1> c2 = new SelectContext<>(E1.class); c2.setSelect(query2); c2.setEntity(resourceEntity); SelectQuery<E1> query2Amended = makeQueryStage.buildQuery(c2); assertEquals(E1.NAME.in("a", "b").andExp(E1.NAME.eq("X")), query2Amended.getQualifier()); }