@Override public String visit(Constant<?> e, Templates templates) { return e.getConstant().toString(); }
@Override public Object visit(Constant<?> expr, Void context) { if (Enum.class.isAssignableFrom(expr.getType())) { return ((Enum<?>)expr.getConstant()).name(); } else { return expr.getConstant(); } }
public boolean wrapConstant(Constant<?> expr) { Class<?> type = expr.asExpr().getType(); return type.isArray() || Collection.class.isAssignableFrom(type); }
@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; }
@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 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 Integer visit(Constant<?> expr, Void context) { return expr.getConstant().hashCode(); }
@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; }
@Override public final Void visit(Constant<?> expr, Void context) { visitConstant(expr.getConstant()); return null; }
@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 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; }
@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; }
@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); }
public Expression<?> visit(Constant<?> constant, Filters filters) { Object javaValue = constant.getConstant(); ConverterRegistry converter = configuration.getConverterRegistry(); if (List.class.isAssignableFrom(constant.getType()) && ((List<?>) constant.getConstant()).isEmpty()) { return new ConstantImpl<UID>(RDF.nil); } else if (NODE.class.isAssignableFrom(constant.getType())) { return constant; } else if (javaValue instanceof Class<?>) { UID datatype = converter.getDatatype((Class<?>) javaValue); if (datatype != null) { return new ConstantImpl<UID>(datatype); } else { return new ConstantImpl<UID>(getTypeForDomainClass((Class<?>) javaValue)); } } else if (javaValue instanceof String) { return new ConstantImpl<LIT>(new LIT(javaValue.toString(), XSD.stringType)); } else if (converter.supports(javaValue.getClass())) { String label = converter.toString(javaValue); UID datatype = converter.getDatatype(javaValue.getClass()); return new ConstantImpl<LIT>(new LIT(label, datatype)); } else { ID id = session.getId(javaValue); return new ConstantImpl<ID>(id); } }
@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()); }
if (operator == Ops.IN && inToOr) { BooleanBuilder builder = new BooleanBuilder(); for (Object arg : ((Constant<Collection>)args.get(1)).getConstant()) { builder.or(ExpressionUtils.eq(args.get(0), new ConstantImpl(arg))); String value = ((Constant<LIT>) args.get(1)).getConstant().getValue().replace("%", ".*").replace("_", "."); args = Arrays.asList(args.get(0), new ConstantImpl<LIT>(LIT.class, new LIT(value))); } else if (REGEX_OPS.contains(operator) && args.get(1) instanceof Constant && ((Constant) args.get(1)).getConstant() instanceof LIT) { args = Arrays.<Expression<?>> asList(args.get(0), new ConstantImpl(((Constant<LIT>) args.get(1)).getConstant().getValue())); UID datatype = (UID) ((Constant<?>) args.get(1)).getConstant(); append("xsd:" + datatype.ln() + "("); handle(args.get(0));
@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); } }
/** * 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()); } }