Refine search
@SuppressWarnings("all") public QCustomer(Path<? extends Customer> path) { this((Class)path.getType(), path.getMetadata(), path.getMetadata().isRoot() ? INITS : PathInits.DEFAULT); }
private MappedPath getMappedPath(Path<?> path) { PathMetadata<?> md = path.getMetadata(); if (path.getMetadata().getPathType() != PathType.PROPERTY) { md = md.getParent().getMetadata(); } MappedClass mc = configuration.getMappedClass(md.getParent().getType()); return mc.getMappedPath(md.getElement().toString()); }
@Override public Expression<?> visit(Path<?> expr, @Nullable Void context) { if (expr.getMetadata().isRoot()) { return expr; } else { PathMetadata metadata = expr.getMetadata(); Path<?> parent = (Path)metadata.getParent().accept(this, null); Object element = metadata.getElement(); if (element instanceof Expression<?>) { element = ((Expression) element).accept(this, null); } if (parent.equals(metadata.getParent()) && Objects.equal(element, metadata.getElement())) { return expr; } else { metadata = new PathMetadata(parent, element, metadata.getPathType()); return new PathImpl(expr.getType(), metadata); } } }
@SuppressWarnings("unchecked") private static <T> Path<T> replaceParent(Path<T> path, Path<?> parent) { PathMetadata<?> metadata = new PathMetadata(parent, path.getMetadata().getElement(), path.getMetadata().getPathType()); return new PathImpl<T>(path.getType(), metadata); }
protected Map<String, Path<?>> getColumns(RelationalPath<?> path) { Map<String, Path<?>> columns = Maps.newLinkedHashMap(); for (Path<?> column : path.getColumns()) { columns.put(column.getMetadata().getName(), column); } return columns; }
@Override public Void visit(Path<?> path, Void context) { if (path.getMetadata().getParent() == null && !path.getType().equals(path.getClass())){ super.visit(path, context); append(".*"); entityPaths.add(path); }else{ super.visit(path, context); } return null; }
/** * @param newPath * @param path * @return */ private <P extends Path<?>> P addMetadataOf(P newPath, Path<?> path) { if (path.getMetadata().getParent() instanceof EntityPath) { EntityPath<?> parent = (EntityPath)path.getMetadata().getParent(); propertyMetadata.put(newPath, parent.getMetadata(path)); } return newPath; }
@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; }
@Override public Set<RelationalPath<?>> visit(Path<?> expr, Set<RelationalPath<?>> known) { if (expr.getMetadata().isRoot()) { if (expr instanceof RelationalPath) { known = add(known, (RelationalPath<?>)expr); } } else { known = expr.getMetadata().getParent().accept(this, known); } return known; }
/** * template method, override to customize * * @param path * @return */ protected String toField(Path<?> path) { String rv = path.getMetadata().getName(); if (path.getMetadata().getParent() != null) { Path<?> parent = path.getMetadata().getParent(); if (parent.getMetadata().getPathType() != PathType.VARIABLE) { rv = toField(parent) + "." + rv; } } return rv; }
private Set<Path<?>> getRootPaths(Collection<Expression<?>> exprs) { Set<Path<?>> paths = Sets.newHashSet(); for (Expression<?> e : exprs) { Path<?> path = e.accept(PathExtractor.DEFAULT, null); if (path != null && !path.getMetadata().isRoot()) { paths.add(path.getMetadata().getRoot()); } } return paths; }
@Override public final AnnotatedElement getAnnotatedElement() { if (annotatedElement == null) { if (metadata.getPathType() == PathType.PROPERTY) { Class<?> beanClass = metadata.getParent().getType(); String propertyName = metadata.getName(); annotatedElement = ReflectionUtils.getAnnotatedElement(beanClass, propertyName, getType()); } else { annotatedElement = getType(); } } return annotatedElement; }
public static String getName(Path<?> path) { Path<?> parent = path.getMetadata().getParent(); if (parent instanceof EntityPath) { Object columnMetadata = ((EntityPath<?>) parent).getMetadata(path); if (columnMetadata instanceof ColumnMetadata) { return ((ColumnMetadata)columnMetadata).getName(); } } return path.getMetadata().getName(); }
@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); }
@Override public Void visit(Path<?> expr, Void context) { if (expr.getMetadata().getElement() instanceof Expression) { handle((Expression) expr.getMetadata().getElement()); } handle(expr.getMetadata().getParent()); return null; }
private static String getName(Expression<?> expression) { if (expression instanceof Path<?>) { @SuppressWarnings("rawtypes") PathMetadata<?> metadata = ((Path) expression).getMetadata(); if (metadata.getPathType() == PathType.PROPERTY) { return metadata.getElement().toString(); } else { throw new MappingException("Unexpected expression " + expression); } } else { throw new MappingException("Unexpected expression " + expression); } }
private Path<?> normalizePath(Path<?> expr) { Context context = new Context(); Path<?> replaced = (Path<?>)expr.accept(CollectionAnyVisitor.DEFAULT, 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; } }
public QOrder(PathMetadata<?> metadata) { this(metadata, metadata.isRoot() ? INITS : PathInits.DEFAULT); }
/** * @param path * @return */ private String toString(Path<?> path) { return path.getMetadata().getElement().toString(); }
protected String getKeyForPath(Path<?> expr, PathMetadata<?> metadata) { if (expr.getType().equals(ObjectId.class)) { return "_id"; } else { return metadata.getElement().toString(); } }