How to use

isEverything

method

in

org.h2.expression.Expression

@Override
public boolean isEverything(ExpressionVisitor visitor) {
  for (Expression e : list) {
    if (!e.isEverything(visitor)) {
      return false;
    }
  }
  return true;
}

@Override
public boolean isEverything(ExpressionVisitor visitor) {
  return left.isEverything(visitor) &&
      (right == null || right.isEverything(visitor));
}

private boolean areAllValues(ExpressionVisitor visitor) {
  for (Expression e : valueList) {
    if (!e.isEverything(visitor)) {
      return false;
    }
  }
  return true;
}

@Override
public boolean isEverything(ExpressionVisitor visitor) {
  return left.isEverything(visitor) && right.isEverything(visitor)
      && (escape == null || escape.isEverything(visitor));
}

@Override
public boolean isReadOnly() {
  return expression.isEverything(ExpressionVisitor.READONLY_VISITOR);
}

@Override
public boolean isEverything(ExpressionVisitor visitor) {
  return expr.isEverything(visitor);
}

@Override
public boolean isEverything(ExpressionVisitor visitor) {
  return expr.isEverything(visitor);
}

@Override
public boolean isEverything(ExpressionVisitor visitor) {
  return left.isEverything(visitor) &&
      (right == null || right.isEverything(visitor));
}

@Override
public boolean isEverything(ExpressionVisitor visitor) {
  return condition.isEverything(visitor);
}

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

/**
 * Check if the expression can be evaluated.
 *
 * @return true if it can be evaluated
 */
public boolean isEvaluatable() {
  if (expression != null) {
    return expression
        .isEverything(ExpressionVisitor.EVALUATABLE_VISITOR);
  }
  if (expressionList != null) {
    for (Expression e : expressionList) {
      if (!e.isEverything(ExpressionVisitor.EVALUATABLE_VISITOR)) {
        return false;
      }
    }
    return true;
  }
  return expressionQuery
      .isEverything(ExpressionVisitor.EVALUATABLE_VISITOR);
}

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

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

/**
 * Add conditions to a table filter if they can be evaluated.
 *
 * @param filter the table filter
 * @param outerJoin if the expression is part of an outer join
 */
public void addFilterConditions(TableFilter filter, boolean outerJoin) {
  if (!addedToFilter && !outerJoin &&
      isEverything(ExpressionVisitor.EVALUATABLE_VISITOR)) {
    filter.addFilterCondition(this, false);
    addedToFilter = true;
  }
}

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

@Override
public HashSet<Column> getReferencedColumns(Table table) {
  HashSet<Column> columns = new HashSet<>();
  expr.isEverything(ExpressionVisitor.getColumnsVisitor(columns));
  for (Iterator<Column> it = columns.iterator(); it.hasNext();) {
    if (it.next().getTable() != table) {
      it.remove();
    }
  }
  return columns;
}

@Override
public boolean isEverything(ExpressionVisitor visitor) {
  switch (visitor.getType()) {
  case ExpressionVisitor.DETERMINISTIC:
    // TODO optimization: some functions are deterministic, but we don't
    // know (no setting for that)
  case ExpressionVisitor.OPTIMIZABLE_MIN_MAX_COUNT_ALL:
    // user defined aggregate functions can not be optimized
    return false;
  case ExpressionVisitor.GET_DEPENDENCIES:
    visitor.addDependency(userAggregate);
    break;
  default:
  }
  for (Expression e : args) {
    if (e != null && !e.isEverything(visitor)) {
      return false;
    }
  }
  return filterCondition == null || filterCondition.isEverything(visitor);
}

private static void checkDefaultReferencesTable(Table table, Expression defaultExpression) {
  if (defaultExpression == null) {
    return;
  }
  HashSet<DbObject> dependencies = new HashSet<>();
  ExpressionVisitor visitor = ExpressionVisitor
      .getDependenciesVisitor(dependencies);
  defaultExpression.isEverything(visitor);
  if (dependencies.contains(table)) {
    throw DbException.get(ErrorCode.COLUMN_IS_REFERENCED_1,
        defaultExpression.getSQL());
  }
}

private HashSet<Column> buildColumnListFromOnCondition(
    TableFilter anyTableFilter) {
  HashSet<Column> filteredColumns = new HashSet<>();
  HashSet<Column> columns = new HashSet<>();
  ExpressionVisitor visitor = ExpressionVisitor
      .getColumnsVisitor(columns);
  onCondition.isEverything(visitor);
  for (Column c : columns) {
    if (c != null && c.getTable() == anyTableFilter.getTable()) {
      filteredColumns.add(c);
    }
  }
  return filteredColumns;
}

@Override
public void createIndexConditions(Session session, TableFilter filter) {
  if (!(left instanceof ExpressionColumn)) {
    return;
  }
  ExpressionColumn l = (ExpressionColumn) left;
  if (filter != l.getTableFilter()) {
    return;
  }
  if (session.getDatabase().getSettings().optimizeInList) {
    ExpressionVisitor visitor = ExpressionVisitor.getNotFromResolverVisitor(filter);
    for (Expression e : valueList) {
      if (!e.isEverything(visitor)) {
        return;
      }
    }
    filter.addIndexCondition(IndexCondition.getInList(l, valueList));
  }
}