public DropView(Session session, Schema schema) { super(session, schema); dropAction = session.getDatabase().getSettings().dropRestrict ? AlterTableAddConstraint.RESTRICT : AlterTableAddConstraint.CASCADE; }
public Parser(Session session) { this.database = session.getDatabase(); this.identifiersToUpper = database.getSettings().databaseToUpper; this.session = session; }
public DropTable(Session session, Schema schema) { super(session, schema); dropAction = session.getDatabase().getSettings().dropRestrict ? AlterTableAddConstraint.RESTRICT : AlterTableAddConstraint.CASCADE; }
public CompareLike(Database db, Expression left, Expression right, Expression escape, boolean regexp) { this(db.getCompareMode(), db.getSettings().defaultEscape, left, right, escape, regexp); }
public Session(Database database, User user, int id) { this.id = id; this.user = user; this.database = database; this.queryTimeout = database.getSettings().defaultQueryTimeout; this.queryCacheSize = database.getSettings().queryCacheSize; this.currentSchemaName = Constants.SCHEMA_MAIN; this.transaction = database.getRepository().newTransaction(this); this.workerHolder = new WorkerFactoryProxy(this); }
@Override public Column getRowIdColumn() { if (session.getDatabase().getSettings().rowId) { return table.getRowIdColumn(); } return null; }
private Column parseColumn(Table table) { String id = readColumnIdentifier(); if (database.getSettings().rowId && Column.ROWID.equals(id)) { return table.getRowIdColumn(); } return table.getColumn(id); }
private Value getMax(Value a, Value b, boolean bigger) { if (a == null) { return b; } else if (b == null) { return a; } if (session.getDatabase().getSettings().optimizeIsNull) { // IS NULL must be checked later if (a == ValueNull.INSTANCE) { return b; } else if (b == ValueNull.INSTANCE) { return a; } } int comp = a.compareTo(b, table.getDatabase().getCompareMode()); if (comp == 0) { return a; } if (a == ValueNull.INSTANCE || b == ValueNull.INSTANCE) { if (session.getDatabase().getSettings().optimizeIsNull) { // column IS NULL AND column <op> <not null> is always false return null; } } if (!bigger) { comp = -comp; } return comp > 0 ? a : b; }
@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) { filter.addIndexCondition(IndexCondition.getInList(l, valueList)); return; } }
@Override public String getSQL() { String sql; boolean quote = database.getSettings().databaseToUpper; if (column != null) { sql = column.getSQL(); } else { sql = quote ? Parser.quoteIdentifier(columnName) : columnName; } if (tableAlias != null) { String a = quote ? Parser.quoteIdentifier(tableAlias) : tableAlias; sql = a + "." + sql; } if (schemaName != null) { String s = quote ? Parser.quoteIdentifier(schemaName) : schemaName; sql = s + "." + sql; } return sql; }
/** * Get an instance of the given function for this database. * If no function with this name is found, null is returned. * * @param database the database * @param name the function name * @return the function object or null */ public static Function getFunction(Database database, String name) { if (!database.getSettings().databaseToUpper) { // if not yet converted to uppercase, do it now name = StringUtils.toUpperEnglish(name); } FunctionInfo info = getFunctionInfo(name); if (info == null) { return null; } switch (info.type) { case TABLE: case TABLE_DISTINCT: return new TableFunction(database, info, Long.MAX_VALUE); default: return new Function(database, info); } }
public ConnectionHolder(Session session) { Database database = session.getDatabase(); JdbcRepository repository = (JdbcRepository) database.getRepository(); this.session = session; this.trace = database.getTrace(Trace.TRANSACTION); this.target = repository.getConnectionProvider(); String mode = database.getSettings().transactionMode; this.holderStrategy = transactionMode(mode); connectionMap = New.concurrentHashMap(); }
@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)); }
@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; } }
/** * Remove all index conditions that can not be used. */ public void removeUnusableIndexConditions() { for (int i = 0; i < allFilters.length; i++) { TableFilter f = allFilters[i]; setEvaluatable(f, true); if (i < allFilters.length - 1 || f.getSession().getDatabase().getSettings().earlyFilter) { // the last table doesn't need the optimization, // otherwise the expression is calculated twice unnecessarily // (not that bad but not optimal) f.optimizeFullCondition(false); } f.removeUnusableIndexConditions(); } for (TableFilter f : allFilters) { setEvaluatable(f, false); } }
private void setEvaluatable(TableFilter join) { if (session.getDatabase().getSettings().nestedJoins) { setEvaluatable(true); return; } // this table filter is now evaluatable - in all sub-joins do { Expression e = join.getJoinCondition(); if (e != null) { e.setEvaluatable(this, true); } TableFilter n = join.getNestedJoin(); if (n != null) { setEvaluatable(n); } join = join.getJoin(); } while (join != null); }
private Cursor find(TableMate tableMate) { try { tableFilter.setEvaluatable(false); ConditionExtractor extractor = new ConditionExtractor(tableFilter); this.alwaysFalse = extractor.isAlwaysFalse(); if (extractor.isAlwaysFalse()) { return this; } RoutingResult result = doRoute(tableMate, extractor); ObjectNode[] selectNodes = result.getSelectNodes(); if (session.getDatabase().getSettings().optimizeMerging) { selectNodes = result.group(); } List<QueryWorker> workers = New.arrayList(selectNodes.length); for (ObjectNode objectNode : selectNodes) { QueryWorker worker = queryHandlerFactory.createQueryWorker(searchColumns, tableFilter, objectNode); workers.add(worker); } return invokeQueryWorker(workers); } finally { tableFilter.setEvaluatable(true); } }
if (database.getSettings().rowId) { if (Column.ROWID.equals(columnName)) { return filter.getRowIdColumn();
if (database.getSettings().nestedJoins) { if (visitor.getQueryLevel() < this.queryLevel) { return true;
return l; if (!session.getDatabase().getSettings().optimizeInSelect) { return getValueSlow(rows, l);