/** * Copies values of this object to another SelectInfo object. */ void copyFromInfo(QueryMetadata info) { this.lastEntityResolver = null; this.lastRoot = null; this.objEntity = null; this.dbEntity = null; this.dataMap = null; this.fetchingDataRows = info.isFetchingDataRows(); this.fetchLimit = info.getFetchLimit(); this.pageSize = info.getPageSize(); this.refreshingObjects = info.isRefreshingObjects(); this.resolvingInherited = info.isResolvingInherited(); this.cachePolicy = info.getCachePolicy(); this.cacheKey = info.getCacheKey(); setPrefetchTree(info.getPrefetchTree()); }
/** * Copies values of another QueryMetadata object to this object. */ void copyFromInfo(QueryMetadata info) { this.lastEntityResolver = null; this.lastRoot = null; this.classDescriptor = null; this.dbEntity = null; this.dataMap = null; this.fetchingDataRows = info.isFetchingDataRows(); this.fetchLimit = info.getFetchLimit(); this.pageSize = info.getPageSize(); this.cacheStrategy = info.getCacheStrategy(); this.cacheKey = info.getCacheKey(); this.cacheGroup = info.getCacheGroup(); this.resultSetMapping = info.getResultSetMapping(); setPrefetchTree(info.getPrefetchTree()); }
@Override public DataMap getDataMap() { return mdDelegate.getDataMap(); }
/** * Creates a PaginatedQuery that returns a single page from an existing cached * server-side result list. */ public RangeQuery(String cacheKey, int fetchStartIndex, int fetchLimit, QueryMetadata rootMetadata) { this.cacheKey = cacheKey; this.fetchStartIndex = fetchStartIndex; this.fetchLimit = fetchLimit; this.fetchingDataRows = rootMetadata.isFetchingDataRows(); this.prefetchTree = rootMetadata.getPrefetchTree(); }
if (metadata.getPageSize() <= 0) { throw new CayenneRuntimeException("Not a paginated query; page size: " + metadata.getPageSize()); this.pageSize = metadata.getPageSize(); this.rootEntity = metadata.getObjEntity(); this.internalQuery.setFetchingDataRows(metadata.isFetchingDataRows()); this.internalQuery.setPrefetchTree(metadata.getPrefetchTree()); this.idWidth = metadata.getDbEntity().getPrimaryKeys().size();
private void interceptObjectConversion() { if (context != null && !metadata.isFetchingDataRows()) { ObjEntity entity = metadata.getObjEntity(); PrefetchTreeNode prefetchTree = metadata.getPrefetchTree(); .isRefreshingObjects(), metadata.isResolvingInherited()) .synchronizedObjectsFromDataRows(mainRows);
@Override public String getCacheKey() { return mdDelegate.getCacheKey(); }
private boolean interceptIncrementalListConversion() { int pageSize = serverMetadata.getPageSize(); if (pageSize > 0 && serverMetadata.getCacheKey() != null) { List list = response.firstList(); if (list.size() > pageSize && list instanceof IncrementalFaultList) { // cache channel.getQueryCache().put(serverMetadata, list); // extract and convert first page // TODO: andrus, 2008/03/05 - we no longer resolve the first page // automatically on the server... probably should not do it for the client // either... One rare case when this is completely undesirable is // subaction execution from 'interceptSinglePageQuery', as it doesn't even // care about the first page... List sublist = list.subList(0, pageSize); List firstPage = (serverMetadata.isFetchingDataRows()) ? new ArrayList(sublist) : toClientObjects(sublist); this.response = new IncrementalListResponse(firstPage, list.size()); return DONE; } } return !DONE; }
/** * @since 1.1 * @deprecated since 1.2. Note that this implementation no longer resolves prefetches * properly. */ public List getResultsAsObjects(DataContext dataContext, Query rootQuery) { QueryMetadata info = rootQuery.getMetaData(dataContext.getEntityResolver()); return dataContext.objectsFromDataRows( info.getObjEntity(), getResults(rootQuery), info.isRefreshingObjects(), info.isResolvingInherited()); }
@Override protected boolean interceptPaginatedQuery() { if (metadata.getPageSize() > 0) { Integer maxIdQualifierSize = actingDataContext.getParentDataDomain().getMaxIdQualifierSize(); List<?> paginatedList; List<Object> rsMapping = metadata.getResultSetMapping(); boolean mixedResults = false; if(rsMapping != null) { if(rsMapping.size() > 1) { mixedResults = true; } else if(rsMapping.size() == 1) { mixedResults = !(rsMapping.get(0) instanceof EntityResultSegment) || !metadata.isSingleResultSetMapping(); } } if(mixedResults) { paginatedList = new MixedResultIncrementalFaultList<>(actingDataContext, query, maxIdQualifierSize); } else { DbEntity dbEntity = metadata.getDbEntity(); if (dbEntity != null && dbEntity.getPrimaryKeys().size() == 1) { paginatedList = new SimpleIdIncrementalFaultList<>(actingDataContext, query, maxIdQualifierSize); } else { paginatedList = new IncrementalFaultList<>(actingDataContext, query, maxIdQualifierSize); } } response = new ListResponse(paginatedList); return DONE; } return !DONE; }
/** * Warn user in case query uses both limit and joint prefetch, as we don't support this combination. */ private void checkLimitAndJointPrefetch() { if(queryMetadata.getFetchLimit() == 0 && queryMetadata.getFetchOffset() == 0) { return; } if(!jointPrefetchChecker.haveJointNode(queryMetadata.getPrefetchTree())) { return; } logger.warn("Query uses both limit and joint prefetch, this most probably will lead to incorrect result. " + "Either use disjointById prefetch or get full result set."); }
@SuppressWarnings("rawtypes") public void put(QueryMetadata metadata, List results) { String key = metadata.getCacheKey(); if (key != null) { osCache.putInCache(key, results, new String[]{metadata.getCacheGroup()}); } }
@Override public int getFetchLimit() { return mdDelegate.getFetchLimit(); }
@Override public DbEntity getDbEntity() { return mdDelegate.getDbEntity(); }
@Override public int getPageSize() { return mdDelegate.getPageSize(); }
public ObjEntity getObjEntity() { return metadata.getObjEntity(); }
DataMap dataMap = queryMetadata.getDataMap(); JoinStack joins = getJoinStack(); suppressingDistinct = queryMetadata.isSuppressingDistinct(); if(!suppressingDistinct) { for (ColumnDescriptor column : resultColumns) { joins.appendRootWithQuoteSqlIdentifiers(queryBuf, getQueryMetadata().getDbEntity());
@Override public boolean isFetchingDataRows() { return mdDelegate.isFetchingDataRows(); }
public Procedure getProcedure() { return info.getProcedure(); }
@Override void convert(List<DataRow> mainRows) { PrefetchTreeNode prefetchTree = metadata.getPrefetchTree(); List<Object> rsMapping = metadata.getResultSetMapping(); EntityResultSegment resultSegment = null; if(rsMapping != null && !rsMapping.isEmpty()) { resultSegment = (EntityResultSegment)rsMapping.get(0); } ClassDescriptor descriptor = resultSegment == null ? metadata.getClassDescriptor() : resultSegment.getClassDescriptor(); PrefetchProcessorNode node = toResultsTree(descriptor, prefetchTree, mainRows); List<Persistent> objects = node.getObjects(); updateResponse(mainRows, objects != null ? objects : new ArrayList<>(1)); // apply POST_LOAD callback LifecycleCallbackRegistry callbackRegistry = context.getEntityResolver().getCallbackRegistry(); if (!callbackRegistry.isEmpty(LifecycleEvent.POST_LOAD)) { performPostLoadCallbacks(node, callbackRegistry); } } }