@Override public String visit(Constant<?> e, Templates templates) { return e.getConstant().toString(); }
@Override public boolean equals(Object o) { if (o == this) { return true; } else if (o instanceof Constant<?>) { return ((Constant<?>)o).getConstant().equals(constant); } else { return false; } }
@Override public Integer visit(Constant<?> expr, Void context) { return expr.getConstant().hashCode(); }
@Override public Object visit(Constant<?> expr, Void context) { if (Enum.class.isAssignableFrom(expr.getType())) { return ((Enum<?>)expr.getConstant()).name(); } else { return expr.getConstant(); } }
@Override public final Void visit(Constant<?> expr, Void context) { visitConstant(expr.getConstant()); return null; }
@Override public Void visit(Constant<?> expr, Void context) { if (!getConstantToLabel().containsKey(expr.getConstant())) { String constLabel = getConstantPrefix() + (getConstantToLabel().size() + 1); getConstantToLabel().put(expr.getConstant(), constLabel); append(":"+constLabel); } else { append(":"+getConstantToLabel().get(expr.getConstant())); } return null; }
@SuppressWarnings({"unchecked"}) protected Query range(Path<?> leftHandSide, String field, @Nullable Expression<?> min, @Nullable Expression<?> max, boolean minInc, boolean maxInc, QueryMetadata metadata) { if (min != null && Number.class.isAssignableFrom(min.getType()) || max != null && Number.class.isAssignableFrom(max.getType())) { Class<? extends Number> numType = (Class) (min != null ? min.getType() : max.getType()); return numericRange((Class) numType, field, (Number) (min == null ? null : ((Constant) min).getConstant()), (Number) (max == null ? null : ((Constant) max).getConstant()), minInc, maxInc); } return stringRange(leftHandSide, field, min, max, minInc, maxInc, metadata); }
@Override public NODE visit(Constant<?> expr, Bindings bindings) { if (expr.getType().equals(String.class)) { return new LIT(expr.getConstant().toString()); } else if (NODE.class.isAssignableFrom(expr.getType())) { return (NODE) expr.getConstant(); } else { UID datatype = ConverterRegistryImpl.DEFAULT.getDatatype(expr.getType()); String value = ConverterRegistryImpl.DEFAULT.toString(expr.getConstant()); return new LIT(value, datatype); } }
@Override public Void visit(Constant<?> expr, Void context) { Object o = expr.getConstant(); if (o instanceof Collection<?>) { Collection<?> col = (Collection<?>) o; for (Object c : col) { if (c instanceof UID) { namespaces.add(((UID) c).ns()); } } } else if (o instanceof UID) { namespaces.add(((UID) o).ns()); } return null; }
/** * Converts the given expression to lower(expression) * * <p>Constants are lower()ed at creation time</p> * * @param stringExpression the string to lower() * @return lower(stringExpression) */ public static Expression<String> toLower(Expression<String> stringExpression) { if (stringExpression instanceof Constant) { Constant<String> constantExpression = (Constant<String>) stringExpression; return ConstantImpl.create(constantExpression.getConstant().toLowerCase(Locale.ENGLISH)); } else { return operation(String.class, Ops.LOWER, stringExpression); } }
protected DBRef asReference(Operation<?> expr, int constIndex) { return asReference(((Constant<?>)expr.getArg(constIndex)).getConstant()); }
@Override protected void visitOperation(Class<?> type, Operator<?> operator, List<? extends Expression<?>> args) { if (Ops.aggOps.contains(operator)) { throw new UnsupportedOperationException("Aggregation operators are only supported as single expressions"); } if (args.size() == 2 && OPERATOR_SYMBOLS.containsKey(operator) && isPrimitive(args.get(0).getType()) && isPrimitive(args.get(1).getType())) { handle(args.get(0)); append(OPERATOR_SYMBOLS.get(operator)); handle(args.get(1)); if (args.get(1) instanceof Constant) { append(CAST_SUFFIXES.get(args.get(1).getType())); } return; } if (operator == Ops.STRING_CAST) { visitCast(operator, args.get(0), String.class); } else if (operator == Ops.NUMCAST) { visitCast(operator, args.get(0), (Class<?>) ((Constant<?>) args.get(1)).getConstant()); } else { super.visitOperation(type, operator, args); } }
@Override public Void visit(Constant<?> expr, Void context) { boolean wrap = templates.wrapConstant(expr); if (wrap) { append("("); } append(":"); if (!getConstantToLabel().containsKey(expr.getConstant())) { String constLabel = getConstantPrefix() + (getConstantToLabel().size()+1); getConstantToLabel().put(expr.getConstant(), constLabel); append(constLabel); } else { append(getConstantToLabel().get(expr.getConstant())); } if (wrap) { append(")"); } return null; }
protected void appendAsString(Expression<?> expr) { Object constant; if (expr instanceof Constant<?>) { constant = ((Constant<?>) expr).getConstant(); } else if (expr instanceof ParamExpression<?> && metadata != null) { if (metadata.getParams().containsKey(expr)) { constant = metadata.getParams().get(expr); } else { constant = ((ParamExpression<?>) expr).getName(); } } else { constant = expr.toString(); } if (constant instanceof NODE) { append(((NODE) constant).getValue()); } else { append(constant.toString()); } }
@Override public Var visit(Constant<?> expr, QueryMetadata md) { Var var = constantToVar.get(expr); if (NODE.class.isAssignableFrom(expr.getType())) { var = new Var(varNames.next(), dialect.getNode((NODE) expr.getConstant())); } else if (expr.getType().equals(String.class)) { var = new Var(varNames.next(), dialect.getNode(new LIT(expr.getConstant().toString()))); } else { UID datatype = ConverterRegistryImpl.DEFAULT.getDatatype(expr.getType()); String value = ConverterRegistryImpl.DEFAULT.toString(expr.getConstant()); var = new Var(varNames.next(), dialect.getNode(new LIT(value, datatype))); } return var; }
public Object arg(com.mysema.query.types.Expression expression) { if (expression instanceof Constant) return ((Constant)expression).getConstant(); else if (expression instanceof ParamExpression) return param( ( (ParamExpression) expression ).getName() ); else if (expression instanceof Path) { Path path = (Path) expression; return identifier( path.getRoot()).string( path.getMetadata().getExpression().toString() ); } else throw new IllegalArgumentException("Unknown argument type:"+expression); } }, null ));
@SuppressWarnings("unchecked") protected Query eq(Operation<?> operation, QueryMetadata metadata, boolean ignoreCase) { verifyArguments(operation); Path<?> path = getPath(operation.getArg(0)); String field = toField(path); if (Number.class.isAssignableFrom(operation.getArg(1).getType())) { return new TermQuery(new Term(field, convertNumber(((Constant<Number>) operation .getArg(1)).getConstant()))); } return eq(field, convert(path, operation.getArg(1), metadata), ignoreCase); }
@Override public Var visit(Constant<?> expr, QueryMetadata md) { Var var = constantToVar.get(expr); if (var == null) { if (NODE.class.isAssignableFrom(expr.getType())) { var = new Var(varNames.next(), dialect.getNode((NODE) expr.getConstant())); } else if (expr.getType().equals(String.class)) { var = new Var(varNames.next(), dialect.getNode(new LIT(expr.getConstant().toString()))); } else { UID datatype = ConverterRegistryImpl.DEFAULT.getDatatype(expr.getType()); String value = ConverterRegistryImpl.DEFAULT.toString(expr.getConstant()); var = new Var(varNames.next(), dialect.getNode(new LIT(value, datatype))); } var.setAnonymous(true); constantToVar.put(expr, var); } return var; }
@Override public Var visit(Constant<?> expr, QueryMetadata md) { Var var = constantToVar.get(expr); if (var == null){ if (NODE.class.isAssignableFrom(expr.getType())){ var = new Var(varNames.next(), dialect.getNode((NODE)expr.getConstant())); }else if (expr.getType().equals(String.class)){ var = new Var(varNames.next(), dialect.getNode(new LIT(expr.getConstant().toString()))); }else{ UID datatype = ConverterRegistryImpl.DEFAULT.getDatatype(expr.getType()); String value = ConverterRegistryImpl.DEFAULT.toString(expr.getConstant()); var = new Var(varNames.next(), dialect.getNode(new LIT(value, datatype))); } var.setAnonymous(true); constantToVar.put(expr, var); } return var; }
protected Query in(Operation<?> operation, QueryMetadata metadata, boolean ignoreCase) { Path<?> path = getPath(operation.getArg(0)); String field = toField(path); Collection<?> values = (Collection<?>) ((Constant<?>) operation.getArg(1)).getConstant(); BooleanQuery bq = new BooleanQuery(); for (Object value : values) { String[] str = convert(path, value); bq.add(eq(field, str, ignoreCase), Occur.SHOULD); } return bq; }