/** * Merges a prefetch path with specified semantics into the query prefetch * tree. * * @return this object */ public ColumnSelect<T> prefetch(String path, int semantics) { if (path == null) { return this; } if (prefetches == null) { prefetches = new PrefetchTreeNode(); } prefetches.addPath(path).setSemantics(semantics); replacementQuery = null; return this; }
/** * Merges a prefetch path with specified semantics into the query prefetch * tree. * * @return this object */ public SelectById<T> prefetch(String path, int semantics) { if (path == null) { return this; } if (prefetches == null) { prefetches = new PrefetchTreeNode(); } prefetches.addPath(path).setSemantics(semantics); return this; }
/** * Merges a prefetch path with specified semantics into the query prefetch * tree. * * @return this object */ public ObjectSelect<T> prefetch(String path, int semantics) { if (path == null) { return this; } if (prefetches == null) { prefetches = new PrefetchTreeNode(); } prefetches.addPath(path).setSemantics(semantics); replacementQuery = null; return this; }
/** * Creates and returns a prefetch tree spanning a single path. The tree is * made of phantom nodes, up to the leaf node, which is non-phantom and has * specified semantics. * * @since 4.0 */ public static PrefetchTreeNode withPath(String path, int semantics) { PrefetchTreeNode root = new PrefetchTreeNode(); PrefetchTreeNode node = root.addPath(path); node.setPhantom(false); node.setSemantics(semantics); return root; }
/** * Adds a joint prefetch. * * @since 1.2 */ PrefetchTreeNode addPrefetch(String path, int semantics) { if (prefetchTree == null) { prefetchTree = new PrefetchTreeNode(); } PrefetchTreeNode node = prefetchTree.addPath(path); node.setSemantics(semantics); node.setPhantom(false); return node; }
/** * Adds a joint prefetch. * * @since 1.2 */ PrefetchTreeNode addPrefetch(String path, int semantics) { if (prefetchTree == null) { prefetchTree = new PrefetchTreeNode(); } PrefetchTreeNode node = prefetchTree.addPath(path); node.setSemantics(semantics); node.setPhantom(false); return node; }
private void appendPrefetches(PrefetchTreeNode root, ResourceEntity<?> entity, int prefetchSemantics) { for (Map.Entry<String, ResourceEntity<?>> e : entity.getChildren().entrySet()) { // skip prefetches of non-persistent entities if (e.getValue().getAgEntity() instanceof AgPersistentEntity) { PrefetchTreeNode child = root.addPath(e.getKey()); // always full prefetch related entities... we can't use phantom // as this will hit object cache and hence won't be cache // controlled via query cache anymore... child.setPhantom(false); child.setSemantics(prefetchSemantics); appendPrefetches(child, e.getValue(), prefetchSemantics); } } if (entity.getMapBy() != null) { appendPrefetches(root, entity.getMapBy(), prefetchSemantics); } } }
protected PrefetchProcessorNode toResultsTree(ClassDescriptor descriptor, PrefetchTreeNode prefetchTree, List<Object[]> rows, int position) { List<DataRow> rowsColumn = new ArrayList<>(rows.size()); for (Object[] row : rows) { rowsColumn.add((DataRow) row[position]); } if (prefetchTree != null) { PrefetchTreeNode prefetchTreeNode = null; for (PrefetchTreeNode prefetch : prefetchTree.getChildren()) { if (descriptor.getEntity().getName().equals(prefetch.getEntityName())) { if (prefetchTreeNode == null) { prefetchTreeNode = new PrefetchTreeNode(); } PrefetchTreeNode addPath = prefetchTreeNode.addPath(prefetch.getPath()); addPath.setSemantics(prefetch.getSemantics()); addPath.setPhantom(false); } } prefetchTree = prefetchTreeNode; } if (prefetchTree == null) { return new ObjectResolver(context, descriptor, metadata.isRefreshingObjects()) .synchronizedRootResultNodeFromDataRows(rowsColumn); } else { HierarchicalObjectResolver resolver = new HierarchicalObjectResolver(context, metadata, descriptor, true); return resolver.synchronizedRootResultNodeFromDataRows(prefetchTree, rowsColumn, prefetchResultsByPath); } }
private PrefetchTreeNode cloneJointSubtree(PrefetchTreeNode parent) { PrefetchTreeNode cloned = new PrefetchTreeNode(parent, getName()); if (parent != null) { cloned.setSemantics(getSemantics()); cloned.setPhantom(isPhantom()); } if (children != null) { for (PrefetchTreeNode child : children) { if (child.isJointPrefetch()) { cloned.addChild(child.cloneJointSubtree(cloned)); } } } return cloned; }
private void prepareFetchJoin(EJBQLJoin join) { if (prefetchTree == null) { prefetchTree = new PrefetchTreeNode(); } EJBQLPath fetchJoin = (EJBQLPath) join.getChild(0); addPath(fetchJoin); PrefetchTreeNode node = prefetchTree.addPath(fetchJoin.getRelativePath()); node.setSemantics(PrefetchTreeNode.JOINT_PREFETCH_SEMANTICS); node.setPhantom(false); node.setEjbqlPathEntityId(fetchJoin.getChild(0).getText()); }
void merge(PrefetchTreeNode original, PrefetchTreeNode toMerge) { if (toMerge.getSemantics() != UNDEFINED_SEMANTICS) { original.setSemantics(toMerge.getSemantics()); } if (!toMerge.isPhantom()) { original.setPhantom(false); } for (PrefetchTreeNode childToMerge : toMerge.getChildren()) { PrefetchTreeNode childOrigin = original.getChild(childToMerge.getName()); if (childOrigin == null) { childOrigin = original.addPath(childToMerge.getName()); } merge(childOrigin, childToMerge); } }
break; case 3: message.setSemantics(input.readInt32()); break; case 4:
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; }
node.setSemantics(PrefetchTreeNode.UNDEFINED_SEMANTICS); node.setPhantom(false);