org.hsqldb.lib.HsqlList - java examples

Here are the examples of the java api org.hsqldb.lib.HsqlList taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

42 Examples 7

19 View Complete Implementation : Expression.java
Copyright GNU General Public License v3.0
Author : apavlo
/**
 * resolve tables and collect unresolved column expressions
 */
public HsqlList resolveColumnReferences(RangeVariable[] rangeVarArray, HsqlList unresolvedSet) {
    return resolveColumnReferences(rangeVarArray, rangeVarArray.length, unresolvedSet, true);
}

19 View Complete Implementation : Expression.java
Copyright GNU General Public License v3.0
Author : apavlo
public HsqlList resolveColumnReferences(RangeVariable[] rangeVarArray, int rangeCount, HsqlList unresolvedSet, boolean acceptsSequences) {
    if (opType == OpTypes.VALUE) {
        return unresolvedSet;
    }
    switch(opType) {
        case OpTypes.CASEWHEN:
            acceptsSequences = false;
            break;
        case OpTypes.TABLE:
            {
                HsqlList localSet = null;
                for (int i = 0; i < nodes.length; i++) {
                    if (nodes[i] == null) {
                        continue;
                    }
                    localSet = nodes[i].resolveColumnReferences(RangeVariable.emptyArray, localSet);
                }
                if (localSet != null) {
                    isCorrelated = true;
                    if (subQuery != null) {
                        subQuery.setCorrelated();
                    }
                    for (int i = 0; i < localSet.size(); i++) {
                        Expression e = (Expression) localSet.get(i);
                        unresolvedSet = e.resolveColumnReferences(rangeVarArray, unresolvedSet);
                    }
                    unresolvedSet = Expression.resolveColumnSet(rangeVarArray, localSet, unresolvedSet);
                }
                return unresolvedSet;
            }
    }
    for (int i = 0; i < nodes.length; i++) {
        if (nodes[i] == null) {
            continue;
        }
        unresolvedSet = nodes[i].resolveColumnReferences(rangeVarArray, rangeCount, unresolvedSet, acceptsSequences);
    }
    switch(opType) {
        case OpTypes.ROW_SUBQUERY:
        case OpTypes.TABLE_SUBQUERY:
            {
                QueryExpression queryExpression = subQuery.queryExpression;
                if (!queryExpression.areColumnsResolved()) {
                    isCorrelated = true;
                    subQuery.setCorrelated();
                    // take to enclosing context
                    if (unresolvedSet == null) {
                        unresolvedSet = new ArrayListIdenreplacedy();
                    }
                    unresolvedSet.addAll(queryExpression.getUnresolvedExpressions());
                }
                break;
            }
        default:
    }
    return unresolvedSet;
}

19 View Complete Implementation : Expression.java
Copyright GNU General Public License v3.0
Author : apavlo
public void collectAllFunctionExpressions(HsqlList set) {
    Expression.collectAllExpressions(set, this, Expression.emptyExpressionSet, Expression.emptyExpressionSet);
}

19 View Complete Implementation : Expression.java
Copyright GNU General Public License v3.0
Author : apavlo
static HsqlList resolveColumnSet(RangeVariable[] rangeVars, HsqlList sourceSet, HsqlList targetSet) {
    if (sourceSet == null) {
        return targetSet;
    }
    for (int i = 0; i < sourceSet.size(); i++) {
        Expression e = (Expression) sourceSet.get(i);
        targetSet = e.resolveColumnReferences(rangeVars, targetSet);
    }
    return targetSet;
}

19 View Complete Implementation : ExpressionAggregate.java
Copyright GNU General Public License v3.0
Author : apavlo
public HsqlList resolveColumnReferences(RangeVariable[] rangeVarArray, int rangeCount, HsqlList unresolvedSet, boolean acceptsSequences) {
    if (unresolvedSet == null) {
        unresolvedSet = new ArrayListIdenreplacedy();
    }
    unresolvedSet.add(this);
    return unresolvedSet;
}

19 View Complete Implementation : ExpressionArithmetic.java
Copyright GNU General Public License v3.0
Author : apavlo
public HsqlList resolveColumnReferences(RangeVariable[] rangeVarArray, int rangeCount, HsqlList unresolvedSet, boolean acceptsSequences) {
    if (opType == OpTypes.VALUE) {
        return unresolvedSet;
    }
    for (int i = 0; i < nodes.length; i++) {
        if (nodes[i] == null) {
            continue;
        }
        unresolvedSet = nodes[i].resolveColumnReferences(rangeVarArray, rangeCount, unresolvedSet, acceptsSequences);
    }
    return unresolvedSet;
}

19 View Complete Implementation : ExpressionColumn.java
Copyright GNU General Public License v3.0
Author : apavlo
static void checkColumnsResolved(HsqlList set) {
    if (set != null && !set.isEmpty()) {
        ExpressionColumn e = (ExpressionColumn) set.get(0);
        StringBuffer sb = new StringBuffer();
        if (e.schema != null) {
            sb.append(e.schema + '.');
        }
        if (e.tableName != null) {
            sb.append(e.tableName + '.');
        }
        throw Error.error(ErrorCode.X_42501, sb.toString() + e.getColumnName());
    }
}

19 View Complete Implementation : ExpressionColumn.java
Copyright GNU General Public License v3.0
Author : apavlo
public HsqlList resolveColumnReferences(RangeVariable[] rangeVarArray, int rangeCount, HsqlList unresolvedSet, boolean acceptsSequences) {
    switch(opType) {
        case OpTypes.SEQUENCE:
            if (!acceptsSequences) {
                throw Error.error(ErrorCode.X_42598);
            }
            break;
        case OpTypes.MULTICOLUMN:
        case OpTypes.DYNAMIC_PARAM:
        case OpTypes.ASTERISK:
        case OpTypes.SIMPLE_COLUMN:
        case OpTypes.COALESCE:
            break;
        case OpTypes.PARAMETER:
        case OpTypes.VARIABLE:
        case OpTypes.COLUMN:
            if (rangeVariable != null) {
                return unresolvedSet;
            }
            for (int i = 0; i < rangeCount; i++) {
                RangeVariable rangeVar = rangeVarArray[i];
                if (rangeVar == null) {
                    continue;
                }
                if (resolveColumnReference(rangeVar)) {
                    return unresolvedSet;
                }
            }
            if (unresolvedSet == null) {
                unresolvedSet = new ArrayListIdenreplacedy();
            }
            unresolvedSet.add(this);
    }
    return unresolvedSet;
}

19 View Complete Implementation : ExpressionLike.java
Copyright GNU General Public License v3.0
Author : apavlo
public HsqlList resolveColumnReferences(RangeVariable[] rangeVarArray, int rangeCount, HsqlList unresolvedSet, boolean acceptsSequences) {
    for (int i = 0; i < nodes.length; i++) {
        if (nodes[i] != null) {
            unresolvedSet = nodes[i].resolveColumnReferences(rangeVarArray, rangeCount, unresolvedSet, acceptsSequences);
        }
    }
    return unresolvedSet;
}

19 View Complete Implementation : ExpressionOp.java
Copyright GNU General Public License v3.0
Author : apavlo
public HsqlList resolveColumnReferences(RangeVariable[] rangeVarArray, int rangeCount, HsqlList unresolvedSet, boolean acceptsSequences) {
    if (opType == OpTypes.VALUE) {
        return unresolvedSet;
    }
    switch(opType) {
        case OpTypes.CASEWHEN:
            acceptsSequences = false;
            break;
    }
    for (int i = 0; i < nodes.length; i++) {
        if (nodes[i] == null) {
            continue;
        }
        unresolvedSet = nodes[i].resolveColumnReferences(rangeVarArray, rangeCount, unresolvedSet, acceptsSequences);
    }
    return unresolvedSet;
}

19 View Complete Implementation : ParserCommand.java
Copyright GNU General Public License v3.0
Author : apavlo
private Statement compileSetTimeZone() {
    Expression e;
    readThis(Tokens.ZONE);
    if (token.tokenType == Tokens.LOCAL) {
        read();
        e = new ExpressionValue(null, Type.SQL_VARCHAR);
    } else {
        e = XreadIntervalValueExpression();
        HsqlList unresolved = e.resolveColumnReferences(RangeVariable.emptyArray, null);
        ExpressionColumn.checkColumnsResolved(unresolved);
        e.resolveTypes(session, null);
        if (e.dataType == null) {
            throw Error.error(ErrorCode.X_42565);
        }
        if (e.dataType.typeCode != Types.SQL_INTERVAL_HOUR_TO_MINUTE) {
            throw Error.error(ErrorCode.X_42565);
        }
    }
    String sql = getLastPart();
    return new StatementSession(StatementTypes.SET_TIME_ZONE, new Expression[] { e });
}

19 View Complete Implementation : ParserRoutine.java
Copyright GNU General Public License v3.0
Author : apavlo
private Statement readReturnValue(Routine routine, StatementCompound context) {
    Expression e = XreadValueExpressionOrNull();
    if (e == null) {
        checkIsValue();
        if (token.tokenValue == null) {
            e = new ExpressionValue(null, null);
        }
    }
    RangeVariable[] rangeVars = routine.getParameterRangeVariables();
    if (context != null) {
        rangeVars = context.getRangeVariables();
    }
    HsqlList list = e.resolveColumnReferences(rangeVars, rangeVars.length, null, false);
    ExpressionColumn.checkColumnsResolved(list);
    e.resolveTypes(session, null);
    return new StatementSimple(StatementTypes.RETURN, e);
}

19 View Complete Implementation : QueryExpression.java
Copyright GNU General Public License v3.0
Author : apavlo
public void resolve(Session session, RangeVariable[] outerRanges) {
    resolveReferences(session);
    if (unresolvedExpressions != null) {
        for (int i = 0; i < unresolvedExpressions.size(); i++) {
            Expression e = (Expression) unresolvedExpressions.get(i);
            HsqlList list = e.resolveColumnReferences(outerRanges, null);
            ExpressionColumn.checkColumnsResolved(list);
        }
    }
    resolveTypes(session);
}

19 View Complete Implementation : QueryExpression.java
Copyright GNU General Public License v3.0
Author : apavlo
private void addUnresolvedExpressions(HsqlList expressions) {
    if (expressions == null) {
        return;
    }
    if (unresolvedExpressions == null) {
        unresolvedExpressions = new ArrayListIdenreplacedy();
    }
    unresolvedExpressions.addAll(expressions);
}

19 View Complete Implementation : QueryExpression.java
Copyright GNU General Public License v3.0
Author : apavlo
/**
 * Implementation of an SQL query expression
 *
 * @author Fred Toussi (fredt@users dot sourceforge.net)
 * @version 1.9.0
 * @since 1.9.0
 */
/**
 * @todo 1.9.0 - review these
 * - work out usage of getMainSelect etc and add relevant methods
 * - Result metadata for the final result of QueryExpression
 */
public clreplaced QueryExpression {

    public static final int NOUNION = 0, UNION = 1, UNION_ALL = 2, INTERSECT = 3, INTERSECT_ALL = 4, EXCEPT_ALL = 5, EXCEPT = 6, UNION_TERM = 7;

    // 
    int columnCount;

    private QueryExpression leftQueryExpression;

    private QueryExpression rightQueryExpression;

    SortAndSlice sortAndSlice;

    private int unionType;

    private boolean unionCorresponding;

    private OrderedHashSet unionCorrespondingColumns;

    int[] unionColumnMap;

    Type[] unionColumnTypes;

    boolean isFullOrder;

    // 
    HsqlList unresolvedExpressions;

    // 
    boolean isResolved;

    // 
    int persistenceScope = TableBase.SCOPE_STATEMENT;

    // 
    int columnMode = TableBase.COLUMNS_REFERENCED;

    // 
    ResultMetaData resultMetaData;

    boolean[] accessibleColumns;

    // 
    View view;

    boolean isUpdatable;

    boolean isInsertable;

    boolean isCheckable;

    boolean isTopLevel;

    // 
    public TableBase resultTable;

    public Index mainIndex;

    public Index fullIndex;

    public Index orderIndex;

    // 
    CompileContext compileContext;

    QueryExpression(CompileContext compileContext) {
        this.compileContext = compileContext;
        sortAndSlice = SortAndSlice.noSort;
    }

    public QueryExpression(CompileContext compileContext, QueryExpression leftQueryExpression) {
        this(compileContext);
        sortAndSlice = SortAndSlice.noSort;
        this.leftQueryExpression = leftQueryExpression;
    }

    void addUnion(QueryExpression queryExpression, int unionType) {
        sortAndSlice = SortAndSlice.noSort;
        this.rightQueryExpression = queryExpression;
        this.unionType = unionType;
        setFullOrder();
    }

    void addSortAndSlice(SortAndSlice sortAndSlice) {
        this.sortAndSlice = sortAndSlice;
        sortAndSlice.sortUnion = true;
    }

    public void setUnionCorresoponding() {
        unionCorresponding = true;
    }

    public void setUnionCorrespondingColumns(OrderedHashSet names) {
        unionCorrespondingColumns = names;
    }

    public void setFullOrder() {
        isFullOrder = true;
        if (leftQueryExpression == null) {
            return;
        }
        leftQueryExpression.setFullOrder();
        rightQueryExpression.setFullOrder();
    }

    public void resolve(Session session) {
        resolveReferences(session);
        ExpressionColumn.checkColumnsResolved(unresolvedExpressions);
        resolveTypes(session);
    }

    public void resolve(Session session, RangeVariable[] outerRanges) {
        resolveReferences(session);
        if (unresolvedExpressions != null) {
            for (int i = 0; i < unresolvedExpressions.size(); i++) {
                Expression e = (Expression) unresolvedExpressions.get(i);
                HsqlList list = e.resolveColumnReferences(outerRanges, null);
                ExpressionColumn.checkColumnsResolved(list);
            }
        }
        resolveTypes(session);
    }

    public void resolveReferences(Session session) {
        leftQueryExpression.resolveReferences(session);
        rightQueryExpression.resolveReferences(session);
        addUnresolvedExpressions(leftQueryExpression.unresolvedExpressions);
        addUnresolvedExpressions(rightQueryExpression.unresolvedExpressions);
        if (!unionCorresponding) {
            columnCount = leftQueryExpression.getColumnCount();
            int rightCount = rightQueryExpression.getColumnCount();
            if (columnCount != rightCount) {
                throw Error.error(ErrorCode.X_42594);
            }
            unionColumnTypes = new Type[columnCount];
            leftQueryExpression.unionColumnMap = rightQueryExpression.unionColumnMap = new int[columnCount];
            ArrayUtil.fillSequence(leftQueryExpression.unionColumnMap);
            resolveColumnRefernecesInUnionOrderBy();
            return;
        }
        String[] leftNames = leftQueryExpression.getColumnNames();
        String[] rightNames = rightQueryExpression.getColumnNames();
        if (unionCorrespondingColumns == null) {
            unionCorrespondingColumns = new OrderedHashSet();
            OrderedIntHashSet leftColumns = new OrderedIntHashSet();
            OrderedIntHashSet rightColumns = new OrderedIntHashSet();
            for (int i = 0; i < leftNames.length; i++) {
                String name = leftNames[i];
                int index = ArrayUtil.find(rightNames, name);
                if (name.length() > 0 && index != -1) {
                    leftColumns.add(i);
                    rightColumns.add(index);
                    unionCorrespondingColumns.add(name);
                }
            }
            if (unionCorrespondingColumns.isEmpty()) {
                throw Error.error(ErrorCode.X_42579);
            }
            leftQueryExpression.unionColumnMap = leftColumns.toArray();
            rightQueryExpression.unionColumnMap = rightColumns.toArray();
        } else {
            leftQueryExpression.unionColumnMap = new int[unionCorrespondingColumns.size()];
            rightQueryExpression.unionColumnMap = new int[unionCorrespondingColumns.size()];
            for (int i = 0; i < unionCorrespondingColumns.size(); i++) {
                String name = (String) unionCorrespondingColumns.get(i);
                int index = ArrayUtil.find(leftNames, name);
                if (index == -1) {
                    throw Error.error(ErrorCode.X_42579);
                }
                leftQueryExpression.unionColumnMap[i] = index;
                index = ArrayUtil.find(rightNames, name);
                if (index == -1) {
                    throw Error.error(ErrorCode.X_42579);
                }
                rightQueryExpression.unionColumnMap[i] = index;
            }
        }
        columnCount = unionCorrespondingColumns.size();
        unionColumnTypes = new Type[columnCount];
        resolveColumnRefernecesInUnionOrderBy();
    }

    /**
     * Only simple column reference or column position allowed
     */
    void resolveColumnRefernecesInUnionOrderBy() {
        int orderCount = sortAndSlice.getOrderLength();
        if (orderCount == 0) {
            return;
        }
        String[] unionColumnNames = getColumnNames();
        for (int i = 0; i < orderCount; i++) {
            Expression sort = (Expression) sortAndSlice.exprList.get(i);
            Expression e = sort.getLeftNode();
            if (e.getType() == OpTypes.VALUE) {
                if (e.getDataType().typeCode == Types.SQL_INTEGER) {
                    int index = ((Integer) e.getValue(null)).intValue();
                    if (0 < index && index <= unionColumnNames.length) {
                        sort.getLeftNode().queryTableColumnIndex = index - 1;
                        continue;
                    }
                }
            } else if (e.getType() == OpTypes.COLUMN) {
                int index = ArrayUtil.find(unionColumnNames, e.getColumnName());
                if (index >= 0) {
                    sort.getLeftNode().queryTableColumnIndex = index;
                    continue;
                }
            }
            throw Error.error(ErrorCode.X_42576);
        }
        sortAndSlice.prepare(null);
    }

    private void addUnresolvedExpressions(HsqlList expressions) {
        if (expressions == null) {
            return;
        }
        if (unresolvedExpressions == null) {
            unresolvedExpressions = new ArrayListIdenreplacedy();
        }
        unresolvedExpressions.addAll(expressions);
    }

    public void resolveTypes(Session session) {
        if (isResolved) {
            return;
        }
        resolveTypesPartOne(session);
        resolveTypesPartTwo(session);
        isResolved = true;
    }

    void resolveTypesPartOne(Session session) {
        ArrayUtil.projectRowReverse(leftQueryExpression.unionColumnTypes, leftQueryExpression.unionColumnMap, unionColumnTypes);
        leftQueryExpression.resolveTypesPartOne(session);
        ArrayUtil.projectRow(leftQueryExpression.unionColumnTypes, leftQueryExpression.unionColumnMap, unionColumnTypes);
        ArrayUtil.projectRowReverse(rightQueryExpression.unionColumnTypes, rightQueryExpression.unionColumnMap, unionColumnTypes);
        rightQueryExpression.resolveTypesPartOne(session);
        ArrayUtil.projectRow(rightQueryExpression.unionColumnTypes, rightQueryExpression.unionColumnMap, unionColumnTypes);
    }

    void resolveTypesPartTwo(Session session) {
        ArrayUtil.projectRowReverse(leftQueryExpression.unionColumnTypes, leftQueryExpression.unionColumnMap, unionColumnTypes);
        leftQueryExpression.resolveTypesPartTwo(session);
        ArrayUtil.projectRowReverse(rightQueryExpression.unionColumnTypes, rightQueryExpression.unionColumnMap, unionColumnTypes);
        rightQueryExpression.resolveTypesPartTwo(session);
        // 
        if (unionCorresponding) {
            resultMetaData = leftQueryExpression.getMetaData().getNewMetaData(leftQueryExpression.unionColumnMap);
            createTable(session);
        }
        if (sortAndSlice.hasOrder()) {
            QueryExpression queryExpression = this;
            while (true) {
                if (queryExpression.leftQueryExpression == null || queryExpression.unionCorresponding) {
                    sortAndSlice.setIndex(queryExpression.resultTable);
                    break;
                }
                queryExpression = queryExpression.leftQueryExpression;
            }
        }
    }

    public Object[] getValues(Session session) {
        Result r = getResult(session, 2);
        int size = r.getNavigator().getSize();
        if (size == 0) {
            return new Object[r.metaData.getColumnCount()];
        } else if (size == 1) {
            return r.getSingleRowData();
        } else {
            throw Error.error(ErrorCode.X_21000);
        }
    }

    public Object[] getSingleRowValues(Session session) {
        Result r = getResult(session, 2);
        int size = r.getNavigator().getSize();
        if (size == 0) {
            return null;
        } else if (size == 1) {
            return r.getSingleRowData();
        } else {
            throw Error.error(ErrorCode.X_21000);
        }
    }

    public Object getValue(Session session) {
        Object[] values = getValues(session);
        return values[0];
    }

    Result getResult(Session session, int maxRows) {
        int currentMaxRows = unionType == UNION_ALL ? maxRows : Integer.MAX_VALUE;
        Result first = leftQueryExpression.getResult(session, currentMaxRows);
        RowSetNavigatorData navigator = (RowSetNavigatorData) first.getNavigator();
        Result second = rightQueryExpression.getResult(session, currentMaxRows);
        RowSetNavigatorData rightNavigator = (RowSetNavigatorData) second.getNavigator();
        if (unionCorresponding) {
            RowSetNavigatorData rowSet = new RowSetNavigatorData(session, this);
            rowSet.copy(navigator, leftQueryExpression.unionColumnMap);
            navigator = rowSet;
            first.setNavigator(navigator);
            first.metaData = this.getMetaData();
            rowSet = new RowSetNavigatorData(session, this);
            if (unionType != UNION && unionType != UNION_ALL) {
                rowSet.copy(rightNavigator, rightQueryExpression.unionColumnMap);
                rightNavigator = rowSet;
            }
        }
        switch(unionType) {
            case UNION:
                navigator.union(rightNavigator, rightQueryExpression.unionColumnMap);
                break;
            case UNION_ALL:
                navigator.unionAll(rightNavigator, rightQueryExpression.unionColumnMap);
                break;
            case INTERSECT:
                navigator.intersect(rightNavigator);
                break;
            case INTERSECT_ALL:
                navigator.intersectAll(rightNavigator);
                break;
            case EXCEPT:
                navigator.except(rightNavigator);
                break;
            case EXCEPT_ALL:
                navigator.exceptAll(rightNavigator);
                break;
            default:
                throw Error.runtimeError(ErrorCode.U_S0500, "QueryExpression");
        }
        if (sortAndSlice.hasOrder()) {
            RowSetNavigatorData nav = (RowSetNavigatorData) first.getNavigator();
            nav.sortUnion(sortAndSlice);
            nav.trim(sortAndSlice.getLimitStart(session), sortAndSlice.getLimitCount(session, maxRows));
        }
        navigator.reset();
        return first;
    }

    public boolean isSingleColumn() {
        return leftQueryExpression.isSingleColumn();
    }

    public ResultMetaData getMetaData() {
        if (resultMetaData != null) {
            return resultMetaData;
        }
        return leftQueryExpression.getMetaData();
    }

    public QuerySpecification getMainSelect() {
        if (leftQueryExpression == null) {
            return (QuerySpecification) this;
        }
        return leftQueryExpression.getMainSelect();
    }

    /**
     * @todo 1.9.0 review
     */
    public String describe(Session session) {
        return leftQueryExpression.describe(session);
    }

    public HsqlList getUnresolvedExpressions() {
        return unresolvedExpressions;
    }

    public boolean areColumnsResolved() {
        return unresolvedExpressions == null || unresolvedExpressions.isEmpty();
    }

    String[] getColumnNames() {
        if (unionCorrespondingColumns == null) {
            return leftQueryExpression.getColumnNames();
        }
        String[] names = new String[unionCorrespondingColumns.size()];
        unionCorrespondingColumns.toArray(names);
        return names;
    }

    public Type[] getColumnTypes() {
        return unionColumnTypes;
    }

    public int getColumnCount() {
        if (unionCorrespondingColumns == null) {
            int left = leftQueryExpression.getColumnCount();
            int right = rightQueryExpression.getColumnCount();
            if (left != right) {
                throw Error.error(ErrorCode.X_42594);
            }
            return left;
        }
        return unionCorrespondingColumns.size();
    }

    public void collectAllExpressions(HsqlList set, OrderedIntHashSet typeSet, OrderedIntHashSet stopAtTypeSet) {
        leftQueryExpression.collectAllExpressions(set, typeSet, stopAtTypeSet);
        if (rightQueryExpression != null) {
            rightQueryExpression.collectAllExpressions(set, typeSet, stopAtTypeSet);
        }
    }

    public void collectObjectNames(Set set) {
        leftQueryExpression.collectObjectNames(set);
        if (rightQueryExpression != null) {
            rightQueryExpression.collectObjectNames(set);
        }
    }

    public HashMappedList getColumns() {
        this.getResultTable();
        return ((TableDerived) getResultTable()).columnList;
    }

    /**
     * Used prior to type resolution
     */
    public void setView(View view) {
        this.view = view;
    }

    /**
     * Used in views after full type resolution
     */
    public void setTableColumnNames(HashMappedList list) {
        if (resultTable != null) {
            ((TableDerived) resultTable).columnList = list;
            return;
        }
        leftQueryExpression.setTableColumnNames(list);
    }

    void createTable(Session session) {
        createResultTable(session);
        mainIndex = resultTable.getPrimaryIndex();
        if (sortAndSlice.hasOrder()) {
            orderIndex = resultTable.createAndAddIndexStructure(null, sortAndSlice.sortOrder, sortAndSlice.sortDescending, sortAndSlice.sortNullsLast, false, false, false);
        }
        int[] fullCols = new int[columnCount];
        ArrayUtil.fillSequence(fullCols);
        fullIndex = resultTable.createAndAddIndexStructure(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 = leftQueryExpression.getUnionColumns();
        try {
            resultTable = new TableDerived(session.database, tableName, tableType, unionColumnTypes, columnList, null);
        } catch (Exception e) {
        }
    }

    public void setColumnsDefined() {
        columnMode = TableBase.COLUMNS_REFERENCED;
        if (leftQueryExpression != null) {
            leftQueryExpression.setColumnsDefined();
        }
    }

    /**
     * Not for views. Only used on root node.
     */
    public void setAsTopLevel() {
        if (compileContext.getSequences().length > 0) {
            throw Error.error(ErrorCode.X_42598);
        }
        isTopLevel = true;
        setReturningResultSet();
    }

    /**
     * Sets the scope to SESSION for the QueryExpression object that creates
     * the table
     */
    void setReturningResultSet() {
        if (unionCorresponding) {
            persistenceScope = TableBase.SCOPE_SESSION;
            columnMode = TableBase.COLUMNS_UNREFERENCED;
            return;
        }
        leftQueryExpression.setReturningResultSet();
    }

    private HashMappedList getUnionColumns() {
        if (unionCorresponding || leftQueryExpression == null) {
            HashMappedList columns = ((TableDerived) resultTable).columnList;
            HashMappedList list = new HashMappedList();
            for (int i = 0; i < unionColumnMap.length; i++) {
                ColumnSchema column = (ColumnSchema) columns.get(i);
                list.add(column.getName().name, column);
            }
            return list;
        }
        return leftQueryExpression.getUnionColumns();
    }

    public HsqlName[] getResultColumnNames() {
        if (resultTable == null) {
            return leftQueryExpression.getResultColumnNames();
        }
        HashMappedList list = ((TableDerived) resultTable).columnList;
        HsqlName[] resultColumnNames = new HsqlName[list.size()];
        for (int i = 0; i < resultColumnNames.length; i++) {
            resultColumnNames[i] = ((ColumnSchema) list.get(i)).getName();
        }
        return resultColumnNames;
    }

    public TableBase getResultTable() {
        if (resultTable != null) {
            return resultTable;
        }
        if (leftQueryExpression != null) {
            return leftQueryExpression.getResultTable();
        }
        return null;
    }

    // 
    public Table getBaseTable() {
        return null;
    }

    public boolean isUpdatable() {
        return isUpdatable;
    }

    public boolean isInsertable() {
        return isInsertable;
    }

    public int[] getBaseTableColumnMap() {
        return null;
    }

    public Expression getCheckCondition() {
        return null;
    }

    public boolean hasReference(RangeVariable range) {
        if (leftQueryExpression.hasReference(range)) {
            return true;
        }
        if (rightQueryExpression.hasReference(range)) {
            return true;
        }
        return false;
    }

    void getBaseTableNames(OrderedHashSet set) {
        leftQueryExpression.getBaseTableNames(set);
        rightQueryExpression.getBaseTableNames(set);
    }
}

19 View Complete Implementation : QueryExpression.java
Copyright GNU General Public License v3.0
Author : s-store
/**
 * Implementation of an SQL query expression
 *
 * @author Fred Toussi (fredt@users dot sourceforge.net)
 * @version 1.9.0
 * @since 1.9.0
 */
/**
 * @todo 1.9.0 - review these
 * - work out usage of getMainSelect etc and add relevant methods
 * - Result metadata for the final result of QueryExpression
 */
public clreplaced QueryExpression {

    public static final int NOUNION = 0, UNION = 1, UNION_ALL = 2, INTERSECT = 3, INTERSECT_ALL = 4, EXCEPT_ALL = 5, EXCEPT = 6, UNION_TERM = 7;

    // 
    int columnCount;

    private QueryExpression leftQueryExpression;

    private QueryExpression rightQueryExpression;

    SortAndSlice sortAndSlice;

    private int unionType;

    private boolean unionCorresponding;

    private OrderedHashSet unionCorrespondingColumns;

    int[] unionColumnMap;

    Type[] unionColumnTypes;

    boolean isFullOrder;

    // 
    HsqlList unresolvedExpressions;

    // 
    boolean isResolved;

    // 
    int persistenceScope = TableBase.SCOPE_STATEMENT;

    // 
    int columnMode = TableBase.COLUMNS_REFERENCED;

    // 
    ResultMetaData resultMetaData;

    boolean[] accessibleColumns;

    // 
    View view;

    boolean isUpdatable;

    boolean isInsertable;

    boolean isCheckable;

    boolean isTopLevel;

    // 
    public TableBase resultTable;

    public Index mainIndex;

    public Index fullIndex;

    public Index orderIndex;

    // 
    CompileContext compileContext;

    QueryExpression(CompileContext compileContext) {
        this.compileContext = compileContext;
        sortAndSlice = SortAndSlice.noSort;
    }

    public QueryExpression(CompileContext compileContext, QueryExpression leftQueryExpression) {
        this(compileContext);
        sortAndSlice = SortAndSlice.noSort;
        this.leftQueryExpression = leftQueryExpression;
    }

    void addUnion(QueryExpression queryExpression, int unionType) {
        sortAndSlice = SortAndSlice.noSort;
        this.rightQueryExpression = queryExpression;
        this.unionType = unionType;
        setFullOrder();
    }

    void addSortAndSlice(SortAndSlice sortAndSlice) {
        this.sortAndSlice = sortAndSlice;
        sortAndSlice.sortUnion = true;
    }

    public void setUnionCorresoponding() {
        unionCorresponding = true;
    }

    public void setUnionCorrespondingColumns(OrderedHashSet names) {
        unionCorrespondingColumns = names;
    }

    public void setFullOrder() {
        isFullOrder = true;
        if (leftQueryExpression == null) {
            return;
        }
        leftQueryExpression.setFullOrder();
        rightQueryExpression.setFullOrder();
    }

    public void resolve(Session session) {
        resolveReferences(session);
        ExpressionColumn.checkColumnsResolved(unresolvedExpressions);
        resolveTypes(session);
    }

    public void resolve(Session session, RangeVariable[] outerRanges) {
        resolveReferences(session);
        if (unresolvedExpressions != null) {
            for (int i = 0; i < unresolvedExpressions.size(); i++) {
                Expression e = (Expression) unresolvedExpressions.get(i);
                HsqlList list = e.resolveColumnReferences(outerRanges, null);
                ExpressionColumn.checkColumnsResolved(list);
            }
        }
        resolveTypes(session);
    }

    public void resolveReferences(Session session) {
        leftQueryExpression.resolveReferences(session);
        rightQueryExpression.resolveReferences(session);
        addUnresolvedExpressions(leftQueryExpression.unresolvedExpressions);
        addUnresolvedExpressions(rightQueryExpression.unresolvedExpressions);
        if (!unionCorresponding) {
            columnCount = leftQueryExpression.getColumnCount();
            int rightCount = rightQueryExpression.getColumnCount();
            if (columnCount != rightCount) {
                throw Error.error(ErrorCode.X_42594);
            }
            unionColumnTypes = new Type[columnCount];
            leftQueryExpression.unionColumnMap = rightQueryExpression.unionColumnMap = new int[columnCount];
            ArrayUtil.fillSequence(leftQueryExpression.unionColumnMap);
            resolveColumnRefernecesInUnionOrderBy();
            return;
        }
        String[] leftNames = leftQueryExpression.getColumnNames();
        String[] rightNames = rightQueryExpression.getColumnNames();
        if (unionCorrespondingColumns == null) {
            unionCorrespondingColumns = new OrderedHashSet();
            OrderedIntHashSet leftColumns = new OrderedIntHashSet();
            OrderedIntHashSet rightColumns = new OrderedIntHashSet();
            for (int i = 0; i < leftNames.length; i++) {
                String name = leftNames[i];
                int index = ArrayUtil.find(rightNames, name);
                if (name.length() > 0 && index != -1) {
                    leftColumns.add(i);
                    rightColumns.add(index);
                    unionCorrespondingColumns.add(name);
                }
            }
            if (unionCorrespondingColumns.isEmpty()) {
                throw Error.error(ErrorCode.X_42579);
            }
            leftQueryExpression.unionColumnMap = leftColumns.toArray();
            rightQueryExpression.unionColumnMap = rightColumns.toArray();
        } else {
            leftQueryExpression.unionColumnMap = new int[unionCorrespondingColumns.size()];
            rightQueryExpression.unionColumnMap = new int[unionCorrespondingColumns.size()];
            for (int i = 0; i < unionCorrespondingColumns.size(); i++) {
                String name = (String) unionCorrespondingColumns.get(i);
                int index = ArrayUtil.find(leftNames, name);
                if (index == -1) {
                    throw Error.error(ErrorCode.X_42579);
                }
                leftQueryExpression.unionColumnMap[i] = index;
                index = ArrayUtil.find(rightNames, name);
                if (index == -1) {
                    throw Error.error(ErrorCode.X_42579);
                }
                rightQueryExpression.unionColumnMap[i] = index;
            }
        }
        columnCount = unionCorrespondingColumns.size();
        unionColumnTypes = new Type[columnCount];
        resolveColumnRefernecesInUnionOrderBy();
    }

    /**
     * Only simple column reference or column position allowed
     */
    void resolveColumnRefernecesInUnionOrderBy() {
        int orderCount = sortAndSlice.getOrderLength();
        if (orderCount == 0) {
            return;
        }
        String[] unionColumnNames = getColumnNames();
        for (int i = 0; i < orderCount; i++) {
            Expression sort = (Expression) sortAndSlice.exprList.get(i);
            Expression e = sort.getLeftNode();
            if (e.getType() == OpTypes.VALUE) {
                if (e.getDataType().typeCode == Types.SQL_INTEGER) {
                    int index = ((Integer) e.getValue(null)).intValue();
                    if (0 < index && index <= unionColumnNames.length) {
                        sort.getLeftNode().queryTableColumnIndex = index - 1;
                        continue;
                    }
                }
            } else if (e.getType() == OpTypes.COLUMN) {
                int index = ArrayUtil.find(unionColumnNames, e.getColumnName());
                if (index >= 0) {
                    sort.getLeftNode().queryTableColumnIndex = index;
                    continue;
                }
            }
            throw Error.error(ErrorCode.X_42576);
        }
        sortAndSlice.prepare(null);
    }

    private void addUnresolvedExpressions(HsqlList expressions) {
        if (expressions == null) {
            return;
        }
        if (unresolvedExpressions == null) {
            unresolvedExpressions = new ArrayListIdenreplacedy();
        }
        unresolvedExpressions.addAll(expressions);
    }

    public void resolveTypes(Session session) {
        if (isResolved) {
            return;
        }
        resolveTypesPartOne(session);
        resolveTypesPartTwo(session);
        isResolved = true;
    }

    void resolveTypesPartOne(Session session) {
        ArrayUtil.projectRowReverse(leftQueryExpression.unionColumnTypes, leftQueryExpression.unionColumnMap, unionColumnTypes);
        leftQueryExpression.resolveTypesPartOne(session);
        ArrayUtil.projectRow(leftQueryExpression.unionColumnTypes, leftQueryExpression.unionColumnMap, unionColumnTypes);
        ArrayUtil.projectRowReverse(rightQueryExpression.unionColumnTypes, rightQueryExpression.unionColumnMap, unionColumnTypes);
        rightQueryExpression.resolveTypesPartOne(session);
        ArrayUtil.projectRow(rightQueryExpression.unionColumnTypes, rightQueryExpression.unionColumnMap, unionColumnTypes);
    }

    void resolveTypesPartTwo(Session session) {
        ArrayUtil.projectRowReverse(leftQueryExpression.unionColumnTypes, leftQueryExpression.unionColumnMap, unionColumnTypes);
        leftQueryExpression.resolveTypesPartTwo(session);
        ArrayUtil.projectRowReverse(rightQueryExpression.unionColumnTypes, rightQueryExpression.unionColumnMap, unionColumnTypes);
        rightQueryExpression.resolveTypesPartTwo(session);
        // 
        if (unionCorresponding) {
            resultMetaData = leftQueryExpression.getMetaData().getNewMetaData(leftQueryExpression.unionColumnMap);
            createTable(session);
        }
        if (sortAndSlice.hasOrder()) {
            QueryExpression queryExpression = this;
            while (true) {
                if (queryExpression.leftQueryExpression == null || queryExpression.unionCorresponding) {
                    sortAndSlice.setIndex(queryExpression.resultTable);
                    break;
                }
                queryExpression = queryExpression.leftQueryExpression;
            }
        }
    }

    public Object[] getValues(Session session) {
        Result r = getResult(session, 2);
        int size = r.getNavigator().getSize();
        if (size == 0) {
            return new Object[r.metaData.getColumnCount()];
        } else if (size == 1) {
            return r.getSingleRowData();
        } else {
            throw Error.error(ErrorCode.X_21000);
        }
    }

    public Object[] getSingleRowValues(Session session) {
        Result r = getResult(session, 2);
        int size = r.getNavigator().getSize();
        if (size == 0) {
            return null;
        } else if (size == 1) {
            return r.getSingleRowData();
        } else {
            throw Error.error(ErrorCode.X_21000);
        }
    }

    public Object getValue(Session session) {
        Object[] values = getValues(session);
        return values[0];
    }

    Result getResult(Session session, int maxRows) {
        int currentMaxRows = unionType == UNION_ALL ? maxRows : Integer.MAX_VALUE;
        Result first = leftQueryExpression.getResult(session, currentMaxRows);
        RowSetNavigatorData navigator = (RowSetNavigatorData) first.getNavigator();
        Result second = rightQueryExpression.getResult(session, currentMaxRows);
        RowSetNavigatorData rightNavigator = (RowSetNavigatorData) second.getNavigator();
        if (unionCorresponding) {
            RowSetNavigatorData rowSet = new RowSetNavigatorData(session, this);
            rowSet.copy(navigator, leftQueryExpression.unionColumnMap);
            navigator = rowSet;
            first.setNavigator(navigator);
            first.metaData = this.getMetaData();
            rowSet = new RowSetNavigatorData(session, this);
            if (unionType != UNION && unionType != UNION_ALL) {
                rowSet.copy(rightNavigator, rightQueryExpression.unionColumnMap);
                rightNavigator = rowSet;
            }
        }
        switch(unionType) {
            case UNION:
                navigator.union(rightNavigator, rightQueryExpression.unionColumnMap);
                break;
            case UNION_ALL:
                navigator.unionAll(rightNavigator, rightQueryExpression.unionColumnMap);
                break;
            case INTERSECT:
                navigator.intersect(rightNavigator);
                break;
            case INTERSECT_ALL:
                navigator.intersectAll(rightNavigator);
                break;
            case EXCEPT:
                navigator.except(rightNavigator);
                break;
            case EXCEPT_ALL:
                navigator.exceptAll(rightNavigator);
                break;
            default:
                throw Error.runtimeError(ErrorCode.U_S0500, "QueryExpression");
        }
        if (sortAndSlice.hasOrder()) {
            RowSetNavigatorData nav = (RowSetNavigatorData) first.getNavigator();
            nav.sortUnion(sortAndSlice);
            nav.trim(sortAndSlice.getLimitStart(session), sortAndSlice.getLimitCount(session, maxRows));
        }
        navigator.reset();
        return first;
    }

    public boolean isSingleColumn() {
        return leftQueryExpression.isSingleColumn();
    }

    public ResultMetaData getMetaData() {
        if (resultMetaData != null) {
            return resultMetaData;
        }
        return leftQueryExpression.getMetaData();
    }

    public QuerySpecification getMainSelect() {
        if (leftQueryExpression == null) {
            return (QuerySpecification) this;
        }
        return leftQueryExpression.getMainSelect();
    }

    /**
     * @todo 1.9.0 review
     */
    public String describe(Session session) {
        return leftQueryExpression.describe(session);
    }

    public HsqlList getUnresolvedExpressions() {
        return unresolvedExpressions;
    }

    public boolean areColumnsResolved() {
        return unresolvedExpressions == null || unresolvedExpressions.isEmpty();
    }

    String[] getColumnNames() {
        if (unionCorrespondingColumns == null) {
            return leftQueryExpression.getColumnNames();
        }
        String[] names = new String[unionCorrespondingColumns.size()];
        unionCorrespondingColumns.toArray(names);
        return names;
    }

    public Type[] getColumnTypes() {
        return unionColumnTypes;
    }

    public int getColumnCount() {
        if (unionCorrespondingColumns == null) {
            int left = leftQueryExpression.getColumnCount();
            int right = rightQueryExpression.getColumnCount();
            if (left != right) {
                throw Error.error(ErrorCode.X_42594);
            }
            return left;
        }
        return unionCorrespondingColumns.size();
    }

    public void collectAllExpressions(HsqlList set, OrderedIntHashSet typeSet, OrderedIntHashSet stopAtTypeSet) {
        leftQueryExpression.collectAllExpressions(set, typeSet, stopAtTypeSet);
        if (rightQueryExpression != null) {
            rightQueryExpression.collectAllExpressions(set, typeSet, stopAtTypeSet);
        }
    }

    public void collectObjectNames(Set set) {
        leftQueryExpression.collectObjectNames(set);
        if (rightQueryExpression != null) {
            rightQueryExpression.collectObjectNames(set);
        }
    }

    public HashMappedList getColumns() {
        this.getResultTable();
        return ((TableDerived) getResultTable()).columnList;
    }

    /**
     * Used prior to type resolution
     */
    public void setView(View view) {
        this.view = view;
    }

    /**
     * Used in views after full type resolution
     */
    public void setTableColumnNames(HashMappedList list) {
        if (resultTable != null) {
            ((TableDerived) resultTable).columnList = list;
            return;
        }
        leftQueryExpression.setTableColumnNames(list);
    }

    void createTable(Session session) {
        createResultTable(session);
        mainIndex = resultTable.getPrimaryIndex();
        if (sortAndSlice.hasOrder()) {
            orderIndex = resultTable.createAndAddIndexStructure(null, sortAndSlice.sortOrder, sortAndSlice.sortDescending, sortAndSlice.sortNullsLast, false, false, false);
        }
        int[] fullCols = new int[columnCount];
        ArrayUtil.fillSequence(fullCols);
        fullIndex = resultTable.createAndAddIndexStructure(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 = leftQueryExpression.getUnionColumns();
        try {
            resultTable = new TableDerived(session.database, tableName, tableType, unionColumnTypes, columnList, null);
        } catch (Exception e) {
        }
    }

    public void setColumnsDefined() {
        columnMode = TableBase.COLUMNS_REFERENCED;
        if (leftQueryExpression != null) {
            leftQueryExpression.setColumnsDefined();
        }
    }

    /**
     * Not for views. Only used on root node.
     */
    public void setAsTopLevel() {
        if (compileContext.getSequences().length > 0) {
            throw Error.error(ErrorCode.X_42598);
        }
        isTopLevel = true;
        setReturningResultSet();
    }

    /**
     * Sets the scope to SESSION for the QueryExpression object that creates
     * the table
     */
    void setReturningResultSet() {
        if (unionCorresponding) {
            persistenceScope = TableBase.SCOPE_SESSION;
            columnMode = TableBase.COLUMNS_UNREFERENCED;
            return;
        }
        leftQueryExpression.setReturningResultSet();
    }

    private HashMappedList getUnionColumns() {
        if (unionCorresponding || leftQueryExpression == null) {
            HashMappedList columns = ((TableDerived) resultTable).columnList;
            HashMappedList list = new HashMappedList();
            for (int i = 0; i < unionColumnMap.length; i++) {
                ColumnSchema column = (ColumnSchema) columns.get(i);
                list.add(column.getName().name, column);
            }
            return list;
        }
        return leftQueryExpression.getUnionColumns();
    }

    public HsqlName[] getResultColumnNames() {
        if (resultTable == null) {
            return leftQueryExpression.getResultColumnNames();
        }
        HashMappedList list = ((TableDerived) resultTable).columnList;
        HsqlName[] resultColumnNames = new HsqlName[list.size()];
        for (int i = 0; i < resultColumnNames.length; i++) {
            resultColumnNames[i] = ((ColumnSchema) list.get(i)).getName();
        }
        return resultColumnNames;
    }

    public TableBase getResultTable() {
        if (resultTable != null) {
            return resultTable;
        }
        if (leftQueryExpression != null) {
            return leftQueryExpression.getResultTable();
        }
        return null;
    }

    // 
    public Table getBaseTable() {
        return null;
    }

    public boolean isUpdatable() {
        return isUpdatable;
    }

    public boolean isInsertable() {
        return isInsertable;
    }

    public int[] getBaseTableColumnMap() {
        return null;
    }

    public Expression getCheckCondition() {
        return null;
    }

    public boolean hasReference(RangeVariable range) {
        if (leftQueryExpression.hasReference(range)) {
            return true;
        }
        if (rightQueryExpression.hasReference(range)) {
            return true;
        }
        return false;
    }

    void getBaseTableNames(OrderedHashSet set) {
        leftQueryExpression.getBaseTableNames(set);
        rightQueryExpression.getBaseTableNames(set);
    }

    CompileContext getCompileContext() {
        return compileContext;
    }
}

19 View Complete Implementation : ExpressionAccessor.java
Copyright Apache License 2.0
Author : SERG-Delft
public HsqlList resolveColumnReferences(Session session, RangeGroup rangeGroup, int rangeCount, RangeGroup[] rangeGroups, HsqlList unresolvedSet, boolean acceptsSequences) {
    for (int i = 0; i < nodes.length; i++) {
        if (nodes[i] == null) {
            continue;
        }
        unresolvedSet = nodes[i].resolveColumnReferences(session, rangeGroup, rangeCount, rangeGroups, unresolvedSet, acceptsSequences);
    }
    return unresolvedSet;
}

19 View Complete Implementation : ExpressionAggregate.java
Copyright Apache License 2.0
Author : SERG-Delft
public HsqlList resolveColumnReferences(Session session, RangeGroup rangeGroup, int rangeCount, RangeGroup[] rangeGroups, HsqlList unresolvedSet, boolean acceptsSequences) {
    HsqlList conditionSet = nodes[RIGHT].resolveColumnReferences(session, rangeGroup, rangeCount, rangeGroups, null, false);
    if (conditionSet != null) {
        ExpressionColumn.checkColumnsResolved(conditionSet);
    }
    if (unresolvedSet == null) {
        unresolvedSet = new ArrayListIdenreplacedy();
    }
    unresolvedSet.add(this);
    if (rangeGroup.getRangeVariables().length > 0) {
        this.rangeGroups = rangeGroups;
        this.rangeGroup = rangeGroup;
    }
    return unresolvedSet;
}

19 View Complete Implementation : ExpressionArithmetic.java
Copyright Apache License 2.0
Author : SERG-Delft
public HsqlList resolveColumnReferences(Session session, RangeGroup rangeGroup, int rangeCount, RangeGroup[] rangeGroups, HsqlList unresolvedSet, boolean acceptsSequences) {
    if (opType == OpTypes.VALUE) {
        return unresolvedSet;
    }
    for (int i = 0; i < nodes.length; i++) {
        if (nodes[i] == null) {
            continue;
        }
        unresolvedSet = nodes[i].resolveColumnReferences(session, rangeGroup, rangeCount, rangeGroups, unresolvedSet, acceptsSequences);
    }
    return unresolvedSet;
}

19 View Complete Implementation : ExpressionArrayAggregate.java
Copyright Apache License 2.0
Author : SERG-Delft
public HsqlList resolveColumnReferences(Session session, RangeGroup rangeGroup, int rangeCount, RangeGroup[] rangeGroups, HsqlList unresolvedSet, boolean acceptsSequences) {
    HsqlList conditionSet = condition.resolveColumnReferences(session, rangeGroup, rangeCount, rangeGroups, null, false);
    if (conditionSet != null) {
        ExpressionColumn.checkColumnsResolved(conditionSet);
    }
    if (unresolvedSet == null) {
        unresolvedSet = new ArrayListIdenreplacedy();
    }
    unresolvedSet.add(this);
    if (rangeGroup.getRangeVariables().length > 0) {
        this.rangeGroups = rangeGroups;
        this.rangeGroup = rangeGroup;
    }
    return unresolvedSet;
}

19 View Complete Implementation : ExpressionColumnAccessor.java
Copyright Apache License 2.0
Author : SERG-Delft
public HsqlList resolveColumnReferences(Session session, RangeGroup rangeGroup, int rangeCount, RangeGroup[] rangeGroups, HsqlList unresolvedSet, boolean acceptsSequences) {
    return unresolvedSet;
}

19 View Complete Implementation : ExpressionLike.java
Copyright Apache License 2.0
Author : SERG-Delft
public HsqlList resolveColumnReferences(Session session, RangeGroup rangeGroup, int rangeCount, RangeGroup[] rangeGroups, HsqlList unresolvedSet, boolean acceptsSequences) {
    for (int i = 0; i < nodes.length; i++) {
        if (nodes[i] != null) {
            unresolvedSet = nodes[i].resolveColumnReferences(session, rangeGroup, rangeCount, rangeGroups, unresolvedSet, acceptsSequences);
        }
    }
    return unresolvedSet;
}

19 View Complete Implementation : ExpressionOp.java
Copyright Apache License 2.0
Author : SERG-Delft
public HsqlList resolveColumnReferences(Session session, RangeGroup rangeGroup, int rangeCount, RangeGroup[] rangeGroups, HsqlList unresolvedSet, boolean acceptsSequences) {
    if (opType == OpTypes.VALUE) {
        return unresolvedSet;
    }
    switch(opType) {
        case OpTypes.CASEWHEN:
            acceptsSequences = false;
            break;
        default:
    }
    for (int i = 0; i < nodes.length; i++) {
        if (nodes[i] == null) {
            continue;
        }
        unresolvedSet = nodes[i].resolveColumnReferences(session, rangeGroup, rangeCount, rangeGroups, unresolvedSet, acceptsSequences);
    }
    return unresolvedSet;
}

19 View Complete Implementation : FunctionSQLInvoked.java
Copyright Apache License 2.0
Author : SERG-Delft
public HsqlList resolveColumnReferences(Session session, RangeGroup rangeGroup, int rangeCount, RangeGroup[] rangeGroups, HsqlList unresolvedSet, boolean acceptsSequences) {
    HsqlList conditionSet = condition.resolveColumnReferences(session, rangeGroup, rangeCount, rangeGroups, null, false);
    if (conditionSet != null) {
        ExpressionColumn.checkColumnsResolved(conditionSet);
    }
    if (isSelreplacedgregate()) {
        if (unresolvedSet == null) {
            unresolvedSet = new ArrayListIdenreplacedy();
        }
        unresolvedSet.add(this);
        return unresolvedSet;
    } else {
        return super.resolveColumnReferences(session, rangeGroup, rangeCount, rangeGroups, unresolvedSet, acceptsSequences);
    }
}

19 View Complete Implementation : QueryExpression.java
Copyright Apache License 2.0
Author : SERG-Delft
/**
 * Implementation of an SQL query expression
 *
 * @author Fred Toussi (fredt@users dot sourceforge.net)
 * @version 2.3.4
 * @since 1.9.0
 */
/**
 * @todo 1.9.0 - review these
 * - work out usage of getMainSelect etc and add relevant methods
 * - Result metadata for the final result of QueryExpression
 */
public clreplaced QueryExpression implements RangeGroup {

    public static final int NOUNION = 0, UNION = 1, UNION_ALL = 2, INTERSECT = 3, INTERSECT_ALL = 4, EXCEPT_ALL = 5, EXCEPT = 6, UNION_TERM = 7;

    // 
    int columnCount;

    private QueryExpression leftQueryExpression;

    private QueryExpression rightQueryExpression;

    SortAndSlice sortAndSlice;

    private int unionType;

    private boolean unionCorresponding;

    private OrderedHashSet unionCorrespondingColumns;

    int[] unionColumnMap;

    Type[] unionColumnTypes;

    boolean isFullOrder;

    // 
    HsqlList unresolvedExpressions;

    // 
    boolean isReferencesResolved;

    boolean isPartOneResolved;

    boolean isPartTwoResolved;

    boolean isResolved;

    // 
    int persistenceScope = TableBase.SCOPE_STATEMENT;

    // 
    ResultMetaData resultMetaData;

    boolean[] accessibleColumns;

    // 
    View view;

    boolean isBaseMergeable;

    boolean isMergeable;

    boolean isUpdatable;

    boolean isInsertable;

    boolean isCheckable;

    boolean isTopLevel;

    boolean isRecursive;

    boolean isSingleRow;

    boolean acceptsSequences;

    boolean isCorrelated;

    boolean isTable;

    boolean isValueList;

    // 
    TableDerived recursiveTable;

    // 
    public TableBase resultTable;

    public Index mainIndex;

    public Index fullIndex;

    public Index orderIndex;

    public Index idIndex;

    // 
    CompileContext compileContext;

    // 
    QueryExpression(CompileContext compileContext) {
        this.compileContext = compileContext;
        sortAndSlice = SortAndSlice.noSort;
    }

    public QueryExpression(CompileContext compileContext, QueryExpression leftQueryExpression) {
        this(compileContext);
        sortAndSlice = SortAndSlice.noSort;
        this.leftQueryExpression = leftQueryExpression;
    }

    public RangeVariable[] getRangeVariables() {
        return RangeVariable.emptyArray;
    }

    public void setCorrelated() {
        isCorrelated = true;
    }

    public boolean isVariable() {
        return false;
    }

    public void setSingleRow() {
        isSingleRow = true;
    }

    public boolean isRecursive() {
        return isRecursive;
    }

    void addUnion(QueryExpression queryExpression, int unionType) {
        sortAndSlice = SortAndSlice.noSort;
        this.rightQueryExpression = queryExpression;
        this.unionType = unionType;
        setFullOrder();
    }

    void addSortAndSlice(SortAndSlice sortAndSlice) {
        this.sortAndSlice = sortAndSlice;
        sortAndSlice.sortUnion = true;
    }

    public void setUnionCorresoponding() {
        unionCorresponding = true;
    }

    public void setUnionCorrespondingColumns(OrderedHashSet names) {
        unionCorrespondingColumns = names;
    }

    public void setFullOrder() {
        isFullOrder = true;
        if (leftQueryExpression != null) {
            leftQueryExpression.setFullOrder();
        }
        if (rightQueryExpression != null) {
            rightQueryExpression.setFullOrder();
        }
    }

    public void resolve(Session session) {
        resolveReferences(session, RangeGroup.emptyArray);
        ExpressionColumn.checkColumnsResolved(unresolvedExpressions);
        resolveTypes(session);
    }

    public void resolve(Session session, RangeGroup[] rangeGroups, Type[] targetTypes) {
        resolveReferences(session, rangeGroups);
        ExpressionColumn.checkColumnsResolved(unresolvedExpressions);
        resolveTypesPartOne(session);
        if (targetTypes != null) {
            for (int i = 0; i < unionColumnTypes.length && i < targetTypes.length; i++) {
                if (unionColumnTypes[i] == null) {
                    unionColumnTypes[i] = targetTypes[i];
                }
            }
        }
        resolveTypesPartTwo(session);
        resolveTypesPartThree(session);
    }

    public void resolveReferences(Session session, RangeGroup[] rangeGroups) {
        if (isReferencesResolved) {
            return;
        }
        leftQueryExpression.resolveReferences(session, rangeGroups);
        rightQueryExpression.resolveReferences(session, rangeGroups);
        addUnresolvedExpressions(leftQueryExpression.unresolvedExpressions);
        addUnresolvedExpressions(rightQueryExpression.unresolvedExpressions);
        if (leftQueryExpression.isCorrelated || rightQueryExpression.isCorrelated) {
            setCorrelated();
        }
        if (!unionCorresponding) {
            columnCount = leftQueryExpression.getColumnCount();
            int rightCount = rightQueryExpression.getColumnCount();
            if (columnCount != rightCount) {
                throw Error.error(ErrorCode.X_42594);
            }
            unionColumnTypes = new Type[columnCount];
            leftQueryExpression.unionColumnMap = rightQueryExpression.unionColumnMap = new int[columnCount];
            ArrayUtil.fillSequence(leftQueryExpression.unionColumnMap);
            resolveColumnReferencesInUnionOrderBy();
            accessibleColumns = leftQueryExpression.accessibleColumns;
            isReferencesResolved = true;
            return;
        }
        String[] leftNames = leftQueryExpression.getColumnNames();
        String[] rightNames = rightQueryExpression.getColumnNames();
        if (unionCorrespondingColumns == null) {
            unionCorrespondingColumns = new OrderedHashSet();
            OrderedIntHashSet leftColumns = new OrderedIntHashSet();
            OrderedIntHashSet rightColumns = new OrderedIntHashSet();
            for (int i = 0; i < leftNames.length; i++) {
                String name = leftNames[i];
                int index = ArrayUtil.find(rightNames, name);
                if (name.length() > 0 && index != -1) {
                    if (!leftQueryExpression.accessibleColumns[i]) {
                        throw Error.error(ErrorCode.X_42578);
                    }
                    if (!rightQueryExpression.accessibleColumns[index]) {
                        throw Error.error(ErrorCode.X_42578);
                    }
                    leftColumns.add(i);
                    rightColumns.add(index);
                    unionCorrespondingColumns.add(name);
                }
            }
            if (unionCorrespondingColumns.isEmpty()) {
                throw Error.error(ErrorCode.X_42578);
            }
            leftQueryExpression.unionColumnMap = leftColumns.toArray();
            rightQueryExpression.unionColumnMap = rightColumns.toArray();
        } else {
            leftQueryExpression.unionColumnMap = new int[unionCorrespondingColumns.size()];
            rightQueryExpression.unionColumnMap = new int[unionCorrespondingColumns.size()];
            for (int i = 0; i < unionCorrespondingColumns.size(); i++) {
                String name = (String) unionCorrespondingColumns.get(i);
                int index = ArrayUtil.find(leftNames, name);
                if (index == -1) {
                    throw Error.error(ErrorCode.X_42501);
                }
                if (!leftQueryExpression.accessibleColumns[index]) {
                    throw Error.error(ErrorCode.X_42578);
                }
                leftQueryExpression.unionColumnMap[i] = index;
                index = ArrayUtil.find(rightNames, name);
                if (index == -1) {
                    throw Error.error(ErrorCode.X_42501);
                }
                if (!rightQueryExpression.accessibleColumns[index]) {
                    throw Error.error(ErrorCode.X_42578);
                }
                rightQueryExpression.unionColumnMap[i] = index;
            }
        }
        columnCount = unionCorrespondingColumns.size();
        unionColumnTypes = new Type[columnCount];
        resolveColumnReferencesInUnionOrderBy();
        accessibleColumns = new boolean[columnCount];
        ArrayUtil.fillArray(accessibleColumns, true);
        isReferencesResolved = true;
    }

    /**
     * Only simple column reference or column position allowed
     */
    void resolveColumnReferencesInUnionOrderBy() {
        int orderCount = sortAndSlice.getOrderLength();
        if (orderCount == 0) {
            return;
        }
        String[] unionColumnNames = getColumnNames();
        for (int i = 0; i < orderCount; i++) {
            Expression sort = (Expression) sortAndSlice.exprList.get(i);
            Expression e = sort.getLeftNode();
            if (e.getType() == OpTypes.VALUE) {
                if (e.getDataType().typeCode == Types.SQL_INTEGER) {
                    int index = ((Integer) e.getValue(null)).intValue();
                    if (0 < index && index <= unionColumnNames.length) {
                        sort.getLeftNode().queryTableColumnIndex = index - 1;
                        continue;
                    }
                }
            } else if (e.getType() == OpTypes.COLUMN) {
                int index = ArrayUtil.find(unionColumnNames, e.getColumnName());
                if (index >= 0) {
                    sort.getLeftNode().queryTableColumnIndex = index;
                    continue;
                }
            }
            throw Error.error(ErrorCode.X_42576);
        }
        sortAndSlice.prepare(null);
    }

    private void addUnresolvedExpressions(HsqlList expressions) {
        if (expressions == null) {
            return;
        }
        if (unresolvedExpressions == null) {
            unresolvedExpressions = new ArrayListIdenreplacedy();
        }
        unresolvedExpressions.addAll(expressions);
    }

    public void resolveTypes(Session session) {
        if (isResolved) {
            return;
        }
        resolveTypesPartOne(session);
        resolveTypesPartTwo(session);
        resolveTypesPartThree(session);
    }

    void resolveTypesPartOne(Session session) {
        if (isPartOneResolved) {
            return;
        }
        ArrayUtil.projectRowReverse(leftQueryExpression.unionColumnTypes, leftQueryExpression.unionColumnMap, unionColumnTypes);
        leftQueryExpression.resolveTypesPartOne(session);
        ArrayUtil.projectRow(leftQueryExpression.unionColumnTypes, leftQueryExpression.unionColumnMap, unionColumnTypes);
        ArrayUtil.projectRowReverse(rightQueryExpression.unionColumnTypes, rightQueryExpression.unionColumnMap, unionColumnTypes);
        rightQueryExpression.resolveTypesPartOne(session);
        ArrayUtil.projectRow(rightQueryExpression.unionColumnTypes, rightQueryExpression.unionColumnMap, unionColumnTypes);
        isPartOneResolved = true;
    }

    void resolveTypesPartTwoRecursive(Session session) {
        resolveTypesPartTwo(session);
    }

    void resolveTypesPartTwo(Session session) {
        if (isPartTwoResolved) {
            return;
        }
        ArrayUtil.projectRowReverse(leftQueryExpression.unionColumnTypes, leftQueryExpression.unionColumnMap, unionColumnTypes);
        if (isRecursive) {
            leftQueryExpression.resolveTypesPartTwoRecursive(session);
            recursiveTable.colTypes = leftQueryExpression.getColumnTypes();
            for (int i = 0; i < recursiveTable.colTypes.length; i++) {
                recursiveTable.getColumn(i).setType(recursiveTable.colTypes[i]);
            }
            recursiveTable.getFullIndex(session);
        } else {
            leftQueryExpression.resolveTypesPartTwo(session);
        }
        leftQueryExpression.resolveTypesPartThree(session);
        ArrayUtil.projectRowReverse(rightQueryExpression.unionColumnTypes, rightQueryExpression.unionColumnMap, unionColumnTypes);
        rightQueryExpression.resolveTypesPartTwo(session);
        rightQueryExpression.resolveTypesPartThree(session);
        // 
        ResultMetaData leftMeta = leftQueryExpression.getMetaData();
        ResultMetaData rightMeta = rightQueryExpression.getMetaData();
        for (int i = 0; i < leftQueryExpression.unionColumnMap.length; i++) {
            int leftIndex = leftQueryExpression.unionColumnMap[i];
            int rightIndex = rightQueryExpression.unionColumnMap[i];
            ColumnBase column = leftMeta.columns[leftIndex];
            byte leftNullability = leftMeta.columns[leftIndex].getNullability();
            byte rightNullability = rightMeta.columns[rightIndex].getNullability();
            if (rightNullability == SchemaObject.Nullability.NULLABLE || (rightNullability == SchemaObject.Nullability.NULLABLE_UNKNOWN && leftNullability == SchemaObject.Nullability.NO_NULLS)) {
                if (column instanceof ColumnSchema) {
                    column = new ColumnBase();
                    column.setType(leftQueryExpression.unionColumnTypes[i]);
                    leftMeta.columns[leftIndex] = column;
                }
                column.setNullability(rightNullability);
            }
        }
        if (unionCorresponding || isRecursive) {
            resultMetaData = leftQueryExpression.getMetaData().getNewMetaData(leftQueryExpression.unionColumnMap);
            createTable(session);
        }
        if (sortAndSlice.hasOrder()) {
            QueryExpression queryExpression = this;
            while (true) {
                if (queryExpression.leftQueryExpression == null || queryExpression.unionCorresponding) {
                    sortAndSlice.setIndex(session, queryExpression.resultTable);
                    break;
                }
                queryExpression = queryExpression.leftQueryExpression;
            }
        }
        isPartTwoResolved = true;
    }

    void resolveTypesPartThree(Session session) {
        compileContext = null;
        isResolved = true;
        if (isRecursive) {
            recursiveTable.queryExpression.isCorrelated = false;
        }
    }

    public Object[] getValues(Session session) {
        Result r = getResult(session, 2);
        int size = r.getNavigator().getSize();
        if (size == 0) {
            return new Object[r.metaData.getColumnCount()];
        } else if (size == 1) {
            return r.getSingleRowData();
        } else {
            throw Error.error(ErrorCode.X_21000);
        }
    }

    public void addExtraConditions(Expression e) {
    }

    public Object[] getSingleRowValues(Session session) {
        Result r = getResult(session, 2);
        int size = r.getNavigator().getSize();
        if (size == 0) {
            return null;
        } else if (size == 1) {
            return r.getSingleRowData();
        } else {
            throw Error.error(ErrorCode.X_21000);
        }
    }

    public Object getValue(Session session) {
        Object[] values = getValues(session);
        return values[0];
    }

    Result getResult(Session session, int maxRows) {
        if (isRecursive) {
            return getResultRecursive(session);
        }
        int currentMaxRows = unionType == UNION_ALL ? maxRows : 0;
        Result first = leftQueryExpression.getResult(session, currentMaxRows);
        RowSetNavigatorData navigator = (RowSetNavigatorData) first.getNavigator();
        Result second = rightQueryExpression.getResult(session, currentMaxRows);
        RowSetNavigatorData rightNavigator = (RowSetNavigatorData) second.getNavigator();
        if (unionCorresponding) {
            RowSetNavigatorData rowSet;
            boolean memory = session.resultMaxMemoryRows == 0 || (navigator.getSize() < session.resultMaxMemoryRows && rightNavigator.getSize() < session.resultMaxMemoryRows);
            if (memory) {
                rowSet = new RowSetNavigatorData(session, this);
            } else {
                rowSet = new RowSetNavigatorDataTable(session, this);
            }
            rowSet.copy(navigator, leftQueryExpression.unionColumnMap);
            navigator.release();
            navigator = rowSet;
            first.setNavigator(navigator);
            first.metaData = getMetaData();
            if (memory) {
                rowSet = new RowSetNavigatorData(session, this);
            } else {
                rowSet = new RowSetNavigatorDataTable(session, this);
            }
            rowSet.copy(rightNavigator, rightQueryExpression.unionColumnMap);
            rightNavigator.release();
            rightNavigator = rowSet;
        }
        switch(unionType) {
            case UNION:
                navigator.union(session, rightNavigator);
                break;
            case UNION_ALL:
                navigator.unionAll(session, rightNavigator);
                break;
            case INTERSECT:
                navigator.intersect(session, rightNavigator);
                break;
            case INTERSECT_ALL:
                navigator.intersectAll(session, rightNavigator);
                break;
            case EXCEPT:
                navigator.except(session, rightNavigator);
                break;
            case EXCEPT_ALL:
                navigator.exceptAll(session, rightNavigator);
                break;
            default:
                throw Error.runtimeError(ErrorCode.U_S0500, "QueryExpression");
        }
        if (sortAndSlice.hasOrder()) {
            navigator.sortOrderUnion(session, sortAndSlice);
        }
        if (sortAndSlice.hasLimit()) {
            int[] limits = sortAndSlice.getLimits(session, this, maxRows);
            navigator.trim(limits[0], limits[1]);
        }
        navigator.reset();
        return first;
    }

    Result getResultRecursive(Session session) {
        Result tempResult;
        recursiveTable.materialise(session);
        RowSetNavigatorData recNav = recursiveTable.getNavigator(session);
        Result result = Result.newResult(recNav);
        result.metaData = resultMetaData;
        for (int round = 0; ; round++) {
            tempResult = rightQueryExpression.getResult(session, 0);
            RowSetNavigatorData tempNavigator = (RowSetNavigatorData) tempResult.getNavigator();
            if (tempNavigator.isEmpty()) {
                break;
            }
            int startSize = recNav.getSize();
            switch(unionType) {
                case UNION:
                    recNav.union(session, tempNavigator);
                    break;
                case UNION_ALL:
                    recNav.unionAll(session, tempNavigator);
                    break;
                default:
                    throw Error.runtimeError(ErrorCode.U_S0500, "QueryExpression");
            }
            if (startSize == recNav.getSize()) {
                break;
            }
            if (round > 256) {
                throw Error.error(ErrorCode.X_22522);
            }
        }
        return result;
    }

    public OrderedHashSet getSubqueries() {
        OrderedHashSet subqueries = leftQueryExpression.getSubqueries();
        subqueries = OrderedHashSet.addAll(subqueries, rightQueryExpression.getSubqueries());
        return subqueries;
    }

    public boolean isSingleColumn() {
        return leftQueryExpression.isSingleColumn();
    }

    public ResultMetaData getMetaData() {
        if (resultMetaData != null) {
            return resultMetaData;
        }
        return leftQueryExpression.getMetaData();
    }

    public QuerySpecification getMainSelect() {
        if (leftQueryExpression == null) {
            return (QuerySpecification) this;
        }
        return leftQueryExpression.getMainSelect();
    }

    /**
     * @todo 1.9.0 review
     */
    public String describe(Session session, int blanks) {
        StringBuffer sb;
        String temp;
        StringBuffer b = new StringBuffer(blanks);
        for (int i = 0; i < blanks; i++) {
            b.append(' ');
        }
        sb = new StringBuffer();
        switch(unionType) {
            case UNION:
                temp = Tokens.T_UNION;
                break;
            case UNION_ALL:
                temp = Tokens.T_UNION + ' ' + Tokens.T_ALL;
                break;
            case INTERSECT:
                temp = Tokens.T_INTERSECT;
                break;
            case INTERSECT_ALL:
                temp = Tokens.T_INTERSECT + ' ' + Tokens.T_ALL;
                break;
            case EXCEPT:
                temp = Tokens.T_EXCEPT;
                break;
            case EXCEPT_ALL:
                temp = Tokens.T_EXCEPT + ' ' + Tokens.T_ALL;
                break;
            default:
                throw Error.runtimeError(ErrorCode.U_S0500, "QueryExpression");
        }
        sb.append(b).append(temp).append("\n");
        sb.append(b).append("Left Query=[\n");
        sb.append(b).append(leftQueryExpression.describe(session, blanks + 2));
        sb.append(b).append("]\n");
        sb.append(b).append("Right Query=[\n");
        sb.append(b).append(rightQueryExpression.describe(session, blanks + 2));
        sb.append(b).append("]\n");
        return sb.toString();
    }

    public HsqlList getUnresolvedExpressions() {
        return unresolvedExpressions;
    }

    public boolean areColumnsResolved() {
        if (unresolvedExpressions == null || unresolvedExpressions.isEmpty()) {
            return true;
        }
        for (int i = 0; i < unresolvedExpressions.size(); i++) {
            Expression e = (Expression) unresolvedExpressions.get(i);
            if (e.getRangeVariable() == null) {
                return false;
            }
            if (e.getRangeVariable().rangeType == RangeVariable.TABLE_RANGE) {
                return false;
            }
        }
        return true;
    }

    String[] getColumnNames() {
        if (unionCorrespondingColumns == null) {
            return leftQueryExpression.getColumnNames();
        }
        String[] names = new String[unionCorrespondingColumns.size()];
        unionCorrespondingColumns.toArray(names);
        return names;
    }

    public Type[] getColumnTypes() {
        return unionColumnTypes;
    }

    public int getColumnCount() {
        if (unionCorrespondingColumns == null) {
            int left = leftQueryExpression.getColumnCount();
            int right = rightQueryExpression.getColumnCount();
            if (left != right) {
                throw Error.error(ErrorCode.X_42594);
            }
            return left;
        }
        return unionCorrespondingColumns.size();
    }

    public OrderedHashSet collectAllExpressions(OrderedHashSet set, OrderedIntHashSet typeSet, OrderedIntHashSet stopAtTypeSet) {
        set = leftQueryExpression.collectAllExpressions(set, typeSet, stopAtTypeSet);
        if (rightQueryExpression != null) {
            set = rightQueryExpression.collectAllExpressions(set, typeSet, stopAtTypeSet);
        }
        return set;
    }

    OrderedHashSet collectRangeVariables(RangeVariable[] rangeVars, OrderedHashSet set) {
        set = leftQueryExpression.collectRangeVariables(rangeVars, set);
        if (rightQueryExpression != null) {
            set = rightQueryExpression.collectRangeVariables(rangeVars, set);
        }
        return set;
    }

    OrderedHashSet collectRangeVariables(OrderedHashSet set) {
        set = leftQueryExpression.collectRangeVariables(set);
        if (rightQueryExpression != null) {
            set = rightQueryExpression.collectRangeVariables(set);
        }
        return set;
    }

    public void collectObjectNames(Set set) {
        leftQueryExpression.collectObjectNames(set);
        if (rightQueryExpression != null) {
            rightQueryExpression.collectObjectNames(set);
        }
    }

    public HashMappedList getColumns() {
        TableDerived table = (TableDerived) getResultTable();
        return table.columnList;
    }

    /**
     * Used prior to type resolution
     */
    public void setView(View view) {
        this.view = view;
        this.isUpdatable = true;
        this.acceptsSequences = true;
        this.isTopLevel = true;
    }

    /**
     * Used in views after full type resolution
     */
    public void setTableColumnNames(HashMappedList list) {
        if (resultTable != null) {
            ((TableDerived) resultTable).columnList = list;
            return;
        }
        leftQueryExpression.setTableColumnNames(list);
    }

    void createTable(Session session) {
        createResultTable(session);
        mainIndex = resultTable.getPrimaryIndex();
        if (sortAndSlice.hasOrder()) {
            orderIndex = sortAndSlice.getNewIndex(session, resultTable);
        }
        int[] fullCols = new int[columnCount];
        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 = leftQueryExpression.getUnionColumns();
        resultTable = new TableDerived(session.database, tableName, tableType, unionColumnTypes, columnList, ValuePool.emptyIntArray);
    }

    public void setColumnsDefined() {
        if (leftQueryExpression != null) {
            leftQueryExpression.setColumnsDefined();
        }
    }

    /**
     * Not for views. Only used on root node.
     */
    public void setReturningResult() {
        if (compileContext.getSequences().length > 0) {
            throw Error.error(ErrorCode.X_42598);
        }
        isTopLevel = true;
        setReturningResultSet();
    }

    /**
     * Sets the scope to SESSION for the QueryExpression object that creates
     * the table
     */
    void setReturningResultSet() {
        if (unionCorresponding) {
            persistenceScope = TableBase.SCOPE_SESSION;
            return;
        }
        leftQueryExpression.setReturningResultSet();
    }

    private HashMappedList getUnionColumns() {
        if (unionCorresponding || leftQueryExpression == null) {
            HashMappedList columns = ((TableDerived) resultTable).columnList;
            HashMappedList list = new HashMappedList();
            for (int i = 0; i < unionColumnMap.length; i++) {
                ColumnSchema column = (ColumnSchema) columns.get(unionColumnMap[i]);
                list.add(column.getName().name, column);
            }
            return list;
        }
        return leftQueryExpression.getUnionColumns();
    }

    public HsqlName[] getResultColumnNames() {
        if (resultTable == null) {
            return leftQueryExpression.getResultColumnNames();
        }
        HashMappedList list = ((TableDerived) resultTable).columnList;
        HsqlName[] resultColumnNames = new HsqlName[list.size()];
        for (int i = 0; i < resultColumnNames.length; i++) {
            resultColumnNames[i] = ((ColumnSchema) list.get(i)).getName();
        }
        return resultColumnNames;
    }

    public TableBase getResultTable() {
        if (resultTable != null) {
            return resultTable;
        }
        if (leftQueryExpression != null) {
            return leftQueryExpression.getResultTable();
        }
        return null;
    }

    // 
    public Table getBaseTable() {
        return null;
    }

    public boolean isUpdatable() {
        return isUpdatable;
    }

    public boolean isInsertable() {
        return isInsertable;
    }

    public int[] getBaseTableColumnMap() {
        return null;
    }

    public Expression getCheckCondition() {
        return null;
    }

    public boolean hasReference(RangeVariable range) {
        if (leftQueryExpression.hasReference(range)) {
            return true;
        }
        if (rightQueryExpression.hasReference(range)) {
            return true;
        }
        return false;
    }

    void getBaseTableNames(OrderedHashSet set) {
        leftQueryExpression.getBaseTableNames(set);
        rightQueryExpression.getBaseTableNames(set);
    }

    boolean isEquivalent(QueryExpression other) {
        return leftQueryExpression.isEquivalent(other.leftQueryExpression) && unionType == other.unionType && (rightQueryExpression == null ? other.rightQueryExpression == null : rightQueryExpression.isEquivalent(other.rightQueryExpression));
    }

    public void replaceColumnReferences(RangeVariable range, Expression[] list) {
        leftQueryExpression.replaceColumnReferences(range, list);
        rightQueryExpression.replaceColumnReferences(range, list);
    }

    public void replaceRangeVariables(RangeVariable[] ranges, RangeVariable[] newRanges) {
        leftQueryExpression.replaceRangeVariables(ranges, newRanges);
        rightQueryExpression.replaceRangeVariables(ranges, newRanges);
    }

    public void setAsExists() {
    }
}

19 View Complete Implementation : TestDataStructures.java
Copyright Apache License 2.0
Author : SERG-Delft
/**
 * Tells whether the given list contains the same data as the vector
 */
private boolean equalsVector(HsqlList list, Vector vector) {
    if (list.size() != vector.size()) {
        return false;
    }
    Iterator listElements = list.iterator();
    Enumeration vectorElements = vector.elements();
    Object listObj = null;
    Object vectorObj = null;
    while (listElements.hasNext()) {
        listObj = listElements.next();
        vectorObj = vectorElements.nextElement();
        if (!listObj.equals(vectorObj)) {
            return false;
        }
    }
    return true;
}

18 View Complete Implementation : Expression.java
Copyright GNU General Public License v3.0
Author : apavlo
/**
 * collects all range variables in expression tree
 */
void collectRangeVariables(RangeVariable[] rangeVariables, Set set) {
    for (int i = 0; i < nodes.length; i++) {
        if (nodes[i] != null) {
            nodes[i].collectRangeVariables(rangeVariables, set);
        }
    }
    if (subQuery != null && subQuery.queryExpression != null) {
        HsqlList unresolvedExpressions = subQuery.queryExpression.getUnresolvedExpressions();
        if (unresolvedExpressions != null) {
            for (int i = 0; i < unresolvedExpressions.size(); i++) {
                Expression e = (Expression) unresolvedExpressions.get(i);
                e.collectRangeVariables(rangeVariables, set);
            }
        }
    }
}

18 View Complete Implementation : ParserDML.java
Copyright GNU General Public License v3.0
Author : apavlo
void resolveUpdateExpressions(Table targetTable, RangeVariable[] rangeVariables, int[] columnMap, Expression[] colExpressions, RangeVariable[] outerRanges) {
    HsqlList unresolved = null;
    int enforcedDefaultIndex = -1;
    if (targetTable.hasIdenreplacedyColumn() && targetTable.idenreplacedySequence.isAlways()) {
        enforcedDefaultIndex = targetTable.getIdenreplacedyColumnIndex();
    }
    for (int i = 0, ix = 0; i < columnMap.length; ix++) {
        Expression expr = colExpressions[ix];
        Expression e;
        if (expr.getType() == OpTypes.ROW) {
            Expression[] elements = expr.nodes;
            for (int j = 0; j < elements.length; j++, i++) {
                e = elements[j];
                if (enforcedDefaultIndex == columnMap[i]) {
                    if (e.getType() != OpTypes.DEFAULT) {
                        throw Error.error(ErrorCode.X_42541);
                    }
                }
                if (e.isParam()) {
                    e.setAttributesAsColumn(targetTable.getColumn(columnMap[i]), true);
                } else if (e.getType() == OpTypes.DEFAULT) {
                    if (targetTable.colDefaults[columnMap[i]] == null && targetTable.idenreplacedyColumn != columnMap[i]) {
                        throw Error.error(ErrorCode.X_42544);
                    }
                } else {
                    unresolved = expr.resolveColumnReferences(outerRanges, null);
                    unresolved = Expression.resolveColumnSet(rangeVariables, unresolved, null);
                    ExpressionColumn.checkColumnsResolved(unresolved);
                    unresolved = null;
                    e.resolveTypes(session, null);
                }
            }
        } else if (expr.getType() == OpTypes.TABLE_SUBQUERY) {
            unresolved = expr.resolveColumnReferences(outerRanges, null);
            unresolved = Expression.resolveColumnSet(rangeVariables, unresolved, null);
            ExpressionColumn.checkColumnsResolved(unresolved);
            expr.resolveTypes(session, null);
            int count = expr.subQuery.queryExpression.getColumnCount();
            for (int j = 0; j < count; j++, i++) {
                if (enforcedDefaultIndex == columnMap[i]) {
                    throw Error.error(ErrorCode.X_42541);
                }
            }
        } else {
            e = expr;
            if (enforcedDefaultIndex == columnMap[i]) {
                if (e.getType() != OpTypes.DEFAULT) {
                    throw Error.error(ErrorCode.X_42541);
                }
            }
            if (e.isParam()) {
                e.setAttributesAsColumn(targetTable.getColumn(columnMap[i]), true);
            } else if (e.getType() == OpTypes.DEFAULT) {
                if (targetTable.colDefaults[columnMap[i]] == null && targetTable.idenreplacedyColumn != columnMap[i]) {
                    throw Error.error(ErrorCode.X_42544);
                }
            } else {
                unresolved = expr.resolveColumnReferences(outerRanges, null);
                unresolved = Expression.resolveColumnSet(rangeVariables, unresolved, null);
                ExpressionColumn.checkColumnsResolved(unresolved);
                e.resolveTypes(session, null);
            }
            i++;
        }
    }
    if (!targetTable.isView) {
        return;
    }
    QuerySpecification select = ((TableDerived) targetTable).getQueryExpression().getMainSelect();
    for (int i = 0; i < colExpressions.length; i++) {
        colExpressions[i] = colExpressions[i].replaceColumnReferences(rangeVariables[0], select.exprColumns);
    }
}

18 View Complete Implementation : ParserRoutine.java
Copyright GNU General Public License v3.0
Author : apavlo
/**
 * Creates SET Statement for PSM from this parse context.
 */
StatementSimple compileSetStatement(RangeVariable[] rangeVars) {
    read();
    OrderedHashSet colNames = new OrderedHashSet();
    HsqlArrayList exprList = new HsqlArrayList();
    readSetClauseList(rangeVars, colNames, exprList);
    if (exprList.size() > 1) {
        throw Error.error(ErrorCode.X_42602);
    }
    Expression expression = (Expression) exprList.get(0);
    if (expression.getDegree() != colNames.size()) {
    // throw Error.error(ErrorCode.X_42546);
    }
    int[] indexes = new int[colNames.size()];
    ColumnSchema[] variables = new ColumnSchema[colNames.size()];
    setVariables(rangeVars, colNames, indexes, variables);
    HsqlList unresolved = expression.resolveColumnReferences(rangeVars, rangeVars.length, null, false);
    unresolved = Expression.resolveColumnSet(rangeVars, unresolved, null);
    ExpressionColumn.checkColumnsResolved(unresolved);
    expression.resolveTypes(session, null);
    StatementSimple cs = new StatementSimple(StatementTypes.replacedIGNMENT, variables, expression, indexes);
    return cs;
}

18 View Complete Implementation : QueryExpression.java
Copyright GNU General Public License v3.0
Author : apavlo
public void collectAllExpressions(HsqlList set, OrderedIntHashSet typeSet, OrderedIntHashSet stopAtTypeSet) {
    leftQueryExpression.collectAllExpressions(set, typeSet, stopAtTypeSet);
    if (rightQueryExpression != null) {
        rightQueryExpression.collectAllExpressions(set, typeSet, stopAtTypeSet);
    }
}

18 View Complete Implementation : ExpressionColumn.java
Copyright Apache License 2.0
Author : SERG-Delft
void getJoinRangeVariables(RangeVariable[] ranges, HsqlList list) {
    if (opType == OpTypes.COLUMN) {
        for (int i = 0; i < ranges.length; i++) {
            if (ranges[i] == rangeVariable) {
                list.add(rangeVariable);
                return;
            }
        }
    }
}

17 View Complete Implementation : Expression.java
Copyright GNU General Public License v3.0
Author : apavlo
/**
 * Returns a Select object that can be used for checking the contents
 * of an existing table against the given CHECK search condition.
 */
static QuerySpecification getCheckSelect(Session session, Table t, Expression e) {
    CompileContext compileContext = new CompileContext(session);
    QuerySpecification s = new QuerySpecification(compileContext);
    s.exprColumns = new Expression[1];
    s.exprColumns[0] = EXPR_TRUE;
    RangeVariable range = new RangeVariable(t, null, null, null, compileContext);
    s.rangeVariables = new RangeVariable[] { range };
    HsqlList unresolved = e.resolveColumnReferences(s.rangeVariables, null);
    ExpressionColumn.checkColumnsResolved(unresolved);
    e.resolveTypes(session, null);
    if (Type.SQL_BOOLEAN != e.getDataType()) {
        throw Error.error(ErrorCode.X_42568);
    }
    Expression condition = new ExpressionLogical(OpTypes.NOT, e);
    s.queryCondition = condition;
    s.resolveReferences(session);
    s.resolveTypes(session);
    return s;
}

17 View Complete Implementation : ParserDML.java
Copyright GNU General Public License v3.0
Author : apavlo
/**
 * Creates an UPDATE-type Statement from this parse context.
 */
StatementDMQL compileUpdateStatement(RangeVariable[] outerRanges) {
    read();
    Expression[] updateExpressions;
    int[] columnMap;
    boolean[] columnCheckList;
    OrderedHashSet colNames = new OrderedHashSet();
    HsqlArrayList exprList = new HsqlArrayList();
    RangeVariable[] rangeVariables = { readSimpleRangeVariable(StatementTypes.UPDATE_WHERE) };
    Table table = rangeVariables[0].rangeTable;
    Table baseTable = table.getBaseTable();
    readThis(Tokens.SET);
    readSetClauseList(rangeVariables, colNames, exprList);
    columnMap = table.getColumnIndexes(colNames);
    columnCheckList = table.getColumnCheckList(columnMap);
    updateExpressions = new Expression[exprList.size()];
    exprList.toArray(updateExpressions);
    Expression condition = null;
    if (token.tokenType == Tokens.WHERE) {
        read();
        condition = XreadBooleanValueExpression();
        HsqlList unresolved = condition.resolveColumnReferences(outerRanges, null);
        unresolved = Expression.resolveColumnSet(rangeVariables, unresolved, null);
        ExpressionColumn.checkColumnsResolved(unresolved);
        condition.resolveTypes(session, null);
        if (condition.isParam()) {
            condition.dataType = Type.SQL_BOOLEAN;
        } else if (condition.getDataType() != Type.SQL_BOOLEAN) {
            throw Error.error(ErrorCode.X_42568);
        }
    }
    resolveUpdateExpressions(table, rangeVariables, columnMap, updateExpressions, outerRanges);
    if (table != baseTable) {
        QuerySpecification select = ((TableDerived) table).getQueryExpression().getMainSelect();
        if (condition != null) {
            condition = condition.replaceColumnReferences(rangeVariables[0], select.exprColumns);
        }
        rangeVariables[0] = new RangeVariable(select.rangeVariables[0]);
        condition = ExpressionLogical.andExpressions(select.queryCondition, condition);
    }
    if (condition != null) {
        RangeVariableResolver resolver = new RangeVariableResolver(rangeVariables, condition, compileContext);
        resolver.processConditions();
        rangeVariables = resolver.rangeVariables;
    }
    if (table != baseTable) {
        int[] baseColumnMap = table.getBaseTableColumnMap();
        int[] newColumnMap = new int[columnMap.length];
        ArrayUtil.projectRow(baseColumnMap, columnMap, newColumnMap);
        columnMap = newColumnMap;
    }
    StatementDMQL cs = new StatementDML(session, table, rangeVariables, columnMap, updateExpressions, columnCheckList, compileContext);
    return cs;
}

17 View Complete Implementation : ParserDML.java
Copyright GNU General Public License v3.0
Author : apavlo
/**
 * Creates a DELETE-type Statement from this parse context.
 */
StatementDMQL compileDeleteStatement(RangeVariable[] outerRanges) {
    Expression condition = null;
    boolean truncate = false;
    boolean restartIdenreplacedy = false;
    switch(token.tokenType) {
        case Tokens.TRUNCATE:
            {
                read();
                readThis(Tokens.TABLE);
                truncate = true;
                break;
            }
        case Tokens.DELETE:
            {
                read();
                readThis(Tokens.FROM);
                break;
            }
    }
    RangeVariable[] rangeVariables = { readSimpleRangeVariable(StatementTypes.DELETE_WHERE) };
    Table table = rangeVariables[0].getTable();
    Table baseTable = table.getBaseTable();
    if (!table.isUpdatable()) {
        throw Error.error(ErrorCode.X_42000);
    }
    if (truncate) {
        switch(token.tokenType) {
            case Tokens.CONTINUE:
                {
                    read();
                    readThis(Tokens.IDENreplacedY);
                    break;
                }
            case Tokens.RESTART:
                {
                    read();
                    readThis(Tokens.IDENreplacedY);
                    restartIdenreplacedy = true;
                    break;
                }
        }
        for (int i = 0; i < table.constraintList.length; i++) {
            if (table.constraintList[i].getConstraintType() == Constraint.MAIN) {
                throw Error.error(ErrorCode.X_23501);
            }
        }
    }
    if (truncate && table != baseTable) {
        throw Error.error(ErrorCode.X_42000);
    }
    if (!truncate && token.tokenType == Tokens.WHERE) {
        read();
        condition = XreadBooleanValueExpression();
        HsqlList unresolved = condition.resolveColumnReferences(outerRanges, null);
        unresolved = Expression.resolveColumnSet(rangeVariables, unresolved, null);
        ExpressionColumn.checkColumnsResolved(unresolved);
        condition.resolveTypes(session, null);
        if (condition.isParam()) {
            condition.dataType = Type.SQL_BOOLEAN;
        }
        if (condition.getDataType() != Type.SQL_BOOLEAN) {
            throw Error.error(ErrorCode.X_42568);
        }
    }
    if (table != baseTable) {
        QuerySpecification select = ((TableDerived) table).getQueryExpression().getMainSelect();
        if (condition != null) {
            condition = condition.replaceColumnReferences(rangeVariables[0], select.exprColumns);
        }
        rangeVariables[0] = new RangeVariable(select.rangeVariables[0]);
        condition = ExpressionLogical.andExpressions(select.queryCondition, condition);
    }
    if (condition != null) {
        RangeVariableResolver resolver = new RangeVariableResolver(rangeVariables, condition, compileContext);
        resolver.processConditions();
        rangeVariables = resolver.rangeVariables;
    }
    StatementDMQL cs = new StatementDML(session, table, rangeVariables, compileContext, restartIdenreplacedy);
    return cs;
}

17 View Complete Implementation : ParserRoutine.java
Copyright GNU General Public License v3.0
Author : apavlo
private Statement readIf(Routine routine, StatementCompound context) {
    HsqlArrayList list = new HsqlArrayList();
    RangeVariable[] rangeVariables = context == null ? routine.getParameterRangeVariables() : context.getRangeVariables();
    HsqlList unresolved = null;
    readThis(Tokens.IF);
    Expression condition = XreadBooleanValueExpression();
    unresolved = condition.resolveColumnReferences(rangeVariables, rangeVariables.length, unresolved, false);
    ExpressionColumn.checkColumnsResolved(unresolved);
    unresolved = null;
    condition.resolveTypes(session, null);
    Statement statement = new StatementSimple(StatementTypes.CONDITION, condition);
    list.add(statement);
    readThis(Tokens.THEN);
    Statement[] statements = readSQLProcedureStatementList(routine, context);
    for (int i = 0; i < statements.length; i++) {
        list.add(statements[i]);
    }
    while (token.tokenType == Tokens.ELSEIF) {
        read();
        condition = XreadBooleanValueExpression();
        unresolved = condition.resolveColumnReferences(rangeVariables, rangeVariables.length, unresolved, false);
        ExpressionColumn.checkColumnsResolved(unresolved);
        unresolved = null;
        condition.resolveTypes(session, null);
        statement = new StatementSimple(StatementTypes.CONDITION, condition);
        list.add(statement);
        readThis(Tokens.THEN);
        statements = readSQLProcedureStatementList(routine, context);
        for (int i = 0; i < statements.length; i++) {
            list.add(statements[i]);
        }
    }
    if (token.tokenType == Tokens.ELSE) {
        read();
        condition = Expression.EXPR_TRUE;
        statement = new StatementSimple(StatementTypes.CONDITION, condition);
        list.add(statement);
        statements = readSQLProcedureStatementList(routine, context);
        for (int i = 0; i < statements.length; i++) {
            list.add(statements[i]);
        }
    }
    readThis(Tokens.END);
    readThis(Tokens.IF);
    statements = new Statement[list.size()];
    list.toArray(statements);
    StatementCompound result = new StatementCompound(StatementTypes.IF, null);
    result.setStatements(statements);
    return result;
}

17 View Complete Implementation : ParserRoutine.java
Copyright GNU General Public License v3.0
Author : apavlo
private HsqlArrayList readSimpleCaseWhen(Routine routine, StatementCompound context) {
    HsqlArrayList list = new HsqlArrayList();
    RangeVariable[] rangeVariables = context == null ? routine.getParameterRangeVariables() : context.getRangeVariables();
    HsqlList unresolved = null;
    Expression condition = null;
    Statement statement;
    Statement[] statements;
    Expression predicand = XreadRowValuePredicand();
    do {
        readThis(Tokens.WHEN);
        do {
            Expression newCondition = XreadPredicateRightPart(predicand);
            if (predicand == newCondition) {
                newCondition = new ExpressionLogical(predicand, XreadRowValuePredicand());
            }
            unresolved = newCondition.resolveColumnReferences(rangeVariables, rangeVariables.length, unresolved, false);
            ExpressionColumn.checkColumnsResolved(unresolved);
            unresolved = null;
            newCondition.resolveTypes(session, null);
            if (condition == null) {
                condition = newCondition;
            } else {
                condition = new ExpressionLogical(OpTypes.OR, condition, newCondition);
            }
            if (token.tokenType == Tokens.COMMA) {
                read();
            } else {
                break;
            }
        } while (true);
        statement = new StatementSimple(StatementTypes.CONDITION, condition);
        list.add(statement);
        readThis(Tokens.THEN);
        statements = readSQLProcedureStatementList(routine, context);
        for (int i = 0; i < statements.length; i++) {
            list.add(statements[i]);
        }
        if (token.tokenType != Tokens.WHEN) {
            break;
        }
    } while (true);
    return list;
}

17 View Complete Implementation : ParserRoutine.java
Copyright GNU General Public License v3.0
Author : apavlo
private HsqlArrayList readCaseWhen(Routine routine, StatementCompound context) {
    HsqlArrayList list = new HsqlArrayList();
    RangeVariable[] rangeVariables = context == null ? routine.getParameterRangeVariables() : context.getRangeVariables();
    HsqlList unresolved = null;
    Expression condition = null;
    Statement statement;
    Statement[] statements;
    do {
        readThis(Tokens.WHEN);
        condition = XreadBooleanValueExpression();
        unresolved = condition.resolveColumnReferences(rangeVariables, rangeVariables.length, unresolved, false);
        ExpressionColumn.checkColumnsResolved(unresolved);
        unresolved = null;
        condition.resolveTypes(session, null);
        statement = new StatementSimple(StatementTypes.CONDITION, condition);
        list.add(statement);
        readThis(Tokens.THEN);
        statements = readSQLProcedureStatementList(routine, context);
        for (int i = 0; i < statements.length; i++) {
            list.add(statements[i]);
        }
        if (token.tokenType != Tokens.WHEN) {
            break;
        }
    } while (true);
    return list;
}

16 View Complete Implementation : ParserDML.java
Copyright GNU General Public License v3.0
Author : apavlo
/**
 * Retrieves a CALL Statement from this parse context.
 */
// to do call argument name and type resolution
StatementDMQL compileCallStatement(RangeVariable[] outerRanges, boolean isStrictlyProcedure) {
    read();
    if (isIdentifier()) {
        checkValidCatalogName(token.namePrePrefix);
        RoutineSchema routineSchema = (RoutineSchema) database.schemaManager.findSchemaObject(token.tokenString, session.getSchemaName(token.namePrefix), SchemaObject.PROCEDURE);
        if (routineSchema != null) {
            read();
            HsqlArrayList list = new HsqlArrayList();
            readThis(Tokens.OPENBRACKET);
            if (token.tokenType == Tokens.CLOSEBRACKET) {
                read();
            } else {
                while (true) {
                    Expression e = XreadValueExpression();
                    list.add(e);
                    if (token.tokenType == Tokens.COMMA) {
                        read();
                    } else {
                        readThis(Tokens.CLOSEBRACKET);
                        break;
                    }
                }
            }
            Expression[] arguments = new Expression[list.size()];
            list.toArray(arguments);
            Routine routine = routineSchema.getSpecificRoutine(arguments.length);
            HsqlList unresolved = null;
            for (int i = 0; i < arguments.length; i++) {
                Expression e = arguments[i];
                if (e.isParam()) {
                    e.setAttributesAsColumn(routine.getParameter(i), routine.getParameter(i).isWriteable());
                } else {
                    int paramMode = routine.getParameter(i).getParameterMode();
                    unresolved = arguments[i].resolveColumnReferences(outerRanges, unresolved);
                    if (paramMode != SchemaObject.ParameterModes.PARAM_IN) {
                        if (e.getType() != OpTypes.VARIABLE) {
                            throw Error.error(ErrorCode.X_42603);
                        }
                    }
                }
            }
            ExpressionColumn.checkColumnsResolved(unresolved);
            for (int i = 0; i < arguments.length; i++) {
                arguments[i].resolveTypes(session, null);
            }
            StatementDMQL cs = new StatementProcedure(session, routine, arguments, compileContext);
            return cs;
        }
    }
    if (isStrictlyProcedure) {
        throw Error.error(ErrorCode.X_42501, token.tokenString);
    }
    Expression expression = this.XreadValueExpression();
    HsqlList unresolved = expression.resolveColumnReferences(outerRanges, null);
    ExpressionColumn.checkColumnsResolved(unresolved);
    expression.resolveTypes(session, null);
    // expression.paramMode = PARAM_OUT;
    StatementDMQL cs = new StatementProcedure(session, expression, compileContext);
    return cs;
}

16 View Complete Implementation : ExpressionColumn.java
Copyright Apache License 2.0
Author : SERG-Delft
static void checkColumnsResolved(HsqlList set) {
    if (set != null && !set.isEmpty()) {
        StringBuffer sb = new StringBuffer();
        Expression e = (Expression) set.get(0);
        if (e instanceof ExpressionColumn) {
            ExpressionColumn c = (ExpressionColumn) e;
            if (c.schema != null) {
                sb.append(c.schema + '.');
            }
            if (c.tableName != null) {
                sb.append(c.tableName + '.');
            }
            sb.append(c.getColumnName());
            throw Error.error(ErrorCode.X_42501, sb.toString());
        } else {
            OrderedHashSet newSet = new OrderedHashSet();
            e.collectAllExpressions(newSet, Expression.columnExpressionSet, Expression.emptyExpressionSet);
            // throw with column name
            checkColumnsResolved(newSet);
            // throw anyway if not found
            throw Error.error(ErrorCode.X_42501);
        }
    }
}

15 View Complete Implementation : Expression.java
Copyright GNU General Public License v3.0
Author : apavlo
/**
 * collect all extrreplacedions of a set of expression types appearing anywhere
 * in a select statement and its subselects, etc.
 */
static void collectAllExpressions(HsqlList set, Expression e, OrderedIntHashSet typeSet, OrderedIntHashSet stopAtTypeSet) {
    if (e == null) {
        return;
    }
    if (stopAtTypeSet.contains(e.opType)) {
        return;
    }
    for (int i = 0; i < e.nodes.length; i++) {
        collectAllExpressions(set, e.nodes[i], typeSet, stopAtTypeSet);
    }
    if (typeSet.contains(e.opType)) {
        set.add(e);
    }
    if (e.subQuery != null && e.subQuery.queryExpression != null) {
        e.subQuery.queryExpression.collectAllExpressions(set, typeSet, stopAtTypeSet);
    }
}

15 View Complete Implementation : ParserDML.java
Copyright GNU General Public License v3.0
Author : apavlo
/**
 * Retrieves a MERGE Statement from this parse context.
 */
StatementDMQL compileMergeStatement(RangeVariable[] outerRanges) {
    boolean[] insertColumnCheckList;
    int[] insertColumnMap = null;
    int[] updateColumnMap = null;
    int[] baseUpdateColumnMap;
    Table table;
    RangeVariable targetRange;
    RangeVariable sourceRange;
    Expression mergeCondition;
    HsqlArrayList updateList = new HsqlArrayList();
    Expression[] updateExpressions = null;
    HsqlArrayList insertList = new HsqlArrayList();
    Expression insertExpression = null;
    read();
    readThis(Tokens.INTO);
    targetRange = readSimpleRangeVariable(StatementTypes.MERGE);
    table = targetRange.rangeTable;
    readThis(Tokens.USING);
    sourceRange = readTableOrSubquery();
    // parse ON search conditions
    readThis(Tokens.ON);
    mergeCondition = XreadBooleanValueExpression();
    if (mergeCondition.getDataType() != Type.SQL_BOOLEAN) {
        throw Error.error(ErrorCode.X_42568);
    }
    RangeVariable[] fullRangeVars = new RangeVariable[] { sourceRange, targetRange };
    RangeVariable[] sourceRangeVars = new RangeVariable[] { sourceRange };
    RangeVariable[] targetRangeVars = new RangeVariable[] { targetRange };
    // parse WHEN clause(s) and convert lists to arrays
    insertColumnMap = table.getColumnMap();
    insertColumnCheckList = table.getNewColumnCheckList();
    OrderedHashSet updateColNames = new OrderedHashSet();
    OrderedHashSet insertColNames = new OrderedHashSet();
    readMergeWhen(insertColNames, updateColNames, insertList, updateList, targetRangeVars, sourceRange);
    if (insertList.size() > 0) {
        int colCount = insertColNames.size();
        if (colCount != 0) {
            insertColumnMap = table.getColumnIndexes(insertColNames);
            insertColumnCheckList = table.getColumnCheckList(insertColumnMap);
        }
        insertExpression = (Expression) insertList.get(0);
        setParameterTypes(insertExpression, table, insertColumnMap);
    }
    if (updateList.size() > 0) {
        updateExpressions = new Expression[updateList.size()];
        updateList.toArray(updateExpressions);
        updateColumnMap = table.getColumnIndexes(updateColNames);
    }
    if (updateExpressions != null) {
        Table baseTable = table.getBaseTable();
        baseUpdateColumnMap = updateColumnMap;
        if (table != baseTable) {
            baseUpdateColumnMap = new int[updateColumnMap.length];
            ArrayUtil.projectRow(table.getBaseTableColumnMap(), updateColumnMap, baseUpdateColumnMap);
        }
        resolveUpdateExpressions(table, sourceRangeVars, updateColumnMap, updateExpressions, outerRanges);
    }
    HsqlList unresolved = null;
    unresolved = mergeCondition.resolveColumnReferences(fullRangeVars, null);
    ExpressionColumn.checkColumnsResolved(unresolved);
    mergeCondition.resolveTypes(session, null);
    if (mergeCondition.isParam()) {
        mergeCondition.dataType = Type.SQL_BOOLEAN;
    }
    if (mergeCondition.getDataType() != Type.SQL_BOOLEAN) {
        throw Error.error(ErrorCode.X_42568);
    }
    RangeVariableResolver resolver = new RangeVariableResolver(fullRangeVars, mergeCondition, compileContext);
    resolver.processConditions();
    fullRangeVars = resolver.rangeVariables;
    if (insertExpression != null) {
        unresolved = insertExpression.resolveColumnReferences(sourceRangeVars, unresolved);
        ExpressionColumn.checkColumnsResolved(unresolved);
        insertExpression.resolveTypes(session, null);
    }
    StatementDMQL cs = new StatementDML(session, fullRangeVars, insertColumnMap, updateColumnMap, insertColumnCheckList, mergeCondition, insertExpression, updateExpressions, compileContext);
    return cs;
}

14 View Complete Implementation : ExpressionColumn.java
Copyright Apache License 2.0
Author : SERG-Delft
public HsqlList resolveColumnReferences(Session session, RangeGroup rangeGroup, int rangeCount, RangeGroup[] rangeGroups, HsqlList unresolvedSet, boolean acceptsSequences) {
    switch(opType) {
        case OpTypes.SEQUENCE:
            if (!acceptsSequences) {
                throw Error.error(ErrorCode.X_42598);
            }
            break;
        case OpTypes.MULTICOLUMN:
            throw Error.error(ErrorCode.X_42581, "*");
        case OpTypes.ROWNUM:
        case OpTypes.DYNAMIC_PARAM:
        case OpTypes.ASTERISK:
        case OpTypes.SIMPLE_COLUMN:
        case OpTypes.DIAGNOSTICS_VARIABLE:
            break;
        case OpTypes.COALESCE:
            for (int i = 0; i < nodes.length; i++) {
                nodes[i].resolveColumnReferences(session, rangeGroup, rangeGroups, unresolvedSet);
            }
            break;
        case OpTypes.COLUMN:
        case OpTypes.PARAMETER:
        case OpTypes.VARIABLE:
            {
                boolean resolved = false;
                RangeVariable[] rangeVarArray = rangeGroup.getRangeVariables();
                if (rangeVariable != null) {
                    return unresolvedSet;
                }
                for (int i = 0; i < rangeCount; i++) {
                    RangeVariable rangeVar = rangeVarArray[i];
                    if (rangeVar == null) {
                        continue;
                    }
                    if (resolved) {
                        if (session.database.sqlEnforceRefs) {
                            if (resolvesDuplicateColumnReference(rangeVar)) {
                                String message = getColumnName();
                                if (alias != null) {
                                    StringBuffer sb = new StringBuffer(message);
                                    sb.append(' ').append(Tokens.T_AS).append(' ').append(alias.getStatementName());
                                    message = sb.toString();
                                }
                                throw Error.error(ErrorCode.X_42580, message);
                            }
                        }
                    } else {
                        if (resolveColumnReference(rangeVar, false)) {
                            resolved = true;
                            if (!session.database.sqlEnforceRefs) {
                                break;
                            }
                        }
                    }
                }
                if (resolved) {
                    return unresolvedSet;
                }
                if (session.database.sqlSyntaxOra || session.database.sqlSyntaxDb2) {
                    if (acceptsSequences && tableName != null) {
                        if (Tokens.T_CURRVAL.equals(columnName) || Tokens.T_PREVVAL.equals(columnName)) {
                            NumberSequence seq = session.database.schemaManager.findSequence(session, tableName, schema);
                            if (seq != null) {
                                opType = OpTypes.SEQUENCE_CURRENT;
                                dataType = seq.getDataType();
                                sequence = seq;
                                schema = null;
                                tableName = null;
                                columnName = null;
                                resolved = true;
                            }
                        } else if (Tokens.T_NEXTVAL.equals(columnName)) {
                            NumberSequence seq = session.database.schemaManager.findSequence(session, tableName, schema);
                            if (seq != null) {
                                opType = OpTypes.SEQUENCE;
                                dataType = seq.getDataType();
                                sequence = seq;
                                schema = null;
                                tableName = null;
                                columnName = null;
                                resolved = true;
                            }
                        }
                    }
                }
                if (resolved) {
                    return unresolvedSet;
                }
                if (resolveCorrelated(rangeGroup, rangeGroups)) {
                    return unresolvedSet;
                }
                if (unresolvedSet == null) {
                    unresolvedSet = new ArrayListIdenreplacedy();
                }
                unresolvedSet.add(this);
                break;
            }
        default:
    }
    return unresolvedSet;
}