Refine search
public QCustomer(Path<? extends Customer> path) { super(path.getType(), path.getMetadata()); }
@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); } } }
@Nullable private MongoPersistentProperty getPropertyFor(Path<?> path) { Path<?> parent = path.getMetadata().getParent(); if (parent == null || !PATH_TYPES.contains(path.getMetadata().getPathType())) { return null; } MongoPersistentEntity<?> entity = mappingContext.getPersistentEntity(parent.getType()); return entity != null ? entity.getPersistentProperty(path.getMetadata().getName()) : null; }
@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); } }
/** * QAbstractAuditedEntityAsMillis is a Querydsl query type for AbstractAuditedEntityAsMillis */ @Generated("com.querydsl.codegen.SupertypeSerializer") public class QAbstractAuditedEntityAsMillis extends EntityPathBase<AbstractAuditedEntityAsMillis> { private static final long serialVersionUID = 1992558749L; public static final QAbstractAuditedEntityAsMillis abstractAuditedEntityAsMillis = new QAbstractAuditedEntityAsMillis("abstractAuditedEntityAsMillis"); public final DateTimePath<org.joda.time.DateTime> createdTime = createDateTime("createdTime", org.joda.time.DateTime.class); public final DateTimePath<org.joda.time.DateTime> modifiedTime = createDateTime("modifiedTime", org.joda.time.DateTime.class); public QAbstractAuditedEntityAsMillis(String variable) { super(AbstractAuditedEntityAsMillis.class, forVariable(variable)); } public QAbstractAuditedEntityAsMillis(Path<? extends AbstractAuditedEntityAsMillis> path) { super(path.getType(), path.getMetadata()); } public QAbstractAuditedEntityAsMillis(PathMetadata metadata) { super(AbstractAuditedEntityAsMillis.class, metadata); } }
@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; }
@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; }
@SuppressWarnings("unchecked") @Test public void various() { List<Path<?>> paths = new ArrayList<Path<?>>(); paths.add(new ArrayPath(String[].class, "p")); paths.add(new BeanPath(Object.class, "p")); paths.add(new BooleanPath("p")); paths.add(new CollectionPath(String.class, StringPath.class, "p")); paths.add(new ComparablePath(String.class,"p")); paths.add(new DatePath(Date.class,"p")); paths.add(new DateTimePath(Date.class,"p")); paths.add(new EnumPath(ExampleEnum.class,"p")); paths.add(new ListPath(String.class, StringPath.class, "p")); paths.add(new MapPath(String.class, String.class, StringPath.class, "p")); paths.add(new NumberPath(Integer.class,"p")); paths.add(new SetPath(String.class, StringPath.class, "p")); paths.add(new SimplePath(String.class,"p")); paths.add(new StringPath("p")); paths.add(new TimePath(Time.class,"p")); for (Path<?> path : paths) { Path other = ExpressionUtils.path(path.getType(), "p"); assertEquals(path.toString(), path.accept(ToStringVisitor.DEFAULT, null)); assertEquals(path.hashCode(), other.hashCode()); assertEquals(path, other); assertNotNull(path.getMetadata()); assertNotNull(path.getType()); assertEquals(path, path.getRoot()); } }
@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((path.getType()).getName()).append(">get("); handle(parent); append(", \"" + property + "\")"); 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()) {
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); } } };
/** * Create a Bean populating projection for the given type and expressions * * @param <T> type of projection * @param type type of the projection * @param exprs arguments for the projection * @return factory expression */ public static <T> QBean<T> bean(Path<? extends T> type, Expression<?>... exprs) { return new QBean<T>(type.getType(), exprs); }
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); }
@SuppressWarnings("unchecked") @Nullable protected Predicate createJoinFilter(QueryMetadata metadata) { Multimap<Expression<?>, Predicate> predicates = HashMultimap.create(); List<JoinExpression> joins = metadata.getJoins(); for (int i = joins.size() - 1; i >= 0; i--) { JoinExpression join = joins.get(i); Path<?> source = (Path) ((Operation<?>) join.getTarget()).getArg(0); Path<?> target = (Path) ((Operation<?>) join.getTarget()).getArg(1); Collection<Predicate> extraFilters = predicates.get(target.getRoot()); Predicate filter = ExpressionUtils.allOf(join.getCondition(), allOf(extraFilters)); List<? extends Object> ids = getIds(target.getType(), filter); if (ids.isEmpty()) { throw new NoResults(); } Path<?> path = ExpressionUtils.path(String.class, source, "$id"); predicates.put(source.getRoot(), ExpressionUtils.in((Path<Object>) path, ids)); } Path<?> source = (Path) ((Operation) joins.get(0).getTarget()).getArg(0); return allOf(predicates.get(source.getRoot())); }
@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 boolean isRoot() { return parent == null || (pathType == PathType.DELEGATE && parent.getMetadata().isRoot()); }
public static StringExpression string( Path<?> entityPath ) { return identifier( entityPath.getRoot().toString() ).string( entityPath.getMetadata().getElement() .toString() ); }
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; }
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; }