How to use

Constant

in

com.mysema.query.types

@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());
  }
}