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"); }
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"); }
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"); }
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); }
@Override public Integer visit(Operation<?> expr, Void context) { int result = expr.getOperator().name().hashCode(); return 31 * result + expr.getArgs().hashCode(); }
private static Expression<?> unwrap(Expression<?> expr) { expr = ExpressionUtils.extract(expr); if (expr instanceof Operation && ((Operation<?>) expr).getOperator() == Ops.ALIAS) { return ((Operation<?>) expr).getArg(0); } return expr; }
@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); } }
@SuppressWarnings("unchecked") 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()]); }
private List<?> project(QueryMetadata metadata, List<Expression<?>> sources, List<?> list) { Expression<?> projection = metadata.getProjection(); 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; } }
@Override public Expression<?> visit(Operation<?> expr, C context) { ImmutableList<Expression<?>> args = visit(expr.getArgs(), context); if (args.equals(expr.getArgs())) { return expr; } else if (expr instanceof Predicate) { return ExpressionUtils.predicate(expr.getOperator(), args); } else { return ExpressionUtils.operation(expr.getType(), expr.getOperator(), args); } }
@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().name() + " and args " + o.getArgs(); } }
/** * template method * * @param leftHandSide left hand side * @param rightHandSide right hand side * @return results */ protected String[] convert(Path<?> leftHandSide, Expression<?> rightHandSide, QueryMetadata metadata) { if (rightHandSide instanceof Operation) { Operation<?> operation = (Operation<?>) rightHandSide; if (operation.getOperator() == LuceneOps.PHRASE) { return Iterables.toArray(WS_SPLITTER.split(operation.getArg(0).toString()), String.class); } else if (operation.getOperator() == LuceneOps.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()); } }
/** * template method * * @param leftHandSide left hand side * @param rightHandSide right hand side * @return results */ protected String[] convert(Path<?> leftHandSide, Expression<?> rightHandSide, QueryMetadata metadata) { if (rightHandSide instanceof Operation) { Operation<?> operation = (Operation<?>) rightHandSide; if (operation.getOperator() == LuceneOps.PHRASE) { return Iterables.toArray(WS_SPLITTER.split(operation.getArg(0).toString()), String.class); } else if (operation.getOperator() == LuceneOps.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 Void visit(Operation<?> expr, Void context) { visitOperation(expr.getType(), expr.getOperator(), expr.getArgs()); return null; }
@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("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 = ExpressionUtils.predicate(expr.getOperator(), args); return !context.paths.isEmpty() ? exists(context, predicate) : predicate; } else { return ExpressionUtils.operation(expr.getType(), expr.getOperator(), args); } } else { return expr; } }
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(); }
@Override public Object convert(List<?> args) { Object arg1 = args.get(index1); if (isNumber(arg1)) { return MathUtils.result(asNumber(arg1), arg2, operator); } else { Expression<?> expr1 = asExpression(arg1); if (CONVERTIBLES.contains(operator) && expr1 instanceof com.querydsl.core.types.Operation) { com.querydsl.core.types.Operation operation = (com.querydsl.core.types.Operation) expr1; if (CONVERTIBLES.contains(operation.getOperator()) && operation.getArg(1) instanceof Constant) { Number num1 = ((Constant<Number>) operation.getArg(1)).getConstant(); Number num2; if (operator == operation.getOperator()) { num2 = MathUtils.result(num1, arg2, Ops.ADD); } else if (operator == Ops.ADD) { num2 = MathUtils.result(arg2, num1, Ops.SUB); } else { num2 = MathUtils.result(num1, arg2, Ops.SUB); } return ExpressionUtils.operation(expr1.getType(), operator, operation.getArg(0), Expressions.constant(num2)); } } return ExpressionUtils.operation(expr1.getType(), operator, expr1, expr2); } }
@SuppressWarnings("unchecked") @Test public void various() { Expression[] args = new Expression[]{new StringPath("x"), new StringPath("y")}; List<Operation<?>> operations = new ArrayList<Operation<?>>(); // paths.add(new ArrayOperation(String[].class, "p")); operations.add(new BooleanOperation(Ops.EQ, args)); operations.add(new ComparableOperation(String.class, Ops.SUBSTR_1ARG, args)); operations.add(new DateOperation(Date.class, Ops.DateTimeOps.CURRENT_DATE, args)); operations.add(new DateTimeOperation(Date.class,Ops.DateTimeOps.CURRENT_TIMESTAMP, args)); operations.add(new EnumOperation(ExampleEnum.class,Ops.ALIAS, args)); operations.add(new NumberOperation(Integer.class,Ops.ADD, args)); operations.add(new SimpleOperation(String.class,Ops.TRIM, args)); operations.add(new StringOperation(Ops.CONCAT, args)); operations.add(new TimeOperation(Time.class,Ops.DateTimeOps.CURRENT_TIME, args)); for (Operation<?> operation : operations) { Operation<?> other = ExpressionUtils.operation(operation.getType(), operation.getOperator(), ImmutableList.copyOf(operation.getArgs())); assertEquals(operation.toString(), operation.accept(ToStringVisitor.DEFAULT, Templates.DEFAULT)); assertEquals(operation.hashCode(), other.hashCode()); assertEquals(operation, other); assertNotNull(operation.getOperator()); assertNotNull(operation.getArgs()); assertNotNull(operation.getType()); } }