@Override public PrefetchTreeNode getPrefetchTree() { return mdDelegate.getPrefetchTree(); }
public PrefetchTreeNode getPrefetchTree() { return info.getPrefetchTree(); } }
public PrefetchTreeNode getPrefetchTree() { return metadata.getPrefetchTree(); }
/** * 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(); }
private List<?> singleObjectConversion(List<?> serverObjects) { // must clone the list to ensure we do not mess up the server list that can be // used elsewhere (e.g. it can be cached). List<Object> clientObjects = new ArrayList<>(serverObjects.size()); ObjectDetachOperation op = new ObjectDetachOperation(serverResolver .getClientEntityResolver()); PrefetchTreeNode prefetchTree = serverMetadata.getPrefetchTree(); for (Object serverObject : serverObjects) { clientObjects.add(convertSingleObject(prefetchTree, op, serverObject)); } return clientObjects; }
/** * 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."); }
private List<Object[]> processMixedResult( List<Object[]> serverObjects, List<Object> rsMapping) { // must clone the list to ensure we do not mess up the server list that can be // used elsewhere (e.g. it can be cached). List<Object[]> clientObjects = new ArrayList<>(serverObjects.size()); ObjectDetachOperation op = new ObjectDetachOperation(serverResolver .getClientEntityResolver()); int width = rsMapping.size(); for (Object[] serverObject : serverObjects) { Object[] clientObject = new Object[width]; for (int i = 0; i < width; i++) { if (rsMapping.get(i) instanceof EntityResultSegment) { clientObject[i] = convertSingleObject(serverMetadata .getPrefetchTree(), op, serverObject[i]); } else { clientObject[i] = serverObject[i]; } } clientObjects.add(clientObject); } return clientObjects; }
private void runQuery() { // reset this.fullResponse = new GenericResponse(); this.response = this.fullResponse; this.queriesByNode = null; this.queriesByExecutedQueries = null; // whether this is null or not will driver further decisions on how to process // prefetched rows this.prefetchResultsByPath = metadata.getPrefetchTree() != null && !metadata.isFetchingDataRows() ? new HashMap() : null; // categorize queries by node and by "executable" query... query.route(this, domain.getEntityResolver(), null); // run categorized queries if (queriesByNode != null) { Iterator nodeIt = queriesByNode.entrySet().iterator(); while (nodeIt.hasNext()) { Map.Entry entry = (Map.Entry) nodeIt.next(); QueryEngine nextNode = (QueryEngine) entry.getKey(); Collection nodeQueries = (Collection) entry.getValue(); nextNode.performQueries(nodeQueries, this); } } }
private void runQuery() { // reset this.fullResponse = new GenericResponse(); this.response = this.fullResponse; this.queriesByNode = null; this.queriesByExecutedQueries = null; // whether this is null or not will driver further decisions on how to process prefetched rows this.prefetchResultsByPath = metadata.getPrefetchTree() != null && !metadata.isFetchingDataRows() ? new HashMap<String, List>() : null; // categorize queries by node and by "executable" query... query.route(this, domain.getEntityResolver(), null); // run categorized queries if (queriesByNode != null) { for (Map.Entry<QueryEngine, Collection<Query>> entry : queriesByNode.entrySet()) { QueryEngine nextNode = entry.getKey(); Collection<Query> nodeQueries = entry.getValue(); nextNode.performQueries(nodeQueries, this); } } }
EntityResultSegment entitySegment = (EntityResultSegment) rsMapping.get(i); PrefetchProcessorNode nextResult = toResultsTree(entitySegment.getClassDescriptor(), metadata.getPrefetchTree(), mainRows, i);
private List toClientObjects(List serverObjects) { // create a list copy even if it is empty to ensure that we have a // clean serializable list... List clientObjects = new ArrayList(serverObjects.size()); if (!serverObjects.isEmpty()) { ObjectDetachOperation op = new ObjectDetachOperation(serverResolver .getClientEntityResolver()); Iterator it = serverObjects.iterator(); PrefetchTreeNode prefetchTree = serverMetadata.getPrefetchTree(); while (it.hasNext()) { Persistent object = (Persistent) it.next(); ObjectId id = object.getObjectId(); // sanity check if (id == null) { throw new CayenneRuntimeException( "Server returned an object without an id: " + object); } // have to resolve descriptor here for every object, as // often a query will not have any info indicating the // entity type ClassDescriptor serverDescriptor = serverResolver.getClassDescriptor(id .getEntityName()); clientObjects.add(op.detach(object, serverDescriptor, prefetchTree)); } } return clientObjects; }
@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); } } }
Collection prefetches = metadata.getPrefetchTree() != null ? query .getPrefetchTree() .nonPhantomNodes() : Collections.EMPTY_LIST;
PrefetchTreeNode prefetchTree = metadata.getPrefetchTree();
/** * 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()); }
compareFullRows[0] = translator.hasJoins(); final PrefetchTreeNode rootPrefetch = queryMetadata.getPrefetchTree(); if (!compareFullRows[0] && rootPrefetch != null) { rootPrefetch.traverse(new PrefetchProcessor() {
this.internalQuery.setPrefetchTree(metadata.getPrefetchTree());
final PrefetchTreeNode rootPrefetch = md.getPrefetchTree();