How to use org.h2.expression

@Override
public Expression getNotIfPossible(Session session) {
  return new Comparison(session, Comparison.EQUAL, this,
      ValueExpression.get(ValueBoolean.FALSE));
}

  @Override
  public Expression[] getExpressionColumns(Session session) {
    if (getType() == Value.ARRAY) {
      return getExpressionColumns(session, (ValueArray) getValue(session));
    }
    return super.getExpressionColumns(session);
  }
}

@Override
public Expression optimize(Session session) {
  left = left.optimize(session);
  if (left.isConstant() && left == ValueExpression.getNull()) {
    return left;
  }
  return this;
}

@Override
public Expression optimize(Session session) {
  boolean allConst = isDeterministic();
  for (int i = 0, len = args.length; i < len; i++) {
    Expression e = args[i].optimize(session);
    args[i] = e;
    allConst &= e.isConstant();
  }
  if (allConst) {
    return ValueExpression.get(getValue(session));
  }
  return this;
}

@Override
public Expression getNotIfPossible(Session session) {
  // (NOT (A OR B)): (NOT(A) AND NOT(B))
  // (NOT (A AND B)): (NOT(A) OR NOT(B))
  Expression l = left.getNotIfPossible(session);
  if (l == null) {
    l = new ConditionNot(left);
  }
  Expression r = right.getNotIfPossible(session);
  if (r == null) {
    r = new ConditionNot(right);
  }
  int reversed = andOrType == AND ? OR : AND;
  return new ConditionAndOr(reversed, l, r);
}

@Override
public int getDisplaySize() {
  return getExpression().getDisplaySize();
}

@Override
public int getScale() {
  return getExpression().getScale();
}

@Override
public long getPrecision() {
  return getExpression().getPrecision();
}

@Override
public int getType() {
  return getExpression().getType();
}

@Override
public void prepare() {
  expression = expression.optimize(session);
  expressions = new Expression[] { expression };
  isResultSet = expression.getType() == Value.RESULT_SET;
  if (isResultSet) {
    prepareAlways = true;
  }
}

@Override
public boolean isEverything(ExpressionVisitor visitor) {
  if (!left.isEverything(visitor)) {
    return false;
  }
  return areAllValues(visitor);
}

@Override
public void addFilterConditions(TableFilter filter, boolean outerJoin) {
  if (andOrType == AND) {
    left.addFilterConditions(filter, outerJoin);
    right.addFilterConditions(filter, outerJoin);
  } else {
    super.addFilterConditions(filter, outerJoin);
  }
}

  @Override
  public Expression[] getExpressionColumns(Session session) {
    return getExpression().getExpressionColumns(session);
  }
}

@Override
public String getSQL() {
  String sql;
  if (opType == OpType.NEGATE) {
    // don't remove the space, otherwise it might end up some thing like
    // --1 which is a line remark
    sql = "- " + left.getSQL();
  } else {
    // don't remove the space, otherwise it might end up some thing like
    // --1 which is a line remark
    sql = left.getSQL() + " " + getOperationToken() + " " + right.getSQL();
  }
  return "(" + sql + ")";
}

@Override
public String getSQL() {
  return '(' + left.getSQL() + " = ANY(" + parameter.getSQL() + "))";
}

@Override
public boolean isEverything(ExpressionVisitor visitor) {
  return left.isEverything(visitor) && parameter.isEverything(visitor);
}

/**
 * Create a new visitor to get all referenced columns.
 *
 * @param columns the columns map
 * @return the new visitor
 */
public static ExpressionVisitor getColumnsVisitor(HashSet<Column> columns) {
  return new ExpressionVisitor(GET_COLUMNS, 0, null, columns, null, null, null);
}

@Override
public Expression getNotIfPossible(Session session) {
  return new Comparison(session, Comparison.EQUAL, this,
      ValueExpression.get(ValueBoolean.FALSE));
}

/**
 * Increment or decrement the query level.
 *
 * @param offset 1 to increment, -1 to decrement
 * @return a clone of this expression visitor, with the changed query level
 */
public ExpressionVisitor incrementQueryLevel(int offset) {
  return new ExpressionVisitor(type, queryLevel + offset, dependencies,
      columns, table, resolver, maxDataModificationId);
}

@Override
public Expression getNotIfPossible(Session session) {
  return new Comparison(session, Comparison.EQUAL, this,
      ValueExpression.get(ValueBoolean.FALSE));
}