/** * Create a new visitor object to collect dependencies. * * @param dependencies the dependencies set * @return the new visitor */ public static ExpressionVisitor getDependenciesVisitor( HashSet<DbObject> dependencies) { return new ExpressionVisitor(GET_DEPENDENCIES, 0, dependencies, null, null, null, null); }
@Override public boolean isEverything(ExpressionVisitor visitor) { switch (visitor.getType()) { case ExpressionVisitor.EVALUATABLE: case ExpressionVisitor.NOT_FROM_RESOLVER: case ExpressionVisitor.GET_COLUMNS: case ExpressionVisitor.GET_AGGREGATE: return true; case ExpressionVisitor.DETERMINISTIC: case ExpressionVisitor.READONLY: case ExpressionVisitor.INDEPENDENT: case ExpressionVisitor.QUERY_COMPARABLE: return false; case ExpressionVisitor.GET_DEPENDENCIES: visitor.addDependency(sequence); return true; default: throw DbException.throwInternalError("type=" + visitor.getType()); } }
@Override public boolean isEverything(ExpressionVisitor visitor) { switch (visitor.getType()) { case ExpressionVisitor.READONLY: case ExpressionVisitor.DETERMINISTIC: return true; case ExpressionVisitor.INDEPENDENT: return this.queryLevel < visitor.getQueryLevel(); case ExpressionVisitor.EVALUATABLE: if (visitor.getQueryLevel() < this.queryLevel) { return true; return evaluatable || visitor.getQueryLevel() < this.queryLevel; case ExpressionVisitor.NOT_FROM_RESOLVER: return columnResolver != visitor.getResolver(); case ExpressionVisitor.GET_DEPENDENCIES: if (column != null) { visitor.addDependency(column.getTable()); visitor.addColumn(column); return true; default: throw DbException.throwInternalError("type=" + visitor.getType());
@Override public boolean isEverything(ExpressionVisitor visitor) { switch (visitor.getType()) { case ExpressionVisitor.DETERMINISTIC: { if (isForUpdate) { TableFilter f = filters.get(i); Table table = f.getTable(); visitor.addDependency(table); table.addDependencies(visitor.getDependencies()); ExpressionVisitor v2 = visitor.incrementQueryLevel(1); boolean result = true; for (int i = 0, size = expressions.size(); i < size; i++) {
/** * Visit the default expression, the check constraint, and the sequence (if * any). * * @param visitor the visitor * @return true if every visited expression returned true, or if there are * no expressions */ boolean isEverything(ExpressionVisitor visitor) { if (visitor.getType() == ExpressionVisitor.GET_DEPENDENCIES) { if (sequence != null) { visitor.getDependencies().add(sequence); } } if (defaultExpression != null && !defaultExpression.isEverything(visitor)) { return false; } return !(checkConstraint != null && !checkConstraint.isEverything(visitor)); }
@Override public boolean isEverything(ExpressionVisitor visitor) { if (visitor.getType() == ExpressionVisitor.GET_AGGREGATE) { visitor.addAggregate(this); } if (on != null && !on.isEverything(visitor)) { return false; } if (groupConcatSeparator != null && !groupConcatSeparator.isEverything(visitor)) { return false; } if (groupConcatOrderList != null) { for (int i = 0, size = groupConcatOrderList.size(); i < size; i++) { SelectOrderBy o = groupConcatOrderList.get(i); if (!o.expression.isEverything(visitor)) { return false; } } } return true; }
@Override public void createIndexConditions(Session session, TableFilter filter) { if (!session.getDatabase().getSettings().optimizeInList) { return; } if (!(left instanceof ExpressionColumn)) { return; } ExpressionColumn l = (ExpressionColumn) left; if (filter != l.getTableFilter()) { return; } ExpressionVisitor visitor = ExpressionVisitor.getNotFromResolverVisitor(filter); if (!query.isEverything(visitor)) { return; } filter.addIndexCondition(IndexCondition.getInQuery(l, query)); }
/** * Add all objects that this table depends on to the hash set. * * @param dependencies the current set of dependencies */ public void addDependencies(HashSet<DbObject> dependencies) { if (dependencies.contains(this)) { // avoid endless recursion return; } if (sequences != null) { for (Sequence s : sequences) { dependencies.add(s); } } ExpressionVisitor visitor = ExpressionVisitor .getDependenciesVisitor(dependencies); for (Column col : columns) { col.isEverything(visitor); } dependencies.add(this); }
protected void doPrepare() { searchColumns = tableFilter.getTable().getColumns(); Select select = tableFilter.getSelect(); if (select != null && tableFilter.isFromTableMate()) { HashSet<Column> columns = New.linkedHashSet(); select.isEverything(ExpressionVisitor.getColumnsVisitor(columns)); ArrayList<Column> selected = New.arrayList(10); for (Column column : columns) { if (table == column.getTable()) { selected.add(column); } } //product_category columns is empty null where visitor this sql //SELECT count(*) FROM product_category a LEFT JOIN (SELECT product_category_id, count(*) //c FROM product GROUP BY product_category_id) b ON a.product_category_id = b.product_category_id; if(!selected.isEmpty()) { searchColumns = selected.toArray(new Column[selected.size()]); } } }
expr.isEverything(ExpressionVisitor.getAggregateVisitor(aggregates));
@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)); return; } }
/** * Create a new visitor to check if no expression depends on the given * resolver. * * @param resolver the resolver * @return the new visitor */ static ExpressionVisitor getNotFromResolverVisitor(ColumnResolver resolver) { return new ExpressionVisitor(NOT_FROM_RESOLVER, 0, null, null, null, null,resolver); }
ExpressionVisitor.getNotFromResolverVisitor(filter); if (!left.isEverything(visitor)) { return; ExpressionVisitor.getNotFromResolverVisitor(filter); if (!right.isEverything(visitor)) { return;
/** * 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, aggregates, table, resolver); }
/** * 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); }
/** * Create a new visitor to get all referenced columns. * * @param columns the columns map * @return the new visitor */ public static ExpressionVisitor getAggregateVisitor(HashSet<Aggregate> aggregates) { return new ExpressionVisitor(GET_AGGREGATE, 0, null, null, aggregates, null, null); }