database.java

一个用java写的开源的数据库系统

                                   HsqlName cname) throws SQLException {

        int localcol[] = processColumnList(c, t);

        c.getThis("REFERENCES");

        String expTableName = c.getString();
        Table  expTable;

// fredt@users 20020221 - patch 520213 by boucherb@users - self reference FK
// allows foreign keys that reference a column in the same table
        if (t.equals(expTableName)) {
            expTable = t;
        } else {
            expTable = getTable(expTableName, session);
        }

        int    expcol[] = null;
        String sToken   = c.getString();

        c.back();

// fredt@users 20020503 - patch 1.7.0 by fredt -  FOREIGN KEY on table
        if (sToken.equals("(")) {
            expcol = processColumnList(c, expTable);
        } else {

            // the exp table must have a user defined primary key
            Index expIndex = expTable.getPrimaryIndex();

            if (expIndex != null) {
                expcol = expIndex.getColumns();

                if (expcol[0] == expTable.getColumnCount()) {
                    throw Trace.error(Trace.INDEX_NOT_FOUND,
                                      expTableName + " has no primary key");
                }
            }

            // with CREATE TABLE, (expIndex == null) when self referencing FK
            // is declared in CREATE TABLE
            // null will be returned for expCol and will be checked
            // in caller method
            // with ALTER TABLE, (expIndex == null) when table has no PK
        }

        sToken = c.getString();

// fredt@users 20020305 - patch 1.7.0 - cascading deletes
        boolean cascade = false;

        if (sToken.equals("ON")) {
            c.getThis("DELETE");
            c.getThis("CASCADE");

            cascade = true;
        } else {
            c.back();
        }

        if (cname == null) {
            cname = HsqlName.makeAutoName("FK");
        }

        return new TempConstraint(cname, localcol, expTable, expcol,
                                  Constraint.FOREIGN_KEY, cascade);
    }

// fredt@users 20020420 - patch523880 by leptipre@users - VIEW support

    /**
     *  Responsible for handling the execution CREATE VIEW SQL statements.
     *
     * @param  session
     * @param  c
     * @throws  SQLException
     */
    private void processCreateView(Tokenizer c,
                                   Session session) throws SQLException {

        View   v;
        String sToken      = c.getName();
        int    logposition = c.getPartMarker();

        if (this.findUserTable(sToken, session) != null) {
            throw Trace.error(Trace.VIEW_ALREADY_EXISTS, sToken);
        }

        v = new View(this, new HsqlName(sToken, c.wasQuotedIdentifier()));

        c.getThis("AS");
        c.setPartMarker();
        c.getThis("SELECT");

        Result rResult;
        Parser p       = new Parser(this, c, session);
        int    maxRows = session.getMaxRows();

        try {
            Select select = p.parseSelect();

            if (select.sIntoTable != null) {
                throw (Trace.error(Trace.TABLE_NOT_FOUND));
            }

            select.setPreProcess();

            rResult = select.getResult(1);
        } catch (SQLException e) {
            throw e;
        }

        v.setStatement(c.getLastPart());
        v.addColumns(rResult);
        session.commit();
        tTable.addElement(v);
        c.setPartMarker(logposition);
    }

    private void processRenameTable(Tokenizer c, Session session,
                                    String tablename) throws SQLException {

        String  newname  = c.getName();
        boolean isquoted = c.wasQuotedIdentifier();
        Table   t        = findUserTable(tablename);

        // this ensures temp table belongs to this session
        if (t == null ||!t.equals(tablename, session)) {
            throw Trace.error(Trace.TABLE_NOT_FOUND, tablename);
        }

        Table ttemp = findUserTable(newname);

        if (ttemp != null && ttemp.equals(ttemp.getName().name, session)) {
            throw Trace.error(Trace.TABLE_ALREADY_EXISTS, tablename);
        }

        session.commit();
        session.setScripting(!t.isTemp());
        t.setName(newname, isquoted);
    }

    /**
     * 'RENAME' declaration.
     * ALTER TABLE <name> RENAME TO <newname>
     * ALTER INDEX <name> RENAME TO <newname>
     *
     * ALTER TABLE <name> ADD CONSTRAINT <constname> FOREIGN KEY (<col>, ...)
     * REFERENCE <other table> (<col>, ...) [ON DELETE CASCADE]
     *
     * ALTER TABLE <name> ADD CONSTRAINT <constname> UNIQUE (<col>, ...)
     *
     * @param  c
     * @param  session
     * @return  Result
     * @throws  SQLException
     */
    private Result processAlter(Tokenizer c,
                                Session session) throws SQLException {

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

        String sToken = c.getString();

        if (sToken.equals("TABLE")) {
            processAlterTable(c, session);
        } else if (sToken.equals("INDEX")) {
            processAlterIndex(c, session);
        } else {
            throw Trace.error(Trace.UNEXPECTED_TOKEN, sToken);
        }

        return new Result();
    }

    private void processAlterTable(Tokenizer c,
                                   Session session) throws SQLException {

        String     tablename = c.getString();
        Table      t         = getUserTable(tablename, session);
        TableWorks tw        = new TableWorks(t);
        String     sToken    = c.getString();

        session.setScripting(!t.isTemp());

        if (sToken.equals("RENAME")) {
            c.getThis("TO");
            processRenameTable(c, session, tablename);

            return;
        } else if (sToken.equals("ADD")) {
            sToken = c.getString();

            if (sToken.equals("CONSTRAINT")) {
                HsqlName cname = new HsqlName(c.getName(),
                                              c.wasQuotedIdentifier());

                sToken = c.getString();

                if (sToken.equals("FOREIGN")) {
                    c.getThis("KEY");

                    TempConstraint tc = processCreateFK(c, session, t, cname);

                    t.checkColumnsMatch(tc.localCol, tc.expTable, tc.expCol);
                    session.commit();
                    tw.createForeignKey(tc.localCol, tc.expCol, tc.name,
                                        tc.expTable, tc.cascade);

                    return;
                } else if (sToken.equals("UNIQUE")) {
                    int col[] = processColumnList(c, t);

                    session.commit();
                    tw.createUniqueConstraint(col, cname);

                    return;
                } else {
                    throw Trace.error(Trace.UNEXPECTED_TOKEN, sToken);
                }
            } else if (sToken.equals("COLUMN")) {
                int    colindex = t.getColumnCount();
                Column column   = processCreateColumn(c, t);

                sToken = c.getString();

                if (sToken.equals("BEFORE")) {
                    sToken   = c.getName();
                    colindex = t.getColumnNr(sToken);
                } else {
                    c.back();
                }

                if (column.isIdentity() || column.isPrimaryKey()
                        || (!t.isEmpty() && column.isNullable() == false
                            && column.getDefaultString() == null)) {
                    throw Trace.error(Trace.BAD_ADD_COLUMN_DEFINITION);
                }

                session.commit();
                tw.addOrDropColumn(column, colindex, 1);

                return;
            }
        } else if (sToken.equals("DROP")) {
            sToken = c.getString();

            if (sToken.equals("CONSTRAINT")) {
                String cname = c.getName();

                session.commit();
                tw.dropConstraint(cname);

                return;
            } else if (sToken.equals("COLUMN")) {
                sToken = c.getName();

                int colindex = t.getColumnNr(sToken);

                session.commit();
                tw.addOrDropColumn(null, colindex, -1);

                return;
            } else {
                throw Trace.error(Trace.UNEXPECTED_TOKEN, sToken);
            }
        } else {
            throw Trace.error(Trace.UNEXPECTED_TOKEN, sToken);
        }
    }

    private void processAlterIndex(Tokenizer c,
                                   Session session) throws SQLException {

        String indexname = c.getName();

        c.getThis("RENAME");
        c.getThis("TO");

        String  newname  = c.getName();
        boolean isQuoted = c.wasQuotedIdentifier();
        Table   t        = findTableForIndex(indexname);

        if (t == null ||!t.equals(t.getName().name, session)) {
            throw Trace.error(Trace.INDEX_NOT_FOUND, indexname);
        }

        Table ttemp = findTableForIndex(newname);

        if (ttemp != null && ttemp.equals(ttemp.getName().name, session)) {
            throw Trace.error(Trace.INDEX_ALREADY_EXISTS, indexname);
        }

        if (HsqlName.isReservedName(indexname)) {
            throw Trace.error(Trace.SYSTEM_INDEX, indexname);
        }

        if (HsqlName.isReservedName(newname)) {
            throw Trace.error(Trace.BAD_INDEX_CONSTRAINT_NAME, indexname);
        }

        session.setScripting(!t.isTemp());
        session.commit();
        t.getIndex(indexname).setName(newname, isQuoted);
    }

// fredt@users 20020221 - patch 1.7.0 chnaged IF EXISTS syntax
// new syntax DROP TABLE tablename IF EXISTS
// fredt@users 20020221 - patch 513005 by sqlbob@users (RMP)

    /**
     *  Method declaration
     *
     * @param  c
     * @param  session
     * @return
     * @throws  SQLException
     */
    private Result processDrop(Tokenizer c,
                               Session session) throws SQLException {

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

        String sToken = c.getString();

        if (sToken.equals("TABLE") || sToken.equals("VIEW")) {
            boolean isview    = sToken.equals("VIEW");
            String  tablename = c.getString();
            boolean dropmode  = false;

            sToken = c.getString();

            if (sToken.equals("IF")) {
                c.getThis("EXISTS");

                dropmode = true;
            } else {
                c.back();

                Table t = getTable(tablename, session);

                session.setScripting(!t.isTemp());
            }

            dropTable(tablename, dropmode, isview, session);
            session.commit();
        } else if (sToken.equals("USER")) {
            aAccess.dropUser(c.getStringToken());
        } else if (sToken.equals("TRIGGER")) {
            dropTrigger(c.getString(), session);
        } else if (sToken.equals("INDEX")) {
            String indexname = c.getName();
            Table  t         = findTableForIndex(indexname);

            if (t == null ||!t.equals(t.getName().name, session)) {
                throw Trace.error(Trace.INDEX_NOT_FOUND, indexname);
            }

            t.checkDropIndex(indexname, null);

// fredt@users 20020405 - patch 1.7.0 by fredt - drop index bug
// see Table.moveDefinition();
            session.commit();
            session.setScripting(!t.isTemp());

            TableWorks tw = new TableWorks(t);

            tw.dropIndex(indexname);
        } else {
            throw Trace.error(Trace.UNEXPECTED_TOKEN, sToken);
        }

        return new Result();
    }

// fredt@users 20020221 - patch 513005 by sqlbob@users (RMP)

    /**
     *  Responsible for handling the execution of GRANT and REVOKE SQL
     *  statements.
     *
     * @param  c
     * @param  session
     * @param  grant
     * @return  Description of the Return Value
     * @throws  SQLException
     */
    private Result proc