How to use

ExpressionColumn

in

org.h2.expression

private Index getMinMaxColumnIndex() {
  if (on instanceof ExpressionColumn) {
    ExpressionColumn col = (ExpressionColumn) on;
    Column column = col.getColumn();
    TableFilter filter = col.getTableFilter();
    if (filter != null) {
      Table table = filter.getTable();
      return table.getIndexForColumn(column, true, false);
    }
  }
  return null;
}

String tableAlias = exprCol.getOriginalTableAliasName();
String col = exprCol.getOriginalColumnName();
for (int j = 0; j < visible; j++) {
  boolean found = false;
    found = db.equalsIdentifiers(col, c.getColumnName());
    if (found && tableAlias != null) {
      String ca = c.getOriginalTableAliasName();
      if (ca == null) {
        found = false;
    if (ec2 instanceof ExpressionColumn) {
      ExpressionColumn c2 = (ExpressionColumn) ec2;
      String ta = exprCol.getSQL();
      String tb = c2.getSQL();
      String s2 = c2.getColumnName();
      found = db.equalsIdentifiers(col, s2);
      if (!db.equalsIdentifiers(ta, tb)) {

private LocalResult createResult() {
  Expression[] expressions = { new ExpressionColumn(
      session.getDatabase(), new Column("SCRIPT", Value.STRING)) };
  return new LocalResult(session, expressions, 1);
}

ExpressionColumn expr = (ExpressionColumn) p
    .parseExpression(tab);
String schemaName = expr.getOriginalTableAliasName();
String tableName = expr.getColumnName();
q = q.substring(idx + " WHERE ".length());
Object[][] columnData = parseKey(conn, q);

ExpressionColumn expCol = (ExpressionColumn)expression;
return new GridSqlColumn(expCol.getColumn(),
  parseTableFilter(expCol.getTableFilter()),
  SCHEMA_NAME.get(expCol),
  expCol.getOriginalTableAliasName(),
  expCol.getColumnName());

if (e instanceof ExpressionColumn) {
  ExpressionColumn exprCol = (ExpressionColumn) e;
  String alias = exprCol.getOriginalAliasName();
  String col = exprCol.getOriginalColumnName();
  for (int j = 0; j < visible; j++) {
    boolean found = false;
    if (ec instanceof ExpressionColumn) {
      ExpressionColumn c = (ExpressionColumn) ec;
      found = col.equals(c.getColumnName());
      if (alias != null && found) {
        String ca = c.getOriginalAliasName();
        if (ca != null) {
          found = alias.equals(ca);
      if (ec2 instanceof ExpressionColumn) {
        ExpressionColumn c2 = (ExpressionColumn) ec2;
        String ta = exprCol.getSQL(); // exprCol.getTableAlias();
        String tb = c2.getSQL(); // getTableAlias();
        found = col.equals(c2.getColumnName());
        if (ta == null || tb == null) {
          if (ta != tb) {

@Override
public void createIndexConditions(Session session, TableFilter filter) {
  if (!(left instanceof ExpressionColumn)) {
    return;
  }
  ExpressionColumn l = (ExpressionColumn) left;
  if (filter != l.getTableFilter()) {
    return;
  }
  filter.addIndexCondition(IndexCondition.getInList(l, new ParameterList(parameter)));
}

for (TableFilter f : filters) {
  while (f != null) {
    leftCol.mapColumns(f, 0);
    rightCol.mapColumns(f, 0);
    f = f.getJoin();
TableFilter leftFilter = leftCol.getTableFilter();
TableFilter rightFilter = rightCol.getTableFilter();
r = new Comparison(session, compareType, r, right);
if (leftFilter != null && rightFilter != null) {

/**
 * @param compareType the comparison type, see constants in
 *            {@link Comparison}
 */
private IndexCondition(int compareType, ExpressionColumn column,
    Expression expression) {
  this.compareType = compareType;
  this.column = column == null ? null : column.getColumn();
  this.expression = expression;
}

Expression condition = null;
for (Column column : indexedColumns) {
  ExpressionColumn expr = new ExpressionColumn(session.getDatabase(),
      table.getSchema().getName(), table.getName(),
      column.getName());
  for (int i = 0; i < columns.length; i++) {
    if (expr.getColumnName().equals(columns[i].getName())) {
      if (condition == null) {
        condition = new Comparison(session, Comparison.EQUAL, expr, row[i]);

@Override
public void updateAggregate(Session session) {
  Value now = columnResolver.getValue(column);
  Select select = columnResolver.getSelect();
  if (select == null) {
    throw DbException.get(ErrorCode.MUST_GROUP_BY_COLUMN_1, getSQL());
  }
  HashMap<Expression, Object> values = select.getCurrentGroup();
  if (values == null) {
    // this is a different level (the enclosing query)
    return;
  }
  Value v = (Value) values.get(this);
  if (v == null) {
    values.put(this, now);
  } else {
    if (!database.areEqual(now, v)) {
      throw DbException.get(ErrorCode.MUST_GROUP_BY_COLUMN_1, getSQL());
    }
  }
}

private static void addColumnData(ArrayList<String> columns,
    ArrayList<String> data, Expression expr) {
  if (expr instanceof ConditionAndOr) {
    ConditionAndOr and = (ConditionAndOr) expr;
    Expression left = and.getExpression(true);
    Expression right = and.getExpression(false);
    addColumnData(columns, data, left);
    addColumnData(columns, data, right);
  } else {
    Comparison comp = (Comparison) expr;
    ExpressionColumn ec = (ExpressionColumn) comp.getExpression(true);
    ValueExpression ev = (ValueExpression) comp.getExpression(false);
    String columnName = ec.getColumnName();
    columns.add(columnName);
    if (ev == null) {
      data.add(null);
    } else {
      data.add(ev.getValue(null).getString());
    }
  }
}

  mapColumn(resolver, col, level);
  return;
Column col = resolver.getRowIdColumn();
if (col != null) {
  mapColumn(resolver, col, level);
  return;
Column col = columns[i];
if (database.equalsIdentifiers(columnName, col.getName())) {
  mapColumn(resolver, col, level);
  return;

String tab = q.substring(0, idx);
ExpressionColumn expr = (ExpressionColumn) p.parseExpression(tab);
String schemaName = expr.getOriginalAliasName();
String tableName = expr.getColumnName();
q = q.substring(idx + " WHERE ".length());
Object[][] columnData = parseKey(conn, q);

ExpressionColumn expCol = (ExpressionColumn)expression;
return new GridSqlColumn(expCol.getColumn(),
  parseTableFilter(expCol.getTableFilter()),
  SCHEMA_NAME.get(expCol),
  expCol.getOriginalTableAliasName(),
  expCol.getColumnName());

if (expr instanceof ExpressionColumn) {
  ExpressionColumn seq = (ExpressionColumn) expr;
  schemaName = seq.getOriginalTableAliasName();
  if (schemaName == null) {
    schemaName = session.getCurrentSchemaName();
    sequenceName = sql;
  } else {
    sequenceName = seq.getColumnName();

@Override
public void createIndexConditions(Session session, TableFilter filter) {
  TableFilter tf = getTableFilter();
  if (filter == tf && column.getType() == Value.BOOLEAN) {
    IndexCondition cond = IndexCondition.get(
        Comparison.EQUAL, this, ValueExpression.get(
            ValueBoolean.TRUE));
    filter.addIndexCondition(cond);
  }
}

for (TableFilter f : filters) {
  while (f != null) {
    leftCol.mapColumns(f, 0);
    rightCol.mapColumns(f, 0);
    f = f.getJoin();
TableFilter leftFilter = leftCol.getTableFilter();
TableFilter rightFilter = rightCol.getTableFilter();
r = new Comparison(session, compareType, r, right);
if (leftFilter != null && rightFilter != null) {

.setColumn(((ExpressionColumn) left).getColumn());

private Expression prepareUpdateCondition(Index foundIndex) {
  Expression condition = null;
  for (Column column : foundIndex.getColumns()) {
    ExpressionColumn expr = new ExpressionColumn(session.getDatabase(),
        table.getSchema().getName(), table.getName(), column.getName());
    for (int i = 0; i < columns.length; i++) {
      if (expr.getColumnName().equals(columns[i].getName())) {
        if (condition == null) {
          condition = new Comparison(session, Comparison.EQUAL,
              expr, list.get(getCurrentRowNumber() - 1)[i++]);
        } else {
          condition = new ConditionAndOr(ConditionAndOr.AND, condition,
              new Comparison(session, Comparison.EQUAL,
              expr, list.get(0)[i++]));
        }
      }
    }
  }
  return condition;
}