Refine search
/** * template method, override to customize * * @param path path * @return field name */ protected String toField(Path<?> path) { PathMetadata md = path.getMetadata(); if (md.getPathType() == PathType.COLLECTION_ANY) { return toField(md.getParent()); } else { String rv = md.getName(); if (md.getParent() != null) { Path<?> parent = md.getParent(); if (parent.getMetadata().getPathType() != PathType.VARIABLE) { rv = toField(parent) + "." + rv; } } return rv; } }
@Override public Expression<?> visit(Path<?> expr, C context) { if (expr.getMetadata().isRoot()) { return expr; } else { PathMetadata metadata = expr.getMetadata(); Path<?> parent = (Path) metadata.getParent().accept(this, context); Object element = metadata.getElement(); if (element instanceof Expression<?>) { element = ((Expression<?>) element).accept(this, context); } if (parent.equals(metadata.getParent()) && Objects.equal(element, metadata.getElement())) { return expr; } else { metadata = new PathMetadata(parent, element, metadata.getPathType()); return ExpressionUtils.path(expr.getType(), metadata); } } }
protected PathImpl(Class<? extends T> type, PathMetadata metadata) { super(type); this.metadata = metadata; this.root = metadata.getRootPath() != null ? metadata.getRootPath() : this; }
public static PathInits getFor(PathMetadata metadata, PathInits root) { if (metadata.isRoot()) { return root; } else if (metadata.getParent().getMetadata().isRoot()) { return DIRECT; } else { return DEFAULT; } }
@Override public Void visit(Path<?> path, Void context) { final PathType pathType = path.getMetadata().getPathType(); final Template template = templates.getTemplate(pathType); final Object element = path.getMetadata().getElement(); List<Object> args; if (path.getMetadata().getParent() != null) { args = ImmutableList.of(path.getMetadata().getParent(), element); } else { args = ImmutableList.of(element); } handleTemplate(template, args); return null; }
@Override public long execute() { int rv = 0; for (T match : query.fetch()) { BeanMap beanMap = new BeanMap(match); for (Map.Entry<Path<?>,Object> entry : paths.entrySet()) { // TODO : support deep updates as well String propertyName = entry.getKey().getMetadata().getName(); beanMap.put(propertyName, entry.getValue()); } rv++; } return rv; }
@SuppressWarnings("all") public QDomainResourceReferentialObjectEntity(Path<? extends DomainResourceReferentialObjectEntity> path) { this((Class) path.getType(), path.getMetadata(), path.getMetadata().isRoot() ? INITS : PathInits.DEFAULT); }
protected Object convert(Path<?> property, Constant<?> constant) { if (isReference(property)) { return asReference(constant.getConstant()); } else if (isId(property)) { if (isReference(property.getMetadata().getParent())) { return asReferenceKey(property.getMetadata().getParent().getType(), constant.getConstant()); } else if (constant.getType().equals(String.class) && isImplicitObjectIdConversion()) { String id = (String) constant.getConstant(); return ObjectId.isValid(id) ? new ObjectId(id) : id; } } return visit(constant, null); }
@Override public Expression<?> visit(Path<?> expr, Context context) { if (expr.getMetadata().getPathType() == PathType.COLLECTION_ANY) { Path<?> parent = (Path<?>) expr.getMetadata().getParent().accept(this, context); expr = ExpressionUtils.path(expr.getType(), PathMetadataFactory.forCollectionAny(parent)); EntityPath<?> replacement = new EntityPathBase<Object>(expr.getType(), ExpressionUtils.createRootVariable(expr, replacedCounter++)); context.add(expr, replacement); return replacement; } else if (expr.getMetadata().getParent() != null) { Context c = new Context(); Path<?> parent = (Path<?>) expr.getMetadata().getParent().accept(this, c); if (c.replace) { context.add(c); return replaceParent(expr, parent); } } return expr; }
@Override public Void visit(Path<?> path, Void context) { final PathType pathType = path.getMetadata().getPathType(); if (pathType == PathType.PROPERTY) { final Path<?> parent = path.getMetadata().getParent(); final String property = path.getMetadata().getName(); final Class<?> parentType = parent.getType(); try { append("("); append("(").append(path.getType().getName()).append(")"); path.getMetadata().getParent().accept(this, context); append(")"); if (path.getMetadata().getParent() != null) { args.add(path.getMetadata().getParent()); args.add(path.getMetadata().getElement()); final Template template = getTemplate(pathType); for (Template.Element element : template.getElements()) {
@SuppressWarnings("rawtypes") private static <T> Path<T> replaceParent(Path<T> path, Path<?> parent) { PathMetadata metadata = new PathMetadata(parent, path.getMetadata().getElement(), path.getMetadata().getPathType()); if (path instanceof CollectionExpression) { CollectionExpression<?,?> col = (CollectionExpression<?,?>) path; return (Path<T>) Expressions.listPath(col.getParameter(0), SimplePath.class, metadata); } else { return ExpressionUtils.path(path.getType(), metadata); } }
public Expression<?> visit(Path<?> expr, @Nullable Void context) { if (expr.getMetadata().isRoot()) { return ExpressionUtils.path(expr.getType(), expr.getMetadata().getName() + "_"); } else { return super.visit(expr, context); } } };
private <P extends Path<?>> P addMetadataOf(P newPath, Path<?> path) { if (path.getMetadata().getParent() instanceof EntityPath) { EntityPath<?> parent = (EntityPath<?>) path.getMetadata().getParent(); if (parent.getMetadata(path) != null) { propertyMetadata.putIfAbsent(newPath, parent.getMetadata(path)); } } return newPath; }
/** * Get the String representation of the last path element * * @param path path * @return String representation */ private String toString(Path<?> path) { return path.getMetadata().getElement().toString(); }
@Test public void comparableEntity_property() { ComparableEntity entity = Alias.alias(ComparableEntity.class); Path<String> propertyPath = $(entity.getProperty()); assertEquals(String.class, propertyPath.getType()); assertEquals("property", propertyPath.getMetadata().getName()); }
public static StringExpression string( Path<?> entityPath ) { return identifier( entityPath.getRoot().toString() ).string( entityPath.getMetadata().getElement() .toString() ); }
@Override public String visit(Path<?> expr, Void context) { PathMetadata metadata = expr.getMetadata(); if (metadata.getParent() != null) { Path<?> parent = metadata.getParent(); if (parent.getMetadata().getPathType() == PathType.DELEGATE) { parent = parent.getMetadata().getParent(); } if (metadata.getPathType() == PathType.COLLECTION_ANY) { return visit(parent, context); } else if (parent.getMetadata().getPathType() != PathType.VARIABLE) { String rv = getKeyForPath(expr, metadata); String parentStr = visit(parent, context); return rv != null ? parentStr + "." + rv : parentStr; } } return getKeyForPath(expr, metadata); }
public boolean isRoot() { return parent == null || (pathType == PathType.DELEGATE && parent.getMetadata().isRoot()); }
@Override public Void visit(Path<?> expr, Void context) { // only wrap a PathCollection, if it the pathType is PROPERTY boolean wrap = wrapElements && (Collection.class.isAssignableFrom(expr.getType()) || Map.class.isAssignableFrom(expr.getType())) && expr.getMetadata().getPathType().equals(PathType.PROPERTY); if (wrap) { append("elements("); } super.visit(expr, context); if (wrap) { append(")"); } return null; }
private Path<?> normalizePath(Path<?> expr) { Context context = new Context(); Path<?> replaced = (Path<?>) expr.accept(collectionAnyVisitor, context); if (!replaced.equals(expr)) { for (int i = 0; i < context.paths.size(); i++) { Path path = context.paths.get(i).getMetadata().getParent(); Path replacement = context.replacements.get(i); this.innerJoin(path, replacement); } return replaced; } else { return expr; } }