@Override public void route(QueryRouter router, EntityResolver resolver, Query substitutedQuery) { DataMap map = getMetaData(resolver).getDataMap(); QueryEngine engine; if (map != null) { engine = router.engineForDataMap(map); } else { engine = router.engineForName(getDataNodeName()); } router.route(engine, this, substitutedQuery); }
/** * Routes query prefetches, but not the query itself. */ void route(SelectQuery query, QueryRouter router, EntityResolver resolver) { if (!query.isFetchingDataRows() && query.getPrefetchTree() != null) { this.query = query; this.router = router; this.resolver = resolver; this.classDescriptor = query.getMetaData(resolver).getClassDescriptor(); query.getPrefetchTree().traverse(this); } }
public QueryMetadata getMetaData(EntityResolver resolver) { QueryMetadata md = query.getMetaData(resolver); QueryMetadataWrapper wrappedMd = new QueryMetadataWrapper(md); if (QueryCacheStrategy.LOCAL_CACHE == md.getCacheStrategy()) { wrappedMd.override(QueryMetadata.CACHE_STRATEGY_PROPERTY, QueryCacheStrategy.LOCAL_CACHE_REFRESH); } else if (QueryCacheStrategy.SHARED_CACHE == md.getCacheStrategy()) { wrappedMd.override(QueryMetadata.CACHE_STRATEGY_PROPERTY, QueryCacheStrategy.SHARED_CACHE_REFRESH); } return wrappedMd; }
private PrefetchTreeNode deepClone(PrefetchTreeNode source, PrefetchTreeNode targetParent) { PrefetchTreeNode target = new PrefetchTreeNode(targetParent, source.getName()); target.setEjbqlPathEntityId(source.getEjbqlPathEntityId()); target.setEntityName(source.getEntityName()); target.setPhantom(source.isPhantom()); target.setSemantics(source.getSemantics()); for (PrefetchTreeNode child : source.getChildren()) { target.addChild(deepClone(child, target)); } return target; }
/** * Adds ordering specification to this query orderings. * * @since 3.0 */ public void addOrdering(String sortPathSpec, SortOrder order) { addOrdering(new Ordering(sortPathSpec, order)); }
/** * @since 4.0 */ public static SelectQuery<DataRow> dataRowQuery(Class<?> rootClass) { // create a query replica that would fetch DataRows SelectQuery<DataRow> query = new SelectQuery<DataRow>(); query.setRoot(rootClass); query.metaData.setFetchingDataRows(true); return query; }
/** * Returns default select parameters. * * @since 1.2 */ public QueryMetadata getMetaData(EntityResolver resolver) { BaseQueryMetadata md = new BaseQueryMetadata(); md.resolve(getRoot(), resolver, getName()); return md; }
/** * Add an ordering on the given property. If there is already an ordering * on this query then add this ordering with a lower priority. * * @param property the property to sort on * @param sortOrder the direction of the ordering * @return this object */ public ObjectSelect<T> orderBy(String property, SortOrder sortOrder) { return orderBy(new Ordering(property, sortOrder)); }
/** * Add an ordering on the given property. If there is already an ordering * on this query then add this ordering with a lower priority. * * @param property the property to sort on * @param sortOrder the direction of the ordering * @return this object */ public ColumnSelect<T> orderBy(String property, SortOrder sortOrder) { return orderBy(new Ordering(property, sortOrder)); }
boolean resolve(Object root, EntityResolver resolver, SelectQuery<?> query) { if (super.resolve(root, resolver, null)) { // generate unique cache key, but only if we are caching.. if (cacheStrategy != null && cacheStrategy != QueryCacheStrategy.NO_CACHE) { this.cacheKey = makeCacheKey(query, resolver); } resolveAutoAliases(query); buildResultSetMappingForColumns(query, resolver); isSingleResultSetMapping = query.canReturnScalarValue() && super.isSingleResultSetMapping(); return true; } return false; }
/** * Delegates routing to a replacement query. */ @Override public void route(QueryRouter router, EntityResolver resolver, Query substitutedQuery) { getReplacementQuery(resolver).route(router, resolver, substitutedQuery != null ? substitutedQuery : this); }
/** * Searches for DataMap that holds Query root object. * * @deprecated since 1.2 use 'Query.getMetaData(EntityResolver).getDataMap()'. */ public synchronized DataMap lookupDataMap(Query q) { return q.getMetaData(this).getDataMap(); }
/** * Returns the metadata obtained from the replacement query. */ @Override public QueryMetadata getMetaData(EntityResolver resolver) { return getReplacementQuery(resolver).getMetaData(resolver); }
/** * Looks up the DbEntity for the given query by using the query's getRoot method and * passing to lookupDbEntity * * @return the root DbEntity of the query * @deprecated since 1.2 use 'Query.getMetaData(EntityResolver).getDbEntity()' */ public synchronized DbEntity lookupDbEntity(Query q) { return q.getMetaData(this).getDbEntity(); }
/** * Creates a ProcedureQuery based on a Procedure object. */ public ProcedureQuery(Procedure procedure) { // for backwards compatibility we go against usual default... metaData.setFetchingDataRows(true); setRoot(procedure); }
/** * Translates self to a SelectQuery. */ @SuppressWarnings({"deprecation", "unchecked"}) @Override protected Query createReplacementQuery(EntityResolver resolver) { SelectQuery<?> replacement = (SelectQuery<?>) super.createReplacementQuery(resolver); replacement.setFetchingDataRows(fetchingDataRows); return replacement; }
/** * @since 4.0 */ public void setCacheGroup(String cacheGroup) { getBaseMetaData().setCacheGroup(cacheGroup); }
/** * Returns <code>true</code> if this query should produce a list of data rows as * opposed to DataObjects, <code>false</code> for DataObjects. This is a hint to * QueryEngine executing this query. */ public boolean isFetchingDataRows() { return this.isFetchingCustomAttributes() || selectInfo.isFetchingDataRows(); }
/** * Add an ascending ordering on the given property. If there is already an ordering * on this query then add this ordering with a lower priority. * * @param property the property to sort on * @return this object */ public ObjectSelect<T> orderBy(String property) { return orderBy(new Ordering(property)); }
/** * Delegates routing to a replacement query. */ public void route(QueryRouter router, EntityResolver resolver, Query substitutedQuery) { getReplacementQuery(resolver).route( router, resolver, substitutedQuery != null ? substitutedQuery : this); }