private Path<?> getPath(Expression<?> leftHandSide) { if (leftHandSide instanceof Path<?>) { return (Path<?>)leftHandSide; } else if (leftHandSide instanceof Operation<?>) { Operation<?> operation = (Operation<?>) leftHandSide; if (operation.getOperator() == Ops.LOWER || operation.getOperator() == Ops.UPPER) { return (Path<?>)operation.getArg(0); } } throw new IllegalArgumentException("Unable to transform " + leftHandSide + " to path"); }
@Override public Integer visit(Operation<?> expr, Void context) { int result = expr.getOperator().hashCode(); return 31 * result + expr.getArgs().hashCode(); }
private static ImmutableMap<Expression<?>, Integer> createBindings(List<Expression<?>> exprs) { Map<Expression<?>, Integer> map = Maps.newHashMap(); for (int i = 0; i < exprs.size(); i++) { Expression<?> e = exprs.get(i); if (e instanceof Operation && ((Operation<?>)e).getOperator() == Ops.ALIAS) { map.put(((Operation<?>)e).getArg(1), i); } map.put(e, i); } return ImmutableMap.copyOf(map); }
private List<Expression<?>> transformList(Expression<?> expr, List<Expression<?>> elements) { if (expr instanceof Operation<?> && ((Operation<?>) expr).getOperator() == Ops.LIST) { Operation<?> list = (Operation<?>) expr; transformList(list.getArg(0), elements); elements.add(list.getArg(1)); } else { elements.add(expr); } return elements; }
@Override public final boolean equals(Object o) { if (o == this) { return true; } else if (o instanceof Operation<?>) { Operation<?> op = (Operation<?>)o; return op.getOperator() == operator && op.getArgs().equals(args) && op.getType().equals(getType()); } else { return false; } }
public GroupImpl(List<GroupExpression<?, ?>> columnDefinitions, List<QPair<?, ?>> maps) { this.groupExpressions = columnDefinitions; this.maps = maps; for (int i=0; i < columnDefinitions.size(); i++) { GroupExpression<?, ?> coldef = columnDefinitions.get(i); GroupCollector<?,?> collector = groupCollectorMap.get(coldef.getExpression()); if (collector == null) { collector = coldef.createGroupCollector(); Expression<?> coldefExpr = coldef.getExpression(); groupCollectorMap.put(coldefExpr, collector); if (coldefExpr instanceof Operation && ((Operation)coldefExpr).getOperator() == Ops.ALIAS) { groupCollectorMap.put(((Operation)coldefExpr).getArg(1), collector); } } groupCollectors.add(collector); } }
private List<?> project(QueryMetadata metadata, List<Expression<?>> sources, List<?> list) { Expression<?> projection = metadata.getProjection().get(0); Operator<?> aggregator = null; if (projection instanceof Operation && Ops.aggOps.contains(((Operation)projection).getOperator())) { Operation<?> aggregation = (Operation<?>)projection; aggregator = aggregation.getOperator(); projection = aggregation.getArg(0); } Evaluator projectionEvaluator = evaluatorFactory.create(metadata, sources, projection); EvaluatorFunction transformer = new EvaluatorFunction(projectionEvaluator); List target = new ArrayList(); Iterators.addAll(target, Iterators.transform(list.iterator(), transformer)); if (aggregator != null) { return ImmutableList.of(CollQueryFunctions.aggregate(target, projection, aggregator)); } else { return target; } }
AbstractGroupByTransformer(Expression<K> key, Expression<?>... expressions) { List<Expression<?>> projection = new ArrayList<Expression<?>>(expressions.length); groupExpressions.add(new GOne<K>(key)); projection.add(key); for (Expression<?> expr : expressions) { if (expr instanceof GroupExpression<?,?>) { GroupExpression<?,?> groupExpr = (GroupExpression<?,?>)expr; groupExpressions.add(groupExpr); Expression<?> colExpression = groupExpr.getExpression(); if (colExpression instanceof Operation && ((Operation)colExpression).getOperator() == Ops.ALIAS) { projection.add(((Operation)colExpression).getArg(0)); } else { projection.add(colExpression); } if (groupExpr instanceof GMap) { maps.add((QPair<?, ?>) colExpression); } } else { groupExpressions.add(new GOne(expr)); projection.add(expr); } } this.expressions = projection.toArray(new Expression[projection.size()]); }
@Override public Expression<?> visit(Operation<?> expr, @Nullable Void context) { ImmutableList<Expression<?>> args = visit(expr.getArgs()); if (args.equals(expr.getArgs())) { return expr; } else if (expr instanceof Predicate) { return new PredicateOperation((Operator)expr.getOperator(), args); } else { return new OperationImpl(expr.getType(), expr.getOperator(), args); } }
@Override public Void visit(Operation<?> expr, Void context) { visitOperation(expr.getType(), expr.getOperator(), expr.getArgs()); return null; }
@SuppressWarnings("unchecked") private <T> Expr<?> regexToLike(Operation<T> operation) { List<Expr<?>> args = new ArrayList<Expr<?>>(); for (Expr<?> arg : operation.getArgs()){ if (!arg.getType().equals(String.class)){ args.add(arg); }else if (arg instanceof Constant){ args.add(regexToLike(arg.toString())); }else if (arg instanceof Operation){ args.add(regexToLike((Operation)arg)); }else{ args.add(arg); } } return OSimple.create( operation.getType(), operation.getOperator(), args.<Expr<?>>toArray(new Expr[args.size()])); }
/** * template method * * @param leftHandSide * @param rightHandSide * @return */ protected String[] convert(Path<?> leftHandSide, Expression<?> rightHandSide, QueryMetadata metadata) { if (rightHandSide instanceof Operation) { Operation<?> operation = (Operation<?>)rightHandSide; if (operation.getOperator() == LuceneExpressions.PHRASE) { return Iterables.toArray(WS_SPLITTER.split(operation.getArg(0).toString()), String.class); } else if (operation.getOperator() == LuceneExpressions.TERM) { return new String[] { operation.getArg(0).toString() }; } else { throw new IllegalArgumentException(rightHandSide.toString()); } } else if (rightHandSide instanceof ParamExpression<?>) { Object value = metadata.getParams().get(rightHandSide); if (value == null) { throw new ParamNotSetException((ParamExpression<?>) rightHandSide); } return convert(leftHandSide, value); } else if (rightHandSide instanceof Constant<?>) { return convert(leftHandSide, ((Constant<?>)rightHandSide).getConstant()); } else { throw new IllegalArgumentException(rightHandSide.toString()); } }
@Override public String visit(Operation<?> o, Templates templates) { final Template template = templates.getTemplate(o.getOperator()); if (template != null) { final int precedence = templates.getPrecedence(o.getOperator()); final StringBuilder builder = new StringBuilder(); for (Template.Element element : template.getElements()) { final Object rv = element.convert(o.getArgs()); if (rv instanceof Expression) { if (precedence > -1 && rv instanceof Operation) { if (precedence < templates.getPrecedence(((Operation<?>)rv).getOperator())) { builder.append("("); builder.append(((Expression)rv).accept(this, templates)); builder.append(")"); continue; } } builder.append(((Expression)rv).accept(this, templates)); } else { builder.append(rv.toString()); } } return builder.toString(); } else { return "unknown operation with operator " + o.getOperator().getId() + " and args " + o.getArgs(); } }
@SuppressWarnings("unchecked") @Override public Expression<?> visit(Operation<?> expr, Context context) { final Expression<?>[] args = new Expression<?>[expr.getArgs().size()]; for (int i = 0; i < args.length; i++) { Context c = new Context(); args[i] = expr.getArg(i).accept(this, c); context.add(c); } if (context.replace) { if (expr.getType().equals(Boolean.class)) { Predicate predicate = new PredicateOperation((Operator)expr.getOperator(), ImmutableList.copyOf(args)); return !context.paths.isEmpty() ? exists(context, predicate) : predicate; } else { return new OperationImpl(expr.getType(), expr.getOperator(), ImmutableList.copyOf(args)); } } else { return expr; } }
@SuppressWarnings("rawtypes") @Override public Expression<?> visit(Operation<?> expr, Context context) { Expression<?>[] args = new Expression<?>[expr.getArgs().size()]; for (int i = 0; i < args.length; i++) { Context c = new Context(); args[i] = expr.getArg(i).accept(this, c); context.add(c); } if (context.replace) { if (expr.getType().equals(Boolean.class)) { Predicate predicate = new PredicateOperation((Operator<Boolean>)expr.getOperator(), ImmutableList.copyOf(args)); return !context.paths.isEmpty() ? exists(context, predicate) : predicate; } else { return new OperationImpl(expr.getType(), expr.getOperator(), ImmutableList.copyOf(args)); } } else { return expr; } }
@Override public BooleanExpression exists() { if (queryMixin.getMetadata().getJoins().isEmpty()) { throw new IllegalArgumentException("No sources given"); } Expression<?> expr = queryMixin.getMetadata().getJoins().get(0).getTarget(); if (expr instanceof Operation && ((Operation)expr).getOperator() == Ops.ALIAS) { expr = ((Operation)expr).getArg(1); } return unique(expr).exists(); }
@Override public Set<Expression<?>> visit(Operation<?> expr, Set<Expression<?>> known) { if (expr.getOperator() == Ops.ALIAS) { known = add(known, expr.getArg(1)); } for (Expression<?> arg : expr.getArgs()) { known = arg.accept(this, known); } return known; }
@SuppressWarnings("unchecked") @Override public NumberSubQuery<Long> count() { Expression<?> target = queryMixin.getMetadata().getJoins().get(0).getTarget(); if (target instanceof Operation && ((Operation)target).getOperator() == Ops.ALIAS) { target = ((Operation)target).getArg(1); } return unique(NumberOperation.create(Long.class, Ops.AggOps.COUNT_AGG, target)); }
private static ImmutableMap<String,Expression<?>> createBindings(Expression<?>... args) { ImmutableMap.Builder<String, Expression<?>> rv = ImmutableMap.builder(); for (Expression<?> expr : args) { if (expr instanceof Path<?>) { Path<?> path = (Path<?>)expr; rv.put(path.getMetadata().getName(), expr); } else if (expr instanceof Operation<?>) { Operation<?> operation = (Operation<?>)expr; if (operation.getOperator() == Ops.ALIAS && operation.getArg(1) instanceof Path<?>) { Path<?> path = (Path<?>)operation.getArg(1); if (isCompoundExpression(operation.getArg(0))) { rv.put(path.getMetadata().getName(), operation.getArg(0)); } else { rv.put(path.getMetadata().getName(), operation); } } else { throw new IllegalArgumentException("Unsupported expression " + expr); } } else { throw new IllegalArgumentException("Unsupported expression " + expr); } } return rv.build(); }
@SuppressWarnings("unchecked") private Operation<?> transformPathEqNeConstant(Operation<?> operation) { Path<?> path = (Path<?>) operation.getArg(0); Constant<?> constant = (Constant<?>) operation.getArg(1); MappedPath mappedPath = getMappedPath(path); // id property if (path.getMetadata().getPathType() == PathType.PROPERTY && constant.getType().equals(String.class) && mappedPath.getPredicatePath().isEmpty()) { operation = PredicateOperation.create((Operator) operation.getOperator(), path, new ConstantImpl<ID>(session.getId(new LID(constant.toString())))); // localized property } else if (mappedPath.getMappedProperty().isLocalized()) { Locale locale; if (path.getMetadata().getPathType() == PathType.PROPERTY) { locale = session.getCurrentLocale(); } else { locale = (Locale) path.getMetadata().getElement(); } operation = PredicateOperation.create((Operator) operation.getOperator(), path, new ConstantImpl<LIT>(new LIT(constant.toString(), locale))); } return operation; }