databasecommandinterpreter.java

hsqldb是100％java实现的数据库,是一个开放源代码的JAVA数据库 l 具有标准的SQL语法和JAVA接口 l HSQLDB可以自由使用和分发 l 非常简洁和快速的

        session.setScripting(true);

        token = tokenizer.getSimpleToken();

        switch (Token.get(token)) {

            case Token.RENAME : {
                processAlterTableRename(t);

                return;
            }
            case Token.ADD : {
                HsqlName cname = null;

                if (tokenizer.isGetThis(Token.T_CONSTRAINT)) {
                    token = tokenizer.getName();

                    String constraintSchema = tokenizer.getLongNameFirst();

                    if (constraintSchema != null) {
                        constraintSchema = session.getSchemaNameForWrite(
                            tokenizer.getLongNameFirst());

                        if (!t.getSchemaName().equals(constraintSchema)) {
                            throw Trace.error(
                                Trace.INVALID_SCHEMA_NAME_NO_SUBCLASS,
                                constraintSchema);
                        }
                    }

                    cname = database.nameManager.newHsqlName(token,
                            tokenizer.wasQuotedIdentifier());
                }

                token = tokenizer.getString();

                if (tokenizer.wasQuotedIdentifier()
                        && tokenizer.wasSimpleName()) {
                    tokenizer.back();
                    processAlterTableAddColumn(t);

                    return;
                }

                if (!tokenizer.wasSimpleToken()) {
                    throw Trace.error(Trace.UNEXPECTED_TOKEN, token);
                }

                switch (Token.get(token)) {

                    case Token.FOREIGN :
                        tokenizer.getThis(Token.T_KEY);
                        processAlterTableAddForeignKeyConstraint(t, cname);

                        return;

                    case Token.UNIQUE :
                        processAlterTableAddUniqueConstraint(t, cname);

                        return;

                    case Token.CHECK :
                        processAlterTableAddCheckConstraint(t, cname);

                        return;

                    case Token.PRIMARY :
                        tokenizer.getThis(Token.T_KEY);
                        processAlterTableAddPrimaryKey(t, cname);

                        return;

                    default :
                        if (cname != null) {
                            throw Trace.error(Trace.UNEXPECTED_TOKEN, token);
                        }

                        tokenizer.back();
                    case Token.COLUMN :
                        processAlterTableAddColumn(t);

                        return;
                }
            }
            case Token.DROP : {
                token = tokenizer.getString();

                if (tokenizer.wasQuotedIdentifier()
                        && tokenizer.wasSimpleName()) {
                    tokenizer.back();
                    processAlterTableDropColumn(t);

                    return;
                }

                if (!tokenizer.wasSimpleToken()) {
                    throw Trace.error(Trace.UNEXPECTED_TOKEN, token);
                }

                switch (Token.get(token)) {

                    case Token.PRIMARY :
                        tokenizer.getThis(Token.T_KEY);

                        if (t.hasPrimaryKey()) {
                            processAlterTableDropConstraint(
                                t, t.getPrimaryConstraint().getName().name);
                        } else {
                            throw Trace.error(Trace.CONSTRAINT_NOT_FOUND,
                                              Trace.TABLE_HAS_NO_PRIMARY_KEY,
                                              new Object[] {
                                "PRIMARY KEY", t.getName().name
                            });
                        }

                        return;

                    case Token.CONSTRAINT :
                        processAlterTableDropConstraint(t);

                        return;

                    default :
                        tokenizer.back();
                    case Token.COLUMN :
                        processAlterTableDropColumn(t);

                        return;
                }
            }
            case Token.ALTER : {
                tokenizer.isGetThis(Token.T_COLUMN);
                processAlterColumn(t);

                return;
            }
            default : {
                throw Trace.error(Trace.UNEXPECTED_TOKEN, token);
            }
        }
    }

    /**
     * Handles ALTER COLUMN
     *
     * @param t table
     * @throws HsqlException
     */
    private void processAlterColumn(Table t) throws HsqlException {

        String columnName  = tokenizer.getSimpleName();
        int    columnIndex = t.getColumnNr(columnName);
        Column column      = t.getColumn(columnIndex);
        String token       = tokenizer.getSimpleToken();

        switch (Token.get(token)) {

            case Token.RENAME : {
                tokenizer.getThis(Token.T_TO);
                processAlterColumnRename(t, column);

                return;
            }
            case Token.DROP : {
                tokenizer.getThis(Token.T_DEFAULT);

                TableWorks tw = new TableWorks(session, t);

                tw.setColDefaultExpression(columnIndex, null);

                return;
            }
            case Token.SET : {

//4-8-2005 MarcH and HuugO ALTER TABLE <tablename> ALTER COLUMN <column name> SET [NOT] NULL support added
                token = tokenizer.getSimpleToken();

                if (token.equals(Token.T_NOT)) {
                    tokenizer.getThis(Token.T_NULL);

                    TableWorks tw = new TableWorks(session, t);

                    tw.setColNullability(column, false);
                } else if (token.equals(Token.T_NULL)) {
                    TableWorks tw = new TableWorks(session, t);

                    tw.setColNullability(column, true);
                } else if (token.equals(Token.T_DEFAULT)) {

                    //alter table alter column set default
                    TableWorks tw     = new TableWorks(session, t);
                    int        type   = column.getType();
                    int        length = column.getSize();
                    int        scale  = column.getScale();
                    Expression expr = processCreateDefaultExpression(type,
                        length, scale);

                    tw.setColDefaultExpression(columnIndex, expr);
                } else {
                    throw Trace.error(Trace.UNEXPECTED_TOKEN, token);
                }

                return;
            }
            case Token.RESTART : {
                tokenizer.getThis(Token.T_WITH);

                long identityStart = tokenizer.getBigint();
                int  id            = t.getIdentityColumn();

                if (id == -1) {
                    throw Trace.error(Trace.OPERATION_NOT_SUPPORTED);
                }

                t.identitySequence.reset(identityStart);

                return;
            }
            default : {
                tokenizer.back();
                processAlterColumnType(t, column);
            }
        }
    }

    private void processAlterColumnType(Table table,
                                        Column oldCol) throws HsqlException {

        Column     newCol = processCreateColumn(oldCol.columnName);
        TableWorks tw     = new TableWorks(session, table);

        tw.reTypeColumn(oldCol, newCol);
    }

    /**
     * Responsible for handling tail of ALTER COLUMN ... RENAME ...
     * @param t table
     * @param column column
     * @throws HsqlException
     */
    private void processAlterColumnRename(Table t,
                                          Column column)
                                          throws HsqlException {

        String  newName  = tokenizer.getSimpleName();
        boolean isquoted = tokenizer.wasQuotedIdentifier();

        if (t.findColumn(newName) > -1) {
            throw Trace.error(Trace.COLUMN_ALREADY_EXISTS, newName);
        }

        t.database.schemaManager.checkColumnIsInView(t,
                column.columnName.name);
        session.commit();
        session.setScripting(true);
        t.renameColumn(column, newName, isquoted);
    }

    /**
     * Handles ALTER INDEX.
     *
     * @throws HsqlException
     */
    private void processAlterIndex() throws HsqlException {

        // only the one supported operation, so far
        processAlterIndexRename();
    }

    private void processAlterSchema() throws HsqlException {

        // only the one supported operation, so far
        processAlterSchemaRename();
    }

    /**
     * Responsible for handling parse and execute of SQL DROP DDL
     *
     * @throws  HsqlException
     */
    private void processDrop() throws HsqlException {

        String  token;
        boolean isview;

        session.checkReadWrite();
        session.checkAdmin();
        session.setScripting(true);

        token  = tokenizer.getSimpleToken();
        isview = false;

        switch (Token.get(token)) {

            case Token.INDEX : {
                processDropIndex();

                break;
            }
            case Token.SCHEMA : {
                processDropSchema();

                break;
            }
            case Token.SEQUENCE : {
                processDropSequence();

                break;
            }
            case Token.TRIGGER : {
                processDropTrigger();

                break;
            }
            case Token.USER : {
                processDropUser();

                break;
            }
            case Token.ROLE : {
                database.getGranteeManager().dropRole(
                    tokenizer.getSimpleName());

                break;
            }
            case Token.VIEW : {
                isview = true;
            }    //fall thru
            case Token.TABLE : {
                processDropTable(isview);

                break;
            }
            default : {
                throw Trace.error(Trace.UNEXPECTED_TOKEN, token);
            }
        }
    }

    /**
     *  Responsible for handling the execution of GRANT and REVOKE SQL
     *  statements.
     *
     * @param grant true if grant, false if revoke
     * @throws HsqlException
     */
    private void processGrantOrRevoke(boolean grant) throws HsqlException {

        int    right;
        Object accessKey;
        String token;

        session.checkAdmin();
        session.checkDDLWrite();
        session.setScripting(true);

        right = 0;
        token = tokenizer.getSimpleToken();

        tokenizer.back();

        if (!GranteeManager.validRightString(token)) {
            processRoleGrantOrRevoke(grant);

            return;
        }

        do {
            token = tokenizer.getSimpleToken();
            right |= GranteeManager.getCheckRight(token);
        } while (tokenizer.isGetThis(Token.T_COMMA));

        tokenizer.getThis(Token.T_ON);

        accessKey = null;

        if (tokenizer.isGetThis(Token.T_CLASS)) {
            accessKey = tokenizer.getSimpleName();

            if (!tokenizer.wasQuotedIdentifier()) {
                throw Trace.error(Trace.QUOTED_IDENTIFIER_REQUIRED);
            }
        } else {
            token = tokenizer.getName();

            String schema =
                session.getSchemaName(tokenizer.getLongNameFirst());
            Table t = database.schemaManager.getTable(session, token, schema);

            accessKey = t.getName();

            session.setScripting(true);
        }

        tokenizer.getThis(grant ? Token.T_TO
                                : Token.T_FROM);

        token = getUserIdentifier();

        GranteeManager gm = database.getGranteeManager();

        if (grant) {
            gm.grant(token, accessKey, right);
        } else {
            gm.revok