How to use

createIndexConditions

method

in

org.h2.expression.Expression

@Override
public void createIndexConditions(Session session, TableFilter filter) {
  if (andOrType == AND) {
    left.createIndexConditions(session, filter);
    right.createIndexConditions(session, filter);
  }
}

/**
 * Map the columns and add the join condition.
 *
 * @param on the condition
 */
public void mapAndAddFilter(Expression on) {
  on.mapColumns(this, 0);
  addFilterCondition(on, true);
  on.createIndexConditions(session, this);
  if (nestedJoin != null) {
    on.mapColumns(nestedJoin, 0);
    on.createIndexConditions(session, nestedJoin);
  }
  if (join != null) {
    join.mapAndAddFilter(on);
  }
}

@Override
public void prepare() {
  if (condition != null) {
    condition.mapColumns(targetTableFilter, 0);
    condition = condition.optimize(session);
    condition.createIndexConditions(session, targetTableFilter);
  }
  for (Column c : columns) {
    Expression e = expressionMap.get(c);
    e.mapColumns(targetTableFilter, 0);
    if (sourceTableFilter!=null){
      e.mapColumns(sourceTableFilter, 0);
    }
    expressionMap.put(c, e.optimize(session));
  }
  TableFilter[] filters;
  if(sourceTableFilter==null){
    filters = new TableFilter[] { targetTableFilter };
  }
  else{
    filters = new TableFilter[] { targetTableFilter, sourceTableFilter };
  }
  PlanItem item = targetTableFilter.getBestPlanItem(session, filters, 0,
      ExpressionVisitor.allColumnsForTableFilters(filters));
  targetTableFilter.setPlanItem(item);
  targetTableFilter.prepare();
}

@Override
public void prepare() {
  if (condition != null) {
    condition.mapColumns(targetTableFilter, 0);
    if (sourceTableFilter != null) {
      condition.mapColumns(sourceTableFilter, 0);
    }
    condition = condition.optimize(session);
    condition.createIndexConditions(session, targetTableFilter);
  }
  TableFilter[] filters;
  if (sourceTableFilter == null) {
    filters = new TableFilter[] { targetTableFilter };
  } else {
    filters = new TableFilter[] { targetTableFilter, sourceTableFilter };
  }
  PlanItem item = targetTableFilter.getBestPlanItem(session, filters, 0,
      ExpressionVisitor.allColumnsForTableFilters(filters));
  targetTableFilter.setPlanItem(item);
  targetTableFilter.prepare();
}

onCondition.createIndexConditions(session, sourceTableFilter);
onCondition.createIndexConditions(session, targetTableFilter);
targetMatchCondition.mapColumns(sourceTableFilter, 2);
targetMatchCondition = targetMatchCondition.optimize(session);
targetMatchCondition.createIndexConditions(session, sourceTableFilter);
targetMatchQuery.prepare();

condition.createIndexConditions(session, f);

@Override
public void createIndexConditions(Session session, TableFilter filter) {
  if (andOrType == AND) {
    left.createIndexConditions(session, filter);
    right.createIndexConditions(session, filter);
  }
}

public void createIndexConditions(Session session, TableFilter filter) throws SQLException {
  if (andOrType == AND) {
    left.createIndexConditions(session, filter);
    right.createIndexConditions(session, filter);
  }
}

@Override
public void createIndexConditions(Session session, TableFilter filter) {
  if (andOrType == AND) {
    left.createIndexConditions(session, filter);
    right.createIndexConditions(session, filter);
  }
}

/**
 * Map the columns and add the join condition.
 *
 * @param on the condition
 */
public void mapAndAddFilter(Expression on) {
  on.mapColumns(this, 0);
  addFilterCondition(on, true);
  on.createIndexConditions(session, this);
  if (nestedJoin != null) {
    on.mapColumns(nestedJoin, 0);
    on.createIndexConditions(session, nestedJoin);
  }
  if (join != null) {
    join.mapAndAddFilter(on);
  }
}

/**
 * Map the columns and add the join condition.
 *
 * @param on the condition
 */
public void mapAndAddFilter(Expression on) {
  on.mapColumns(this, 0);
  addFilterCondition(on, true);
  on.createIndexConditions(session, this);
  if (nestedJoin != null) {
    on.mapColumns(nestedJoin, 0);
    on.createIndexConditions(session, nestedJoin);
  }
  if (join != null) {
    join.mapAndAddFilter(on);
  }
}

private void mapAndAddFilter(Expression on) throws SQLException {
  on.mapColumns(this, 0);
  addFilterCondition(on, true);
  on.createIndexConditions(session, this);
  if (join != null) {
    join.mapAndAddFilter(on);
  }
}

@Override
public void prepare() {
  if (condition != null) {
    condition.mapColumns(tableFilter, 0);
    condition = condition.optimize(session);
    condition.createIndexConditions(session, tableFilter);
  }
  for (int i = 0, size = columns.size(); i < size; i++) {
    Column c = columns.get(i);
    Expression e = expressionMap.get(c);
    e.mapColumns(tableFilter, 0);
    expressionMap.put(c, e.optimize(session));
  }
  TableFilter[] filters = new TableFilter[] { tableFilter };
  PlanItem item = tableFilter.getBestPlanItem(session, filters, 0,
      ExpressionVisitor.allColumnsForTableFilters(filters));
  tableFilter.setPlanItem(item);
  tableFilter.prepare();
}

@Override
public void prepare() {
  if (condition != null) {
    condition.mapColumns(tableFilter, 0);
    condition = condition.optimize(session);
    condition.createIndexConditions(session, tableFilter);
  }
  for (int i = 0, size = columns.size(); i < size; i++) {
    Column c = columns.get(i);
    Expression e = expressionMap.get(c);
    e.mapColumns(tableFilter, 0);
    expressionMap.put(c, e.optimize(session));
  }
  TableFilter[] filters = new TableFilter[] { tableFilter };
  PlanItem item = tableFilter.getBestPlanItem(session, filters, 0,
      ExpressionVisitor.allColumnsForTableFilters(filters));
  tableFilter.setPlanItem(item);
  tableFilter.prepare();
}

public void prepare() throws SQLException {
  if (condition != null) {
    condition.mapColumns(tableFilter, 0);
    condition = condition.optimize(session);
    condition.createIndexConditions(session, tableFilter);
  }
  PlanItem item = tableFilter.getBestPlanItem(session);
  tableFilter.setPlanItem(item);
  tableFilter.prepare();
}

@Override
public void prepare() {
  if (condition != null) {
    condition.mapColumns(tableFilter, 0);
    condition = condition.optimize(session);
    condition.createIndexConditions(session, tableFilter);
  }
  TableFilter[] filters = new TableFilter[] { tableFilter };
  PlanItem item = tableFilter.getBestPlanItem(session, filters, 0,
      ExpressionVisitor.allColumnsForTableFilters(filters));
  tableFilter.setPlanItem(item);
  tableFilter.prepare();
}

@Override
public void prepare() {
  if (condition != null) {
    condition.mapColumns(tableFilter, 0);
    condition = condition.optimize(session);
    condition.createIndexConditions(session, tableFilter);
  }
  TableFilter[] filters = new TableFilter[] { tableFilter };
  PlanItem item = tableFilter.getBestPlanItem(session, filters, 0,
      ExpressionVisitor.allColumnsForTableFilters(filters));
  tableFilter.setPlanItem(item);
  tableFilter.prepare();
}

public void prepare() throws SQLException {
  if (condition != null) {
    condition.mapColumns(tableFilter, 0);
    condition = condition.optimize(session);
    condition.createIndexConditions(session, tableFilter);
  }
  for (int i = 0; i < expressions.length; i++) {
    Expression expr = expressions[i];
    if (expr != null) {
      expr.mapColumns(tableFilter, 0);
      expressions[i] = expr.optimize(session);
    }
  }
  PlanItem item = tableFilter.getBestPlanItem(session);
  tableFilter.setPlanItem(item);
  tableFilter.prepare();
}

public Expression optimizeInJoin(Session session, Select select) throws SQLException {
  if (all || compareType != Comparison.EQUAL) {
    return this;
  }
  if (!query.isEverything(ExpressionVisitor.EVALUATABLE)) {
    return this;
  }
  String alias = query.getFirstColumnAlias(session);
  query.setDistinct(true);
  if (alias == null) {
    return this;
  }
  TableView view = TableView.createTempView(session, session.getUser(), query);
  TableFilter filter = new TableFilter(session, view, view.getName(), false, select);
  select.addTableFilter(filter, true);
  ExpressionColumn column = new ExpressionColumn(session.getDatabase(), null, view.getName(), alias);
  Expression on = new Comparison(session, Comparison.EQUAL, left, column);
  on.mapColumns(filter, 0);
  on.createIndexConditions(session, filter);
  filter.addFilterCondition(on, true);
  return ValueExpression.get(ValueBoolean.get(true));
}

condition.createIndexConditions(session, f);