| /* Copyright (c) 2001-2010, The HSQL Development Group |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * |
| * Redistributions of source code must retain the above copyright notice, this |
| * list of conditions and the following disclaimer. |
| * |
| * Redistributions in binary form must reproduce the above copyright notice, |
| * this list of conditions and the following disclaimer in the documentation |
| * and/or other materials provided with the distribution. |
| * |
| * Neither the name of the HSQL Development Group nor the names of its |
| * contributors may be used to endorse or promote products derived from this |
| * software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG, |
| * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| |
| package org.hsqldb; |
| |
| import org.hsqldb.HsqlNameManager.HsqlName; |
| import org.hsqldb.HsqlNameManager.SimpleName; |
| import org.hsqldb.ParserDQL.CompileContext; |
| import org.hsqldb.RangeVariable.RangeIteratorRight; |
| import org.hsqldb.error.Error; |
| import org.hsqldb.error.ErrorCode; |
| import org.hsqldb.index.Index; |
| import org.hsqldb.lib.ArrayListIdentity; |
| import org.hsqldb.lib.ArrayUtil; |
| import org.hsqldb.lib.HashMappedList; |
| import org.hsqldb.lib.HashSet; |
| import org.hsqldb.lib.HsqlArrayList; |
| import org.hsqldb.lib.HsqlList; |
| import org.hsqldb.lib.IntValueHashMap; |
| import org.hsqldb.lib.OrderedHashSet; |
| import org.hsqldb.lib.OrderedIntHashSet; |
| import org.hsqldb.lib.Set; |
| import org.hsqldb.navigator.RangeIterator; |
| import org.hsqldb.navigator.RowSetNavigatorData; |
| import org.hsqldb.navigator.RowSetNavigatorDataTable; |
| import org.hsqldb.persist.PersistentStore; |
| import org.hsqldb.result.Result; |
| import org.hsqldb.result.ResultMetaData; |
| import org.hsqldb.result.ResultProperties; |
| import org.hsqldb.store.ValuePool; |
| import org.hsqldb.types.Type; |
| import org.hsqldb.types.Types; |
| |
| /** |
| * Implementation of an SQL query specification, including SELECT. |
| * |
| * @author Fred Toussi (fredt@users dot sourceforge.net) |
| * |
| * @version 2.0.0 |
| * @since 1.9.0 |
| */ |
| public class QuerySpecification extends QueryExpression { |
| |
| private final static int[] defaultLimits = new int[] { |
| 0, Integer.MAX_VALUE, Integer.MAX_VALUE |
| }; |
| |
| // |
| public int resultRangePosition; |
| public boolean isDistinctSelect; |
| public boolean isAggregated; |
| public boolean isGrouped; |
| RangeVariable[] rangeVariables; |
| private HsqlArrayList rangeVariableList; |
| Expression queryCondition; |
| Expression checkQueryCondition; |
| private Expression havingCondition; |
| Expression rowExpression; |
| Expression[] exprColumns; |
| private HsqlArrayList exprColumnList; |
| public int indexLimitVisible; |
| private int indexLimitRowId; |
| private int groupByColumnCount; // columns in 'group by' |
| private int havingColumnCount; // columns in 'having' (0 or 1) |
| private int indexStartHaving; |
| public int indexStartOrderBy; |
| public int indexStartAggregates; |
| private int indexLimitExpressions; |
| public int indexLimitData; |
| private boolean hasRowID; |
| private boolean isSimpleCount; |
| private boolean hasMemoryRow; |
| |
| // |
| public boolean isUniqueResultRows; |
| private boolean simpleLimit = true; // true if maxrows can be uses as is |
| |
| // |
| Type[] columnTypes; |
| private ArrayListIdentity aggregateSet; |
| |
| // |
| private ArrayListIdentity resolvedSubqueryExpressions = null; |
| |
| // |
| // |
| private boolean[] aggregateCheck; |
| |
| // |
| private OrderedHashSet tempSet = new OrderedHashSet(); |
| |
| // |
| int[] columnMap; |
| private Table baseTable; |
| private OrderedHashSet conditionTables; // for view super-view references |
| |
| // |
| public Index groupIndex; |
| |
| // |
| QuerySpecification(Session session, Table table, |
| CompileContext compileContext) { |
| |
| this(compileContext); |
| |
| RangeVariable range = new RangeVariable(table, null, null, null, |
| compileContext); |
| |
| range.addTableColumns(exprColumnList, 0, null); |
| |
| indexLimitVisible = exprColumnList.size(); |
| |
| addRangeVariable(range); |
| |
| isMergeable = false; |
| |
| resolveReferences(session); |
| resolveTypes(session); |
| |
| sortAndSlice = SortAndSlice.noSort; |
| } |
| |
| QuerySpecification(CompileContext compileContext) { |
| |
| super(compileContext); |
| |
| this.compileContext = compileContext; |
| resultRangePosition = compileContext.getNextRangeVarIndex(); |
| rangeVariableList = new HsqlArrayList(); |
| exprColumnList = new HsqlArrayList(); |
| sortAndSlice = SortAndSlice.noSort; |
| isMergeable = true; |
| } |
| |
| void addRangeVariable(RangeVariable rangeVar) { |
| rangeVariableList.add(rangeVar); |
| } |
| |
| // range variable sub queries are resolves fully |
| private void resolveRangeVariables(Session session) { |
| |
| if (rangeVariables == null |
| || rangeVariables.length < rangeVariableList.size()) { |
| rangeVariables = new RangeVariable[rangeVariableList.size()]; |
| |
| rangeVariableList.toArray(rangeVariables); |
| } |
| |
| for (int i = 0; i < rangeVariables.length; i++) { |
| rangeVariables[i].resolveRangeTable(session, rangeVariables, i); |
| } |
| } |
| |
| void addSelectColumnExpression(Expression e) { |
| |
| if (e.getType() == OpTypes.ROW) { |
| throw Error.error(ErrorCode.X_42564); |
| } |
| |
| if (indexLimitVisible > 0) { |
| if (e.opType == OpTypes.MULTICOLUMN) { |
| if (((ExpressionColumn) e).getTableName() == null) { |
| throw Error.error(ErrorCode.X_42578); |
| } |
| } |
| |
| Expression first = ((Expression) exprColumnList.get(0)); |
| |
| if (first.opType == OpTypes.MULTICOLUMN |
| && ((ExpressionColumn) first).getTableName() == null) { |
| throw Error.error(ErrorCode.X_42578); |
| } |
| } |
| |
| exprColumnList.add(e); |
| |
| indexLimitVisible++; |
| } |
| |
| void addQueryCondition(Expression e) { |
| queryCondition = e; |
| } |
| |
| void addGroupByColumnExpression(Expression e) { |
| |
| if (e.getType() == OpTypes.ROW) { |
| throw Error.error(ErrorCode.X_42564); |
| } |
| |
| exprColumnList.add(e); |
| |
| isGrouped = true; |
| |
| groupByColumnCount++; |
| } |
| |
| void addHavingExpression(Expression e) { |
| |
| exprColumnList.add(e); |
| |
| havingCondition = e; |
| havingColumnCount = 1; |
| } |
| |
| void addSortAndSlice(SortAndSlice sortAndSlice) { |
| this.sortAndSlice = sortAndSlice; |
| } |
| |
| public void resolveReferences(Session session) { |
| |
| resolveRangeVariables(session); |
| resolveColumnReferencesForAsterisk(); |
| finaliseColumns(); |
| resolveColumnReferences(); |
| |
| unionColumnTypes = new Type[indexLimitVisible]; |
| |
| setReferenceableColumns(); |
| } |
| |
| /** |
| * Resolves all column expressions in the GROUP BY clause and beyond. |
| * Replaces any alias column expression in the ORDER BY cluase |
| * with the actual select column expression. |
| */ |
| private void resolveColumnReferences() { |
| |
| if (isDistinctSelect || isGrouped) { |
| acceptsSequences = false; |
| } |
| |
| for (int i = 0; i < rangeVariables.length; i++) { |
| Expression e = rangeVariables[i].getJoinCondition(); |
| |
| if (e == null) { |
| continue; |
| } |
| |
| resolveColumnReferencesAndAllocate(e, i + 1, false); |
| } |
| |
| resolveColumnReferencesAndAllocate(queryCondition, |
| rangeVariables.length, false); |
| |
| if (resolvedSubqueryExpressions != null) { |
| |
| // subqueries in conditions not to be converted to SIMPLE_COLUMN |
| resolvedSubqueryExpressions.setSize(0); |
| } |
| |
| for (int i = 0; i < indexLimitVisible; i++) { |
| resolveColumnReferencesAndAllocate(exprColumns[i], |
| rangeVariables.length, |
| acceptsSequences); |
| } |
| |
| for (int i = indexLimitVisible; i < indexStartHaving; i++) { |
| exprColumns[i] = resolveColumnReferencesInGroupBy(exprColumns[i]); |
| } |
| |
| for (int i = indexStartHaving; i < indexStartOrderBy; i++) { |
| resolveColumnReferencesAndAllocate(exprColumns[i], |
| rangeVariables.length, false); |
| } |
| |
| resolveColumnRefernecesInOrderBy(sortAndSlice); |
| } |
| |
| void resolveColumnRefernecesInOrderBy(SortAndSlice sortAndSlice) { |
| |
| // replace the aliases with expressions |
| // replace column names with expressions and resolve the table columns |
| int orderCount = sortAndSlice.getOrderLength(); |
| |
| for (int i = 0; i < orderCount; i++) { |
| ExpressionOrderBy e = |
| (ExpressionOrderBy) sortAndSlice.exprList.get(i); |
| |
| replaceColumnIndexInOrderBy(e); |
| |
| if (e.getLeftNode().queryTableColumnIndex != -1) { |
| continue; |
| } |
| |
| if (sortAndSlice.sortUnion) { |
| if (e.getLeftNode().getType() != OpTypes.COLUMN) { |
| throw Error.error(ErrorCode.X_42576); |
| } |
| } |
| |
| e.replaceAliasInOrderBy(exprColumns, indexLimitVisible); |
| resolveColumnReferencesAndAllocate(e, rangeVariables.length, |
| false); |
| |
| if (isAggregated || isGrouped) { |
| boolean check = e.getLeftNode().isComposedOf(exprColumns, 0, |
| indexLimitVisible + groupByColumnCount, |
| Expression.aggregateFunctionSet); |
| |
| if (!check) { |
| throw Error.error(ErrorCode.X_42576); |
| } |
| } |
| } |
| |
| sortAndSlice.prepare(this); |
| } |
| |
| private boolean resolveColumnReferences(Expression e, int rangeCount, |
| boolean withSequences) { |
| |
| if (e == null) { |
| return true; |
| } |
| |
| int oldSize = unresolvedExpressions == null ? 0 |
| : unresolvedExpressions |
| .size(); |
| |
| unresolvedExpressions = e.resolveColumnReferences(rangeVariables, |
| rangeCount, unresolvedExpressions, withSequences); |
| |
| int newSize = unresolvedExpressions == null ? 0 |
| : unresolvedExpressions |
| .size(); |
| |
| return oldSize == newSize; |
| } |
| |
| private void resolveColumnReferencesForAsterisk() { |
| |
| for (int pos = 0; pos < indexLimitVisible; ) { |
| Expression e = (Expression) (exprColumnList.get(pos)); |
| |
| if (e.getType() == OpTypes.MULTICOLUMN) { |
| exprColumnList.remove(pos); |
| |
| String tablename = ((ExpressionColumn) e).getTableName(); |
| |
| if (tablename == null) { |
| addAllJoinedColumns(e); |
| } else { |
| int rangeIndex = |
| e.findMatchingRangeVariableIndex(rangeVariables); |
| |
| if (rangeIndex == -1) { |
| throw Error.error(ErrorCode.X_42501, tablename); |
| } |
| |
| RangeVariable range = rangeVariables[rangeIndex]; |
| HashSet exclude = getAllNamedJoinColumns(); |
| |
| range.addTableColumns(e, exclude); |
| } |
| |
| for (int i = 0; i < e.nodes.length; i++) { |
| exprColumnList.add(pos, e.nodes[i]); |
| |
| pos++; |
| } |
| |
| indexLimitVisible += e.nodes.length - 1; |
| } else { |
| pos++; |
| } |
| } |
| } |
| |
| private void resolveColumnReferencesAndAllocate(Expression expression, |
| int count, boolean withSequences) { |
| |
| if (expression == null) { |
| return; |
| } |
| |
| HsqlList list = expression.resolveColumnReferences(rangeVariables, |
| count, null, withSequences); |
| |
| if (list != null) { |
| for (int i = 0; i < list.size(); i++) { |
| Expression e = (Expression) list.get(i); |
| boolean resolved; |
| |
| if (e.isSelfAggregate()) { |
| resolved = resolveColumnReferences(e.getLeftNode(), count, |
| false); |
| } else { |
| resolved = resolveColumnReferences(e, count, |
| withSequences); |
| } |
| |
| if (resolved) { |
| if (e.isSelfAggregate()) { |
| if (aggregateSet == null) { |
| aggregateSet = new ArrayListIdentity(); |
| } |
| |
| aggregateSet.add(e); |
| |
| isAggregated = true; |
| |
| expression.setAggregate(); |
| } |
| |
| if (resolvedSubqueryExpressions == null) { |
| resolvedSubqueryExpressions = new ArrayListIdentity(); |
| } |
| |
| resolvedSubqueryExpressions.add(e); |
| } else { |
| if (unresolvedExpressions == null) { |
| unresolvedExpressions = new ArrayListIdentity(); |
| } |
| |
| unresolvedExpressions.add(e); |
| } |
| } |
| } |
| } |
| |
| private Expression resolveColumnReferencesInGroupBy( |
| Expression expression) { |
| |
| if (expression == null) { |
| return null; |
| } |
| |
| HsqlList list = expression.resolveColumnReferences(rangeVariables, |
| rangeVariables.length, null, false); |
| |
| if (list != null) { |
| |
| // if not resolved, resolve as simple alias |
| if (expression.getType() == OpTypes.COLUMN) { |
| Expression resolved = |
| expression.replaceAliasInOrderBy(exprColumns, |
| indexLimitVisible); |
| |
| if (resolved != expression) { |
| return resolved; |
| } |
| } |
| |
| // resolve and allocate to throw exception |
| resolveColumnReferencesAndAllocate(expression, |
| rangeVariables.length, false); |
| } |
| |
| return expression; |
| } |
| |
| private HashSet getAllNamedJoinColumns() { |
| |
| HashSet set = null; |
| |
| for (int i = 0; i < rangeVariableList.size(); i++) { |
| RangeVariable range = (RangeVariable) rangeVariableList.get(i); |
| |
| if (range.namedJoinColumns != null) { |
| if (set == null) { |
| set = new HashSet(); |
| } |
| |
| set.addAll(range.namedJoinColumns); |
| } |
| } |
| |
| return set; |
| } |
| |
| public Expression getEquiJoinExpressions(OrderedHashSet nameSet, |
| RangeVariable rightRange, boolean fullList) { |
| |
| HashSet set = new HashSet(); |
| Expression result = null; |
| OrderedHashSet joinColumnNames = new OrderedHashSet(); |
| |
| for (int i = 0; i < rangeVariableList.size(); i++) { |
| RangeVariable range = (RangeVariable) rangeVariableList.get(i); |
| HashMappedList columnList = range.rangeTable.columnList; |
| |
| for (int j = 0; j < columnList.size(); j++) { |
| ColumnSchema column = (ColumnSchema) columnList.get(j); |
| String name = range.getColumnAlias(j); |
| boolean columnInList = nameSet.contains(name); |
| boolean namedJoin = range.namedJoinColumns != null |
| && range.namedJoinColumns.contains(name); |
| boolean repeated = !namedJoin && !set.add(name); |
| |
| if (repeated && (!fullList || columnInList)) { |
| throw Error.error(ErrorCode.X_42578, name); |
| } |
| |
| if (!columnInList) { |
| continue; |
| } |
| |
| joinColumnNames.add(name); |
| |
| int leftPosition = |
| range.rangeTable.getColumnIndex(column.getNameString()); |
| int rightPosition = rightRange.rangeTable.getColumnIndex(name); |
| Expression e = new ExpressionLogical(range, leftPosition, |
| rightRange, |
| rightPosition); |
| |
| result = ExpressionLogical.andExpressions(result, e); |
| |
| ExpressionColumn col = range.getColumnExpression(name); |
| |
| if (col == null) { |
| col = new ExpressionColumn(new Expression[] { |
| e.getLeftNode(), e.getRightNode() |
| }, name); |
| |
| range.addNamedJoinColumnExpression(name, col); |
| } else { |
| col.nodes = (Expression[]) ArrayUtil.resizeArray(col.nodes, |
| col.nodes.length + 1); |
| col.nodes[col.nodes.length - 1] = e.getRightNode(); |
| } |
| |
| rightRange.addNamedJoinColumnExpression(name, col); |
| } |
| } |
| |
| if (fullList && !joinColumnNames.containsAll(nameSet)) { |
| throw Error.error(ErrorCode.X_42501); |
| } |
| |
| rightRange.addNamedJoinColumns(joinColumnNames); |
| |
| return result; |
| } |
| |
| private void addAllJoinedColumns(Expression e) { |
| |
| HsqlArrayList list = new HsqlArrayList(); |
| |
| for (int i = 0; i < rangeVariables.length; i++) { |
| rangeVariables[i].addTableColumns(list); |
| } |
| |
| Expression[] nodes = new Expression[list.size()]; |
| |
| list.toArray(nodes); |
| |
| e.nodes = nodes; |
| } |
| |
| private void finaliseColumns() { |
| |
| indexLimitRowId = indexLimitVisible; |
| indexStartHaving = indexLimitRowId + groupByColumnCount; |
| indexStartOrderBy = indexStartHaving + havingColumnCount; |
| indexStartAggregates = indexStartOrderBy |
| + sortAndSlice.getOrderLength(); |
| indexLimitData = indexLimitExpressions = indexStartAggregates; |
| exprColumns = new Expression[indexLimitExpressions]; |
| |
| exprColumnList.toArray(exprColumns); |
| |
| for (int i = 0; i < indexLimitVisible; i++) { |
| exprColumns[i].queryTableColumnIndex = i; |
| } |
| |
| if (sortAndSlice.hasOrder()) { |
| for (int i = 0; i < sortAndSlice.getOrderLength(); i++) { |
| exprColumns[indexStartOrderBy + i] = |
| (Expression) sortAndSlice.exprList.get(i); |
| } |
| } |
| |
| rowExpression = new Expression(OpTypes.ROW, exprColumns); |
| } |
| |
| private void replaceColumnIndexInOrderBy(Expression orderBy) { |
| |
| Expression e = orderBy.getLeftNode(); |
| |
| if (e.getType() != OpTypes.VALUE) { |
| return; |
| } |
| |
| if (e.getDataType().typeCode == Types.SQL_INTEGER) { |
| int i = ((Integer) e.getValue(null)).intValue(); |
| |
| if (0 < i && i <= indexLimitVisible) { |
| orderBy.setLeftNode(exprColumns[i - 1]); |
| |
| return; |
| } |
| } |
| |
| throw Error.error(ErrorCode.X_42576); |
| } |
| |
| void collectRangeVariables(RangeVariable[] rangeVars, Set set) { |
| |
| for (int i = 0; i < indexStartAggregates; i++) { |
| exprColumns[i].collectRangeVariables(rangeVars, set); |
| } |
| |
| if (queryCondition != null) { |
| queryCondition.collectRangeVariables(rangeVars, set); |
| } |
| |
| if (havingCondition != null) { |
| havingCondition.collectRangeVariables(rangeVars, set); |
| } |
| } |
| |
| public boolean hasReference(RangeVariable range) { |
| |
| if (unresolvedExpressions == null) { |
| return false; |
| } |
| |
| for (int i = 0; i < unresolvedExpressions.size(); i++) { |
| if (((Expression) unresolvedExpressions.get(i)).hasReference( |
| range)) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Sets the types of all the expressions used in this SELECT list. |
| */ |
| public void resolveExpressionTypes(Session session, Expression parent) { |
| |
| for (int i = 0; i < indexStartAggregates; i++) { |
| Expression e = exprColumns[i]; |
| |
| e.resolveTypes(session, parent); |
| |
| if (e.getType() == OpTypes.ROW) { |
| throw Error.error(ErrorCode.X_42564); |
| } |
| } |
| |
| for (int i = 0, len = rangeVariables.length; i < len; i++) { |
| Expression e = rangeVariables[i].getJoinCondition(); |
| |
| if (e != null) { |
| e.resolveTypes(session, null); |
| |
| if (e.getDataType() != Type.SQL_BOOLEAN) { |
| throw Error.error(ErrorCode.X_42568); |
| } |
| } |
| } |
| |
| if (queryCondition != null) { |
| queryCondition.resolveTypes(session, null); |
| |
| if (queryCondition.getDataType() != Type.SQL_BOOLEAN) { |
| throw Error.error(ErrorCode.X_42568); |
| } |
| } |
| |
| if (havingCondition != null) { |
| havingCondition.resolveTypes(session, null); |
| |
| if (havingCondition.getDataType() != Type.SQL_BOOLEAN) { |
| throw Error.error(ErrorCode.X_42568); |
| } |
| } |
| } |
| |
| private void resolveAggregates() { |
| |
| tempSet.clear(); |
| |
| if (isAggregated) { |
| aggregateCheck = new boolean[indexStartAggregates]; |
| |
| tempSet.addAll(aggregateSet); |
| |
| indexLimitData = indexLimitExpressions = exprColumns.length |
| + tempSet.size(); |
| exprColumns = (Expression[]) ArrayUtil.resizeArray(exprColumns, |
| indexLimitExpressions); |
| |
| for (int i = indexStartAggregates, j = 0; |
| i < indexLimitExpressions; i++, j++) { |
| Expression e = (Expression) tempSet.get(j); |
| |
| exprColumns[i] = e.duplicate(); |
| exprColumns[i].nodes = e.nodes; // keep original nodes |
| exprColumns[i].dataType = e.dataType; |
| } |
| |
| tempSet.clear(); |
| } |
| } |
| |
| public boolean areColumnsResolved() { |
| return unresolvedExpressions == null |
| || unresolvedExpressions.isEmpty(); |
| } |
| |
| private void setRangeVariableConditions(Session session) { |
| |
| RangeVariableResolver rangeResolver = |
| new RangeVariableResolver(rangeVariables, queryCondition, |
| compileContext); |
| |
| rangeResolver.processConditions(session); |
| |
| rangeVariables = rangeResolver.rangeVariables; |
| } |
| |
| public void resolveTypes(Session session) { |
| |
| if (isResolved) { |
| return; |
| } |
| |
| resolveTypesPartOne(session); |
| resolveTypesPartTwo(session); |
| ArrayUtil.copyArray(resultTable.colTypes, unionColumnTypes, |
| unionColumnTypes.length); |
| |
| for (int i = 0; i < indexStartHaving; i++) { |
| if (exprColumns[i].dataType == null) { |
| throw Error.error(ErrorCode.X_42567); |
| } |
| } |
| } |
| |
| void resolveTypesPartOne(Session session) { |
| |
| resolveExpressionTypes(session, rowExpression); |
| resolveAggregates(); |
| |
| for (int i = 0; i < unionColumnTypes.length; i++) { |
| unionColumnTypes[i] = Type.getAggregateType(unionColumnTypes[i], |
| exprColumns[i].getDataType()); |
| } |
| } |
| |
| void resolveTypesPartTwo(Session session) { |
| |
| resolveGroups(); |
| |
| for (int i = 0; i < unionColumnTypes.length; i++) { |
| Type type = unionColumnTypes[i]; |
| |
| if (type == null) { |
| throw Error.error(ErrorCode.X_42567); |
| } |
| |
| exprColumns[i].setDataType(session, type); |
| } |
| |
| for (int i = 0; i < indexStartHaving; i++) { |
| if (exprColumns[i].dataType == null) { |
| throw Error.error(ErrorCode.X_42567); |
| } |
| } |
| |
| checkLobUsage(); |
| setMergeability(); |
| setUpdatability(); |
| createResultMetaData(); |
| createTable(session); |
| |
| if (isMergeable) { |
| mergeQuery(); |
| } |
| |
| setRangeVariableConditions(session); |
| |
| if (isAggregated && !isGrouped && !sortAndSlice.hasOrder() |
| && !sortAndSlice.hasLimit() && aggregateSet.size() == 1 |
| && indexLimitVisible == 1) { |
| Expression e = exprColumns[indexStartAggregates]; |
| int opType = e.getType(); |
| |
| switch (opType) { |
| |
| case OpTypes.MAX : |
| case OpTypes.MIN : { |
| SortAndSlice slice = new SortAndSlice(); |
| |
| slice.isGenerated = true; |
| |
| slice.addLimitCondition(ExpressionOp.limitOneExpression); |
| |
| if (slice.prepareSpecial(session, this)) { |
| this.sortAndSlice = slice; |
| } |
| |
| break; |
| } |
| case OpTypes.COUNT : { |
| if (rangeVariables.length == 1 && queryCondition == null |
| && e.getLeftNode().getType() == OpTypes.ASTERISK) { |
| isSimpleCount = true; |
| } |
| } |
| } |
| } |
| |
| sortAndSlice.setSortRange(this); |
| |
| isResolved = true; |
| } |
| |
| void checkLobUsage() { |
| |
| if (!isDistinctSelect && !isGrouped) { |
| return; |
| } |
| |
| for (int i = 0; i < indexStartHaving; i++) { |
| if (exprColumns[i].dataType.isLobType()) { |
| throw Error.error(ErrorCode.X_42534); |
| } |
| } |
| } |
| |
| private void resolveGroups() { |
| |
| // - 1.9.0 is standard compliant but has more extended support for |
| // referencing columns |
| // - check there is no direct aggregate expression in group by |
| // - check each expression in select list can be |
| // decomposed into the expressions in group by or any aggregates |
| // this allows direct function of group by expressions, but |
| // doesn't allow indirect functions. e.g. |
| // select 2*abs(cola) , sum(colb) from t group by abs(cola) // ok |
| // select 2*(cola + 10) , sum(colb) from t group by cola + 10 // ok |
| // select abs(cola) , sum(colb) from t group by cola // ok |
| // select 2*cola + 20 , sum(colb) from t group by cola + 10 // not allowed although correct |
| // select cola , sum(colb) from t group by abs(cola) // not allowed because incorrect |
| // - group by can introduce invisible, derived columns into the query table |
| // - check the having expression can be decomposed into |
| // select list expresions plus group by expressions |
| // - having cannot introduce additional, derived columns |
| // - having cannot reference columns not in the select or group by list |
| // - if there is any aggregate in select list but no group by, no |
| // non-aggregates is allowed |
| // - check order by columns |
| // - if distinct select, order by must be composed of the select list columns |
| // - if grouped by, then order by should be decomposed into the |
| // select list plus group by list |
| // - references to column aliases are allowed only in order by (Standard |
| // compliance) and take precendence over references to non-alias |
| // column names. |
| // - references to table / correlation and column list in correlation |
| // names are handled according to the Standard |
| // fredt@users |
| tempSet.clear(); |
| |
| if (isGrouped) { |
| for (int i = indexLimitVisible; |
| i < indexLimitVisible + groupByColumnCount; i++) { |
| exprColumns[i].collectAllExpressions( |
| tempSet, Expression.aggregateFunctionSet, |
| Expression.subqueryExpressionSet); |
| |
| if (!tempSet.isEmpty()) { |
| throw Error.error(ErrorCode.X_42572, |
| ((Expression) tempSet.get(0)).getSQL()); |
| } |
| } |
| |
| for (int i = 0; i < indexLimitVisible; i++) { |
| if (!exprColumns[i].isComposedOf( |
| exprColumns, indexLimitVisible, |
| indexLimitVisible + groupByColumnCount, |
| Expression.subqueryAggregateExpressionSet)) { |
| tempSet.add(exprColumns[i]); |
| } |
| } |
| |
| if (!tempSet.isEmpty() && !resolveForGroupBy(tempSet)) { |
| throw Error.error(ErrorCode.X_42574, |
| ((Expression) tempSet.get(0)).getSQL()); |
| } |
| } else if (isAggregated) { |
| for (int i = 0; i < indexLimitVisible; i++) { |
| exprColumns[i].collectAllExpressions( |
| tempSet, Expression.columnExpressionSet, |
| Expression.aggregateFunctionSet); |
| |
| if (!tempSet.isEmpty()) { |
| throw Error.error(ErrorCode.X_42574, |
| ((Expression) tempSet.get(0)).getSQL()); |
| } |
| } |
| } |
| |
| tempSet.clear(); |
| |
| if (havingCondition != null) { |
| if (unresolvedExpressions != null) { |
| tempSet.addAll(unresolvedExpressions); |
| } |
| |
| for (int i = indexLimitVisible; |
| i < indexLimitVisible + groupByColumnCount; i++) { |
| tempSet.add(exprColumns[i]); |
| } |
| |
| if (!havingCondition.isComposedOf( |
| tempSet, Expression.subqueryAggregateExpressionSet)) { |
| throw Error.error(ErrorCode.X_42573); |
| } |
| |
| tempSet.clear(); |
| } |
| |
| if (isDistinctSelect) { |
| int orderCount = sortAndSlice.getOrderLength(); |
| |
| for (int i = 0; i < orderCount; i++) { |
| Expression e = (Expression) sortAndSlice.exprList.get(i); |
| |
| if (e.queryTableColumnIndex != -1) { |
| continue; |
| } |
| |
| if (!e.isComposedOf(exprColumns, 0, indexLimitVisible, |
| Expression.emptyExpressionSet)) { |
| throw Error.error(ErrorCode.X_42576); |
| } |
| } |
| } |
| |
| if (isGrouped) { |
| int orderCount = sortAndSlice.getOrderLength(); |
| |
| for (int i = 0; i < orderCount; i++) { |
| Expression e = (Expression) sortAndSlice.exprList.get(i); |
| |
| if (e.queryTableColumnIndex != -1) { |
| continue; |
| } |
| |
| if (!e.isAggregate() |
| && !e.isComposedOf( |
| exprColumns, 0, |
| indexLimitVisible + groupByColumnCount, |
| Expression.emptyExpressionSet)) { |
| throw Error.error(ErrorCode.X_42576); |
| } |
| } |
| } |
| |
| if (isDistinctSelect || isGrouped) { |
| simpleLimit = false; |
| } |
| |
| if (!isAggregated) { |
| return; |
| } |
| |
| OrderedHashSet expressions = new OrderedHashSet(); |
| OrderedHashSet columnExpressions = new OrderedHashSet(); |
| |
| for (int i = indexStartAggregates; i < indexLimitExpressions; i++) { |
| Expression e = exprColumns[i]; |
| Expression c = new ExpressionColumn(e, i, resultRangePosition); |
| |
| expressions.add(e); |
| columnExpressions.add(c); |
| } |
| |
| for (int i = 0; i < indexStartHaving; i++) { |
| if (exprColumns[i].isAggregate()) { |
| continue; |
| } |
| |
| Expression e = exprColumns[i]; |
| |
| if (expressions.add(e)) { |
| Expression c = new ExpressionColumn(e, i, resultRangePosition); |
| |
| columnExpressions.add(c); |
| } |
| } |
| |
| // order by with aggregate |
| int orderCount = sortAndSlice.getOrderLength(); |
| |
| for (int i = 0; i < orderCount; i++) { |
| Expression e = (Expression) sortAndSlice.exprList.get(i); |
| |
| if (e.getLeftNode().isAggregate()) { |
| e.setAggregate(); |
| } |
| } |
| |
| for (int i = indexStartOrderBy; i < indexStartAggregates; i++) { |
| if (exprColumns[i].getLeftNode().isAggregate()) { |
| exprColumns[i].setAggregate(); |
| } |
| } |
| |
| for (int i = 0; i < indexStartAggregates; i++) { |
| Expression e = exprColumns[i]; |
| |
| if (!e.isAggregate() && !e.isCorrelated() ) { |
| continue; |
| } |
| |
| aggregateCheck[i] = true; |
| |
| if (e.isAggregate()) { |
| e.convertToSimpleColumn(expressions, columnExpressions); |
| } |
| } |
| |
| for (int i = 0; i < aggregateSet.size(); i++) { |
| Expression e = (Expression) aggregateSet.get(i); |
| |
| e.convertToSimpleColumn(expressions, columnExpressions); |
| } |
| |
| if (resolvedSubqueryExpressions != null) { |
| for (int i = 0; i < resolvedSubqueryExpressions.size(); i++) { |
| Expression e = (Expression) resolvedSubqueryExpressions.get(i); |
| |
| e.convertToSimpleColumn(expressions, columnExpressions); |
| } |
| } |
| } |
| |
| boolean resolveForGroupBy(HsqlList unresolvedSet) { |
| |
| for (int i = indexLimitVisible; |
| i < indexLimitVisible + groupByColumnCount; i++) { |
| Expression e = exprColumns[i]; |
| |
| if (e.getType() == OpTypes.COLUMN) { |
| RangeVariable range = e.getRangeVariable(); |
| int colIndex = e.getColumnIndex(); |
| |
| range.columnsInGroupBy[colIndex] = true; |
| } |
| } |
| |
| for (int i = 0; i < rangeVariables.length; i++) { |
| RangeVariable range = rangeVariables[i]; |
| |
| range.hasKeyedColumnInGroupBy = |
| range.rangeTable.getUniqueNotNullColumnGroup( |
| range.columnsInGroupBy) != null; |
| } |
| |
| OrderedHashSet set = null; |
| |
| for (int i = 0; i < unresolvedSet.size(); i++) { |
| Expression e = (Expression) unresolvedSet.get(i); |
| |
| set = e.getUnkeyedColumns(set); |
| } |
| |
| return set == null; |
| } |
| |
| int[] getLimits(Session session, int maxRows) { |
| |
| int skipRows = 0; |
| int limitRows = Integer.MAX_VALUE; |
| int limitFetch = Integer.MAX_VALUE; |
| boolean hasLimits = false; |
| |
| if (sortAndSlice.hasLimit()) { |
| Integer value = |
| (Integer) sortAndSlice.limitCondition.getLeftNode().getValue( |
| session); |
| |
| if (value == null || value.intValue() < 0) { |
| throw Error.error(ErrorCode.X_2201X); |
| } |
| |
| skipRows = value.intValue(); |
| hasLimits = skipRows != 0; |
| |
| if (sortAndSlice.limitCondition.getRightNode() != null) { |
| value = |
| (Integer) sortAndSlice.limitCondition.getRightNode() |
| .getValue(session); |
| |
| if (value == null || value.intValue() <= 0) { |
| throw Error.error(ErrorCode.X_2201W); |
| } |
| |
| if (value.intValue() == 0) { |
| limitRows = Integer.MAX_VALUE; |
| } else { |
| limitRows = value.intValue(); |
| hasLimits = true; |
| } |
| } |
| } |
| |
| if (maxRows != 0) { |
| if (maxRows < limitRows) { |
| limitRows = maxRows; |
| } |
| |
| hasLimits = true; |
| } |
| |
| if (hasLimits && simpleLimit |
| && (!sortAndSlice.hasOrder() || sortAndSlice.skipSort) |
| && (!sortAndSlice.hasLimit() || sortAndSlice.skipFullResult)) { |
| if (limitFetch - skipRows > limitRows) { |
| limitFetch = skipRows + limitRows; |
| } |
| } |
| |
| return hasLimits ? new int[] { |
| skipRows, limitRows, limitFetch |
| } |
| : defaultLimits; |
| } |
| |
| /** |
| * Returns the result of executing this Select. |
| * |
| * @param maxrows may be 0 to indicate no limit on the number of rows. |
| * Positive values limit the size of the result set. |
| * @return the result of executing this Select |
| */ |
| Result getResult(Session session, int maxrows) { |
| |
| Result r = getSingleResult(session, maxrows); |
| |
| r.getNavigator().reset(); |
| |
| return r; |
| } |
| |
| private Result getSingleResult(Session session, int maxRows) { |
| |
| int[] limits = getLimits(session, maxRows); |
| Result r = buildResult(session, limits[2]); |
| RowSetNavigatorData navigator = (RowSetNavigatorData) r.getNavigator(); |
| |
| if (isDistinctSelect) { |
| navigator.removeDuplicates(); |
| } |
| |
| if (sortAndSlice.hasOrder()) { |
| navigator.sortOrder(); |
| } |
| |
| if (limits != defaultLimits) { |
| navigator.trim(limits[0], limits[1]); |
| } |
| |
| return r; |
| } |
| |
| private Result buildResult(Session session, int limitcount) { |
| |
| RowSetNavigatorData navigator = new RowSetNavigatorData(session, |
| (QuerySpecification) this); |
| Result result = Result.newResult(navigator); |
| |
| result.metaData = resultMetaData; |
| |
| if (isUpdatable) { |
| result.rsProperties = ResultProperties.updatablePropsValue; |
| } |
| |
| if (this.isSimpleCount) { |
| Object[] data = new Object[indexLimitData]; |
| Table table = rangeVariables[0].getTable(); |
| PersistentStore store = table.getRowStore(session); |
| int count = table.getIndex(0).size(session, store); |
| |
| data[0] = data[indexStartAggregates] = ValuePool.getInt(count); |
| |
| navigator.add(data); |
| |
| return result; |
| } |
| |
| int fullJoinIndex = 0; |
| RangeIterator[] rangeIterators = |
| new RangeIterator[rangeVariables.length]; |
| |
| for (int i = 0; i < rangeVariables.length; i++) { |
| rangeIterators[i] = rangeVariables[i].getIterator(session); |
| } |
| |
| for (int currentIndex = 0; ; ) { |
| if (currentIndex < fullJoinIndex) { |
| |
| // finished current span |
| // or finished outer rows on right navigator |
| boolean end = true; |
| |
| for (int i = fullJoinIndex + 1; i < rangeVariables.length; |
| i++) { |
| if (rangeVariables[i].isRightJoin) { |
| fullJoinIndex = i; |
| currentIndex = i; |
| end = false; |
| |
| ((RangeIteratorRight) rangeIterators[i]) |
| .setOnOuterRows(); |
| |
| break; |
| } |
| } |
| |
| if (end) { |
| break; |
| } |
| } |
| |
| RangeIterator it = rangeIterators[currentIndex]; |
| |
| if (it.next()) { |
| if (currentIndex < rangeVariables.length - 1) { |
| currentIndex++; |
| |
| continue; |
| } |
| } else { |
| it.reset(); |
| |
| currentIndex--; |
| |
| continue; |
| } |
| |
| session.sessionData.startRowProcessing(); |
| |
| Object[] data = new Object[indexLimitData]; |
| |
| for (int i = 0; i < indexStartAggregates; i++) { |
| if (isAggregated && aggregateCheck[i]) { |
| continue; |
| } else { |
| data[i] = exprColumns[i].getValue(session); |
| } |
| } |
| |
| for (int i = indexLimitVisible; i < indexLimitRowId; i++) { |
| if (i == indexLimitVisible) { |
| data[i] = it.getRowidObject(); |
| } else { |
| data[i] = it.getCurrentRow(); |
| } |
| } |
| |
| Object[] groupData = null; |
| |
| if (isAggregated || isGrouped) { |
| groupData = navigator.getGroupData(data); |
| |
| if (groupData != null) { |
| data = groupData; |
| } |
| } |
| |
| for (int i = indexStartAggregates; i < indexLimitExpressions; |
| i++) { |
| data[i] = exprColumns[i].updateAggregatingValue(session, |
| data[i]); |
| } |
| |
| if (groupData == null) { |
| navigator.add(data); |
| } else if (isAggregated) { |
| navigator.update(groupData, data); |
| } |
| |
| int rowCount = navigator.getSize(); |
| |
| if (rowCount == session.resultMaxMemoryRows && !isAggregated |
| && !hasMemoryRow) { |
| navigator = new RowSetNavigatorDataTable(session, this, |
| navigator); |
| |
| result.setNavigator(navigator); |
| } |
| |
| if (isAggregated || isGrouped) { |
| if (!sortAndSlice.isGenerated) { |
| continue; |
| } |
| } |
| |
| if (rowCount >= limitcount) { |
| break; |
| } |
| } |
| |
| navigator.reset(); |
| |
| for (int i = 0; i < rangeVariables.length; i++) { |
| rangeIterators[i].reset(); |
| } |
| |
| if (!isGrouped && !isAggregated) { |
| return result; |
| } |
| |
| if (isAggregated) { |
| if (!isGrouped && navigator.getSize() == 0) { |
| Object[] data = new Object[exprColumns.length]; |
| |
| navigator.add(data); |
| } |
| |
| navigator.reset(); |
| session.sessionContext.setRangeIterator(navigator); |
| |
| while (navigator.next()) { |
| Object[] data = navigator.getCurrent(); |
| |
| for (int i = indexStartAggregates; i < indexLimitExpressions; |
| i++) { |
| data[i] = exprColumns[i].getAggregatedValue(session, |
| data[i]); |
| } |
| |
| for (int i = 0; i < indexStartAggregates; i++) { |
| if (aggregateCheck[i]) { |
| data[i] = exprColumns[i].getValue(session); |
| } |
| } |
| } |
| } |
| |
| navigator.reset(); |
| |
| if (havingCondition != null) { |
| while (navigator.hasNext()) { |
| Object[] data = (Object[]) navigator.getNext(); |
| |
| if (!Boolean.TRUE.equals( |
| data[indexLimitVisible + groupByColumnCount])) { |
| navigator.remove(); |
| } |
| } |
| |
| navigator.reset(); |
| } |
| |
| return result; |
| } |
| |
| void setReferenceableColumns() { |
| |
| accessibleColumns = new boolean[indexLimitVisible]; |
| |
| IntValueHashMap aliases = new IntValueHashMap(); |
| |
| for (int i = 0; i < indexLimitVisible; i++) { |
| Expression expression = exprColumns[i]; |
| String alias = expression.getAlias(); |
| |
| if (alias.length() == 0) { |
| SimpleName name = HsqlNameManager.getAutoColumnName(i); |
| |
| expression.setAlias(name); |
| |
| continue; |
| } |
| |
| int index = aliases.get(alias, -1); |
| |
| if (index == -1) { |
| aliases.put(alias, i); |
| |
| accessibleColumns[i] = true; |
| } else { |
| accessibleColumns[index] = false; |
| } |
| } |
| } |
| |
| void setColumnAliases(SimpleName[] names) { |
| |
| if (names.length != indexLimitVisible) { |
| throw Error.error(ErrorCode.X_42593); |
| } |
| |
| for (int i = 0; i < indexLimitVisible; i++) { |
| exprColumns[i].setAlias(names[i]); |
| } |
| } |
| |
| private void createResultMetaData() { |
| |
| columnTypes = new Type[indexLimitData]; |
| |
| for (int i = 0; i < indexStartAggregates; i++) { |
| Expression e = exprColumns[i]; |
| |
| columnTypes[i] = e.getDataType(); |
| } |
| |
| for (int i = indexLimitVisible; i < indexLimitRowId; i++) { |
| if (i == indexLimitVisible) { |
| columnTypes[i] = Type.SQL_BIGINT; |
| } else { |
| columnTypes[i] = Type.SQL_ALL_TYPES; |
| } |
| } |
| |
| for (int i = indexLimitRowId; i < indexLimitData; i++) { |
| Expression e = exprColumns[i]; |
| |
| columnTypes[i] = e.getDataType(); |
| } |
| |
| resultMetaData = ResultMetaData.newResultMetaData(columnTypes, |
| columnMap, indexLimitVisible, indexLimitRowId); |
| |
| for (int i = 0; i < indexLimitVisible; i++) { |
| Expression e = exprColumns[i]; |
| |
| resultMetaData.columnTypes[i] = e.getDataType(); |
| |
| if (i < indexLimitVisible) { |
| ColumnBase column = e.getColumn(); |
| |
| if (column != null) { |
| resultMetaData.columns[i] = column; |
| resultMetaData.columnLabels[i] = e.getAlias(); |
| |
| continue; |
| } |
| |
| column = new ColumnBase(); |
| |
| column.setType(e.getDataType()); |
| |
| resultMetaData.columns[i] = column; |
| resultMetaData.columnLabels[i] = e.getAlias(); |
| } |
| } |
| } |
| |
| void createTable(Session session) { |
| |
| createResultTable(session); |
| |
| mainIndex = resultTable.getPrimaryIndex(); |
| |
| if (sortAndSlice.hasOrder() && !sortAndSlice.skipSort) { |
| orderIndex = resultTable.createAndAddIndexStructure(session, null, |
| sortAndSlice.sortOrder, sortAndSlice.sortDescending, |
| sortAndSlice.sortNullsLast, false, false, false); |
| } |
| |
| if (isDistinctSelect || isFullOrder) { |
| createFullIndex(session); |
| } |
| |
| if (isGrouped) { |
| int[] groupCols = new int[groupByColumnCount]; |
| |
| for (int i = 0; i < groupByColumnCount; i++) { |
| groupCols[i] = indexLimitVisible + i; |
| } |
| |
| groupIndex = resultTable.createAndAddIndexStructure(session, null, |
| groupCols, null, null, false, false, false); |
| } else if (isAggregated) { |
| groupIndex = mainIndex; |
| } |
| |
| if (isUpdatable && view == null) { |
| int[] idCols = new int[]{ indexLimitVisible }; |
| |
| idIndex = resultTable.createAndAddIndexStructure(session, null, |
| idCols, null, null, false, false, false); |
| } |
| } |
| |
| void createFullIndex(Session session) { |
| |
| int[] fullCols = new int[indexLimitVisible]; |
| |
| ArrayUtil.fillSequence(fullCols); |
| |
| fullIndex = resultTable.createAndAddIndexStructure(session, null, |
| fullCols, null, null, false, false, false); |
| resultTable.fullIndex = fullIndex; |
| } |
| |
| void createResultTable(Session session) { |
| |
| HsqlName tableName; |
| HashMappedList columnList; |
| int tableType; |
| |
| tableName = session.database.nameManager.getSubqueryTableName(); |
| tableType = persistenceScope == TableBase.SCOPE_STATEMENT |
| ? TableBase.SYSTEM_SUBQUERY |
| : TableBase.RESULT_TABLE; |
| columnList = new HashMappedList(); |
| |
| for (int i = 0; i < indexLimitVisible; i++) { |
| Expression e = exprColumns[i]; |
| SimpleName simpleName = e.getSimpleName(); |
| String nameString = simpleName.name; |
| HsqlName name = |
| session.database.nameManager.newColumnSchemaHsqlName(tableName, |
| simpleName); |
| |
| if (!accessibleColumns[i]) { |
| nameString = HsqlNameManager.getAutoNoNameColumnString(i); |
| } |
| |
| ColumnSchema column = new ColumnSchema(name, e.dataType, true, |
| false, null); |
| |
| columnList.add(nameString, column); |
| } |
| |
| try { |
| resultTable = new TableDerived(session.database, tableName, |
| tableType, columnTypes, columnList, |
| null, null); |
| } catch (Exception e) {} |
| } |
| |
| public String getSQL() { |
| |
| StringBuffer sb = new StringBuffer(); |
| int limit; |
| |
| sb.append(Tokens.T_SELECT).append(' '); |
| |
| limit = indexLimitVisible; |
| |
| for (int i = 0; i < limit; i++) { |
| if (i > 0) { |
| sb.append(','); |
| } |
| |
| sb.append(exprColumns[i].getSQL()); |
| } |
| |
| sb.append(Tokens.T_FROM); |
| |
| limit = rangeVariables.length; |
| |
| for (int i = 0; i < limit; i++) { |
| RangeVariable rangeVar = rangeVariables[i]; |
| |
| if (i > 0) { |
| if (rangeVar.isLeftJoin && rangeVar.isRightJoin) { |
| sb.append(Tokens.T_FULL).append(' '); |
| } else if (rangeVar.isLeftJoin) { |
| sb.append(Tokens.T_LEFT).append(' '); |
| } else if (rangeVar.isRightJoin) { |
| sb.append(Tokens.T_RIGHT).append(' '); |
| } |
| |
| sb.append(Tokens.T_JOIN).append(' '); |
| } |
| |
| sb.append(rangeVar.getTable().getName().statementName); |
| } |
| |
| if (isGrouped) { |
| sb.append(' ').append(Tokens.T_GROUP).append(' ').append( |
| Tokens.T_BY); |
| |
| limit = indexLimitVisible + groupByColumnCount; |
| |
| for (int i = indexLimitVisible; i < limit; i++) { |
| sb.append(exprColumns[i].getSQL()); |
| |
| if (i < limit - 1) { |
| sb.append(','); |
| } |
| } |
| } |
| |
| if (havingCondition != null) { |
| sb.append(' ').append(Tokens.T_HAVING).append(' '); |
| sb.append(havingCondition.getSQL()); |
| } |
| |
| if (sortAndSlice.hasOrder()) { |
| limit = indexStartOrderBy + sortAndSlice.getOrderLength(); |
| |
| sb.append(' ').append(Tokens.T_ORDER).append(Tokens.T_BY).append( |
| ' '); |
| |
| for (int i = indexStartOrderBy; i < limit; i++) { |
| sb.append(exprColumns[i].getSQL()); |
| |
| if (i < limit - 1) { |
| sb.append(','); |
| } |
| } |
| } |
| |
| if (sortAndSlice.hasLimit()) { |
| sb.append(sortAndSlice.limitCondition.getLeftNode().getSQL()); |
| } |
| |
| return sb.toString(); |
| } |
| |
| public ResultMetaData getMetaData() { |
| return resultMetaData; |
| } |
| |
| public String describe(Session session, int blanks) { |
| |
| StringBuffer sb; |
| String temp; |
| String b = ValuePool.spaceString.substring(0, blanks); |
| |
| sb = new StringBuffer(); |
| |
| sb.append(b).append("isDistinctSelect=[").append( |
| isDistinctSelect).append("]\n"); |
| sb.append(b).append("isGrouped=[").append(isGrouped).append("]\n"); |
| sb.append(b).append("isAggregated=[").append(isAggregated).append( |
| "]\n"); |
| sb.append(b).append("columns=["); |
| |
| for (int i = 0; i < indexLimitVisible; i++) { |
| int index = i; |
| |
| if (exprColumns[i].getType() == OpTypes.SIMPLE_COLUMN) { |
| index = exprColumns[i].columnIndex; |
| } |
| |
| sb.append(b).append(exprColumns[index].describe(session, 2)); |
| } |
| |
| sb.append("\n"); |
| sb.append(b).append("]\n"); |
| |
| for (int i = 0; i < rangeVariables.length; i++) { |
| sb.append(b).append("["); |
| sb.append("range variable ").append(i + 1).append("\n"); |
| sb.append(rangeVariables[i].describe(session, blanks + 2)); |
| sb.append(b).append("]"); |
| } |
| |
| sb.append(b).append("]\n"); |
| |
| temp = queryCondition == null ? "null" |
| : queryCondition.describe(session, |
| blanks); |
| |
| if (isGrouped) { |
| sb.append(b).append("groupColumns=["); |
| |
| for (int i = indexLimitRowId; |
| i < indexLimitRowId + groupByColumnCount; i++) { |
| int index = i; |
| |
| if (exprColumns[i].getType() == OpTypes.SIMPLE_COLUMN) { |
| index = exprColumns[i].columnIndex; |
| } |
| |
| sb.append(exprColumns[index].describe(session, blanks)); |
| } |
| |
| sb.append(b).append("]\n"); |
| } |
| |
| if (havingCondition != null) { |
| temp = havingCondition.describe(session, blanks); |
| |
| sb.append(b).append("havingCondition=[").append(temp).append( |
| "]\n"); |
| } |
| |
| if (sortAndSlice.hasOrder()) { |
| sb.append(b).append("order by=[\n"); |
| |
| for (int i = 0; i < sortAndSlice.exprList.size(); i++) { |
| sb.append(b).append( |
| ((Expression) sortAndSlice.exprList.get(i)).describe( |
| session, blanks)); |
| sb.append(b).append("\n]"); |
| } |
| |
| sb.append(b).append("]\n"); |
| } |
| |
| if (sortAndSlice.hasLimit()) { |
| if (sortAndSlice.limitCondition.getLeftNode() != null) { |
| sb.append(b).append("offset=[").append( |
| sortAndSlice.limitCondition.getLeftNode().describe( |
| session, 0)).append("]\n"); |
| } |
| |
| if (sortAndSlice.limitCondition.getRightNode() != null) { |
| sb.append(b).append("limit=[").append( |
| sortAndSlice.limitCondition.getRightNode().describe( |
| session, 0)).append("]\n"); |
| } |
| } |
| |
| return sb.toString(); |
| } |
| |
| void setMergeability() { |
| |
| if (isGrouped || isDistinctSelect) { |
| isMergeable = false; |
| |
| return; |
| } |
| |
| if (sortAndSlice.hasLimit() || sortAndSlice.hasOrder()) { |
| isMergeable = false; |
| |
| return; |
| } |
| |
| if (rangeVariables.length != 1) { |
| isMergeable = false; |
| |
| return; |
| } |
| } |
| |
| void setUpdatability() { |
| |
| if (!isUpdatable) { |
| return; |
| } |
| |
| isUpdatable = false; |
| |
| if (!isMergeable) { |
| return; |
| } |
| |
| if (!isTopLevel) { |
| return; |
| } |
| |
| if (isAggregated) { |
| return; |
| } |
| |
| if (sortAndSlice.hasLimit() || sortAndSlice.hasOrder()) { |
| return; |
| } |
| |
| RangeVariable rangeVar = rangeVariables[0]; |
| Table table = rangeVar.getTable(); |
| Table baseTable = table.getBaseTable(); |
| |
| if (baseTable == null) { |
| return; |
| } |
| |
| isInsertable = table.isInsertable(); |
| isUpdatable = table.isUpdatable(); |
| |
| if (!isInsertable && !isUpdatable) { |
| return; |
| } |
| |
| IntValueHashMap columns = new IntValueHashMap(); |
| boolean[] checkList; |
| int[] baseColumnMap = table.getBaseTableColumnMap(); |
| int[] columnMap = new int[indexLimitVisible]; |
| |
| if (queryCondition != null) { |
| tempSet.clear(); |
| collectSubQueriesAndReferences(tempSet, queryCondition); |
| |
| if (tempSet.contains(table.getName()) |
| || tempSet.contains(baseTable.getName())) { |
| isUpdatable = false; |
| isInsertable = false; |
| |
| return; |
| } |
| } |
| |
| for (int i = 0; i < indexLimitVisible; i++) { |
| Expression expression = exprColumns[i]; |
| |
| if (expression.getType() == OpTypes.COLUMN) { |
| String name = expression.getColumn().getName().name; |
| |
| if (columns.containsKey(name)) { |
| columns.put(name, 1); |
| |
| continue; |
| } |
| |
| columns.put(name, 0); |
| } else { |
| tempSet.clear(); |
| collectSubQueriesAndReferences(tempSet, expression); |
| |
| if (tempSet.contains(table.getName())) { |
| isUpdatable = false; |
| isInsertable = false; |
| |
| return; |
| } |
| } |
| } |
| |
| isUpdatable = false; |
| |
| for (int i = 0; i < indexLimitVisible; i++) { |
| if (accessibleColumns[i]) { |
| Expression expression = exprColumns[i]; |
| |
| if (expression.getType() == OpTypes.COLUMN) { |
| String name = expression.getColumn().getName().name; |
| |
| if (columns.get(name) == 0) { |
| int index = table.findColumn(name); |
| |
| columnMap[i] = baseColumnMap[index]; |
| |
| if (columnMap[i] != -1) { |
| isUpdatable = true; |
| } |
| |
| continue; |
| } |
| } |
| } |
| |
| columnMap[i] = -1; |
| isInsertable = false; |
| } |
| |
| if (isInsertable) { |
| checkList = baseTable.getColumnCheckList(columnMap); |
| |
| for (int i = 0; i < checkList.length; i++) { |
| if (checkList[i]) { |
| continue; |
| } |
| |
| ColumnSchema column = baseTable.getColumn(i); |
| |
| if (column.isIdentity() || column.isGenerated() |
| || column.hasDefault() || column.isNullable()) {} |
| else { |
| isInsertable = false; |
| |
| break; |
| } |
| } |
| } |
| |
| if (!isUpdatable) { |
| isInsertable = false; |
| } |
| |
| if (isUpdatable) { |
| this.columnMap = columnMap; |
| this.baseTable = baseTable; |
| |
| if (view != null) { |
| return; |
| } |
| |
| indexLimitRowId++; |
| |
| hasRowID = true; |
| |
| if (!baseTable.isFileBased()) { |
| indexLimitRowId++; |
| |
| hasMemoryRow = true; |
| } |
| |
| indexLimitData = indexLimitRowId; |
| } |
| } |
| |
| void mergeQuery() { |
| |
| RangeVariable rangeVar = rangeVariables[0]; |
| Table table = rangeVar.getTable(); |
| Expression localQueryCondition = queryCondition; |
| |
| if (table instanceof TableDerived) { |
| QueryExpression baseQueryExpression = |
| ((TableDerived) table).getQueryExpression(); |
| |
| if (baseQueryExpression == null || !baseQueryExpression.isMergeable) { |
| isMergeable = false; |
| |
| return; |
| } |
| |
| QuerySpecification baseSelect = |
| baseQueryExpression.getMainSelect(); |
| |
| if (baseQueryExpression.view == null) { |
| rangeVariables[0] = baseSelect.rangeVariables[0]; |
| |
| rangeVariables[0].resetConditions(); |
| |
| Expression[] newExprColumns = new Expression[indexLimitData]; |
| |
| for (int i = 0; i < indexLimitData; i++) { |
| Expression e = exprColumns[i]; |
| |
| newExprColumns[i] = e.replaceColumnReferences(rangeVar, |
| baseSelect.exprColumns); |
| } |
| |
| exprColumns = newExprColumns; |
| |
| if (localQueryCondition != null) { |
| localQueryCondition = |
| localQueryCondition.replaceColumnReferences(rangeVar, |
| baseSelect.exprColumns); |
| } |
| |
| Expression baseQueryCondition = baseSelect.queryCondition; |
| |
| checkQueryCondition = baseSelect.checkQueryCondition; |
| queryCondition = |
| ExpressionLogical.andExpressions(baseQueryCondition, |
| localQueryCondition); |
| } else { |
| RangeVariable[] newRangeVariables = new RangeVariable[1]; |
| |
| newRangeVariables[0] = |
| baseSelect.rangeVariables[0].duplicate(); |
| |
| Expression[] newBaseExprColumns = |
| new Expression[baseSelect.indexLimitData]; |
| |
| for (int i = 0; i < baseSelect.indexLimitData; i++) { |
| Expression e = baseSelect.exprColumns[i].duplicate(); |
| |
| newBaseExprColumns[i] = e; |
| |
| e.replaceRangeVariables(baseSelect.rangeVariables, |
| newRangeVariables); |
| } |
| |
| for (int i = 0; i < indexLimitData; i++) { |
| Expression e = exprColumns[i]; |
| |
| exprColumns[i] = e.replaceColumnReferences(rangeVar, |
| newBaseExprColumns); |
| } |
| |
| Expression baseQueryCondition = baseSelect.queryCondition; |
| |
| if (baseQueryCondition != null) { |
| baseQueryCondition = baseQueryCondition.duplicate(); |
| |
| baseQueryCondition.replaceRangeVariables( |
| baseSelect.rangeVariables, newRangeVariables); |
| } |
| |
| if (localQueryCondition != null) { |
| localQueryCondition = |
| localQueryCondition.replaceColumnReferences(rangeVar, |
| newBaseExprColumns); |
| } |
| |
| checkQueryCondition = baseSelect.checkQueryCondition; |
| |
| if (checkQueryCondition != null) { |
| checkQueryCondition = checkQueryCondition.duplicate(); |
| |
| checkQueryCondition.replaceRangeVariables( |
| baseSelect.rangeVariables, newRangeVariables); |
| } |
| |
| queryCondition = |
| ExpressionLogical.andExpressions(baseQueryCondition, |
| localQueryCondition); |
| rangeVariables = newRangeVariables; |
| } |
| } |
| |
| if (view != null) { |
| switch (view.getCheckOption()) { |
| |
| case SchemaObject.ViewCheckModes.CHECK_LOCAL : |
| if (!isUpdatable) { |
| throw Error.error(ErrorCode.X_42537); |
| } |
| |
| checkQueryCondition = localQueryCondition; |
| break; |
| |
| case SchemaObject.ViewCheckModes.CHECK_CASCADE : |
| if (!isUpdatable) { |
| throw Error.error(ErrorCode.X_42537); |
| } |
| |
| checkQueryCondition = queryCondition; |
| break; |
| } |
| } |
| |
| if (isAggregated) { |
| isMergeable = false; |
| } |
| } |
| |
| static void collectSubQueriesAndReferences(OrderedHashSet set, |
| Expression expression) { |
| |
| expression.collectAllExpressions(set, |
| Expression.subqueryExpressionSet, |
| Expression.emptyExpressionSet); |
| |
| int size = set.size(); |
| |
| for (int i = 0; i < size; i++) { |
| Expression e = (Expression) set.get(i); |
| |
| e.collectObjectNames(set); |
| } |
| } |
| |
| public OrderedHashSet getSubqueries() { |
| |
| OrderedHashSet set = null; |
| |
| for (int i = 0; i < indexStartAggregates; i++) { |
| set = exprColumns[i].collectAllSubqueries(set); |
| } |
| |
| if (queryCondition != null) { |
| set = queryCondition.collectAllSubqueries(set); |
| } |
| |
| if (havingCondition != null) { |
| set = havingCondition.collectAllSubqueries(set); |
| } |
| |
| for (int i = 0; i < rangeVariables.length; i++) { |
| OrderedHashSet temp = rangeVariables[i].getSubqueries(); |
| |
| set = OrderedHashSet.addAll(set, temp); |
| } |
| |
| return set; |
| } |
| |
| public Table getBaseTable() { |
| return baseTable; |
| } |
| |
| public OrderedHashSet collectAllSubqueries(OrderedHashSet set) { |
| return set; |
| } |
| |
| public OrderedHashSet collectAllExpressions(OrderedHashSet set, |
| OrderedIntHashSet typeSet, OrderedIntHashSet stopAtTypeSet) { |
| |
| for (int i = 0; i < indexStartAggregates; i++) { |
| set = exprColumns[i].collectAllExpressions(set, typeSet, |
| stopAtTypeSet); |
| } |
| |
| if (queryCondition != null) { |
| set = queryCondition.collectAllExpressions(set, typeSet, |
| stopAtTypeSet); |
| } |
| |
| if (havingCondition != null) { |
| set = havingCondition.collectAllExpressions(set, typeSet, |
| stopAtTypeSet); |
| } |
| |
| return set; |
| } |
| |
| public void collectObjectNames(Set set) { |
| |
| for (int i = 0; i < indexStartAggregates; i++) { |
| exprColumns[i].collectObjectNames(set); |
| } |
| |
| if (queryCondition != null) { |
| queryCondition.collectObjectNames(set); |
| } |
| |
| if (havingCondition != null) { |
| havingCondition.collectObjectNames(set); |
| } |
| |
| for (int i = 0, len = rangeVariables.length; i < len; i++) { |
| HsqlName name = rangeVariables[i].getTable().getName(); |
| |
| set.add(name); |
| } |
| } |
| |
| public void replaceColumnReference(RangeVariable range, |
| Expression[] list) { |
| |
| for (int i = 0; i < indexStartAggregates; i++) { |
| exprColumns[i].replaceColumnReferences(range, list); |
| } |
| |
| if (queryCondition != null) { |
| queryCondition.replaceColumnReferences(range, list); |
| } |
| |
| if (havingCondition != null) { |
| havingCondition.replaceColumnReferences(range, list); |
| } |
| |
| for (int i = 0, len = rangeVariables.length; i < len; i++) { |
| |
| // |
| } |
| } |
| |
| public void replaceRangeVariables(RangeVariable[] ranges, |
| RangeVariable[] newRanges) { |
| |
| for (int i = 0; i < indexStartAggregates; i++) { |
| exprColumns[i].replaceRangeVariables(ranges, newRanges); |
| } |
| |
| if (queryCondition != null) { |
| queryCondition.replaceRangeVariables(ranges, newRanges); |
| } |
| |
| if (havingCondition != null) { |
| havingCondition.replaceRangeVariables(ranges, newRanges); |
| } |
| |
| for (int i = 0, len = rangeVariables.length; i < len; i++) { |
| rangeVariables[i].getSubqueries(); |
| } |
| } |
| |
| /** |
| * Not for views. Only used on root node. |
| */ |
| public void setReturningResult() { |
| |
| setReturningResultSet(); |
| |
| acceptsSequences = true; |
| isTopLevel = true; |
| } |
| |
| void setReturningResultSet() { |
| persistenceScope = TableBase.SCOPE_SESSION; |
| } |
| |
| public boolean isSingleColumn() { |
| return indexLimitVisible == 1; |
| } |
| |
| public String[] getColumnNames() { |
| |
| String[] names = new String[indexLimitVisible]; |
| |
| for (int i = 0; i < indexLimitVisible; i++) { |
| names[i] = exprColumns[i].getAlias(); |
| } |
| |
| return names; |
| } |
| |
| public Type[] getColumnTypes() { |
| |
| if (columnTypes.length == indexLimitVisible) { |
| return columnTypes; |
| } |
| |
| Type[] types = new Type[indexLimitVisible]; |
| |
| ArrayUtil.copyArray(columnTypes, types, types.length); |
| |
| return types; |
| } |
| |
| public int getColumnCount() { |
| return indexLimitVisible; |
| } |
| |
| public int[] getBaseTableColumnMap() { |
| return columnMap; |
| } |
| |
| public Expression getCheckCondition() { |
| return queryCondition; |
| } |
| |
| void getBaseTableNames(OrderedHashSet set) { |
| |
| for (int i = 0; i < rangeVariables.length; i++) { |
| Table rangeTable = rangeVariables[i].rangeTable; |
| HsqlName name = rangeTable.getName(); |
| |
| if (rangeTable.isReadOnly() || rangeTable.isTemp()) { |
| continue; |
| } |
| |
| if (name.schema == SqlInvariants.SYSTEM_SCHEMA_HSQLNAME) { |
| continue; |
| } |
| |
| set.add(name); |
| } |
| } |
| |
| /** |
| * returns true if almost equivalent |
| */ |
| boolean isEquivalent(QueryExpression other) { |
| |
| if (!(other instanceof QuerySpecification)) { |
| return false; |
| } |
| |
| QuerySpecification otherSpec = (QuerySpecification) other; |
| |
| if (!Expression.equals(exprColumns, otherSpec.exprColumns)) { |
| return false; |
| } |
| |
| if (!Expression.equals(queryCondition, otherSpec.queryCondition)) { |
| return false; |
| } |
| |
| if (rangeVariables.length != otherSpec.rangeVariables.length) { |
| return false; |
| } |
| |
| for (int i = 0; i < rangeVariables.length; i++) { |
| if (rangeVariables[i].getTable() |
| != otherSpec.rangeVariables[i].getTable()) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| } |
