Examples with Sequence org.h2.schema.Sequence used on opensource projects

Example 36 with Sequence

use of org.h2.schema.Sequence in project h2database by h2database.

the class Parser method readSequence.

private Sequence readSequence() {
    // same algorithm as readTableOrView
    String sequenceName = readIdentifierWithSchema(null);
    if (schemaName != null) {
        return getSchema().getSequence(sequenceName);
    }
    Sequence sequence = findSequence(session.getCurrentSchemaName(), sequenceName);
    if (sequence != null) {
        return sequence;
    }
    throw DbException.get(ErrorCode.SEQUENCE_NOT_FOUND_1, sequenceName);
}

Example 37 with Sequence

use of org.h2.schema.Sequence in project h2database by h2database.

the class Parser method parseDrop.

private Prepared parseDrop() {
    if (readIf("TABLE")) {
        boolean ifExists = readIfExists(false);
        String tableName = readIdentifierWithSchema();
        DropTable command = new DropTable(session, getSchema());
        command.setTableName(tableName);
        while (readIf(",")) {
            tableName = readIdentifierWithSchema();
            DropTable next = new DropTable(session, getSchema());
            next.setTableName(tableName);
            command.addNextDropTable(next);
        }
        ifExists = readIfExists(ifExists);
        command.setIfExists(ifExists);
        if (readIf("CASCADE")) {
            command.setDropAction(ConstraintActionType.CASCADE);
            readIf("CONSTRAINTS");
        } else if (readIf("RESTRICT")) {
            command.setDropAction(ConstraintActionType.RESTRICT);
        } else if (readIf("IGNORE")) {
            command.setDropAction(ConstraintActionType.SET_DEFAULT);
        }
        return command;
    } else if (readIf("INDEX")) {
        boolean ifExists = readIfExists(false);
        String indexName = readIdentifierWithSchema();
        DropIndex command = new DropIndex(session, getSchema());
        command.setIndexName(indexName);
        ifExists = readIfExists(ifExists);
        command.setIfExists(ifExists);
        // Support for MySQL: DROP INDEX index_name ON tbl_name
        if (readIf("ON")) {
            readIdentifierWithSchema();
        }
        return command;
    } else if (readIf("USER")) {
        boolean ifExists = readIfExists(false);
        DropUser command = new DropUser(session);
        command.setUserName(readUniqueIdentifier());
        ifExists = readIfExists(ifExists);
        readIf("CASCADE");
        command.setIfExists(ifExists);
        return command;
    } else if (readIf("SEQUENCE")) {
        boolean ifExists = readIfExists(false);
        String sequenceName = readIdentifierWithSchema();
        DropSequence command = new DropSequence(session, getSchema());
        command.setSequenceName(sequenceName);
        ifExists = readIfExists(ifExists);
        command.setIfExists(ifExists);
        return command;
    } else if (readIf("CONSTANT")) {
        boolean ifExists = readIfExists(false);
        String constantName = readIdentifierWithSchema();
        DropConstant command = new DropConstant(session, getSchema());
        command.setConstantName(constantName);
        ifExists = readIfExists(ifExists);
        command.setIfExists(ifExists);
        return command;
    } else if (readIf("TRIGGER")) {
        boolean ifExists = readIfExists(false);
        String triggerName = readIdentifierWithSchema();
        DropTrigger command = new DropTrigger(session, getSchema());
        command.setTriggerName(triggerName);
        ifExists = readIfExists(ifExists);
        command.setIfExists(ifExists);
        return command;
    } else if (readIf("VIEW")) {
        boolean ifExists = readIfExists(false);
        String viewName = readIdentifierWithSchema();
        DropView command = new DropView(session, getSchema());
        command.setViewName(viewName);
        ifExists = readIfExists(ifExists);
        command.setIfExists(ifExists);
        ConstraintActionType dropAction = parseCascadeOrRestrict();
        if (dropAction != null) {
            command.setDropAction(dropAction);
        }
        return command;
    } else if (readIf("ROLE")) {
        boolean ifExists = readIfExists(false);
        DropRole command = new DropRole(session);
        command.setRoleName(readUniqueIdentifier());
        ifExists = readIfExists(ifExists);
        command.setIfExists(ifExists);
        return command;
    } else if (readIf("ALIAS")) {
        boolean ifExists = readIfExists(false);
        String aliasName = readIdentifierWithSchema();
        DropFunctionAlias command = new DropFunctionAlias(session, getSchema());
        command.setAliasName(aliasName);
        ifExists = readIfExists(ifExists);
        command.setIfExists(ifExists);
        return command;
    } else if (readIf("SCHEMA")) {
        boolean ifExists = readIfExists(false);
        DropSchema command = new DropSchema(session);
        command.setSchemaName(readUniqueIdentifier());
        ifExists = readIfExists(ifExists);
        command.setIfExists(ifExists);
        if (readIf("CASCADE")) {
            command.setDropAction(ConstraintActionType.CASCADE);
        } else if (readIf("RESTRICT")) {
            command.setDropAction(ConstraintActionType.RESTRICT);
        }
        return command;
    } else if (readIf("ALL")) {
        read("OBJECTS");
        DropDatabase command = new DropDatabase(session);
        command.setDropAllObjects(true);
        if (readIf("DELETE")) {
            read("FILES");
            command.setDeleteFiles(true);
        }
        return command;
    } else if (readIf("DOMAIN")) {
        return parseDropUserDataType();
    } else if (readIf("TYPE")) {
        return parseDropUserDataType();
    } else if (readIf("DATATYPE")) {
        return parseDropUserDataType();
    } else if (readIf("AGGREGATE")) {
        return parseDropAggregate();
    } else if (readIf("SYNONYM")) {
        boolean ifExists = readIfExists(false);
        String synonymName = readIdentifierWithSchema();
        DropSynonym command = new DropSynonym(session, getSchema());
        command.setSynonymName(synonymName);
        ifExists = readIfExists(ifExists);
        command.setIfExists(ifExists);
        return command;
    }
    throw getSyntaxError();
}

Example 38 with Sequence

use of org.h2.schema.Sequence in project h2database by h2database.

the class AlterTableAlterColumn method removeSequence.

private void removeSequence(Table table, Sequence sequence) {
    if (sequence != null) {
        table.removeSequence(sequence);
        sequence.setBelongsToTable(false);
        Database db = session.getDatabase();
        db.removeSchemaObject(session, sequence);
    }
}

Example 39 with Sequence

use of org.h2.schema.Sequence in project h2database by h2database.

the class DropSequence method update.

@Override
public int update() {
    session.getUser().checkAdmin();
    session.commit(true);
    Database db = session.getDatabase();
    Sequence sequence = getSchema().findSequence(sequenceName);
    if (sequence == null) {
        if (!ifExists) {
            throw DbException.get(ErrorCode.SEQUENCE_NOT_FOUND_1, sequenceName);
        }
    } else {
        if (sequence.getBelongsToTable()) {
            throw DbException.get(ErrorCode.SEQUENCE_BELONGS_TO_A_TABLE_1, sequenceName);
        }
        db.removeSchemaObject(session, sequence);
    }
    return 0;
}

Example 40 with Sequence

use of org.h2.schema.Sequence in project h2database by h2database.

the class DropDatabase method dropAllObjects.

private void dropAllObjects() {
    session.getUser().checkAdmin();
    session.commit(true);
    Database db = session.getDatabase();
    db.lockMeta(session);
    // There can be dependencies between tables e.g. using computed columns,
    // so we might need to loop over them multiple times.
    boolean runLoopAgain;
    do {
        ArrayList<Table> tables = db.getAllTablesAndViews(false);
        ArrayList<Table> toRemove = New.arrayList();
        for (Table t : tables) {
            if (t.getName() != null && TableType.VIEW == t.getTableType()) {
                toRemove.add(t);
            }
        }
        for (Table t : tables) {
            if (t.getName() != null && TableType.TABLE_LINK == t.getTableType()) {
                toRemove.add(t);
            }
        }
        for (Table t : tables) {
            if (t.getName() != null && TableType.TABLE == t.getTableType() && !t.isHidden()) {
                toRemove.add(t);
            }
        }
        for (Table t : tables) {
            if (t.getName() != null && TableType.EXTERNAL_TABLE_ENGINE == t.getTableType() && !t.isHidden()) {
                toRemove.add(t);
            }
        }
        runLoopAgain = false;
        for (Table t : toRemove) {
            if (t.getName() == null) {
            // ignore, already dead
            } else if (db.getDependentTable(t, t) == null) {
                db.removeSchemaObject(session, t);
            } else {
                runLoopAgain = true;
            }
        }
    } while (runLoopAgain);
    // TODO session-local temp tables are not removed
    for (Schema schema : db.getAllSchemas()) {
        if (schema.canDrop()) {
            db.removeDatabaseObject(session, schema);
        }
    }
    ArrayList<SchemaObject> list = New.arrayList();
    for (SchemaObject obj : db.getAllSchemaObjects(DbObject.SEQUENCE)) {
        // ones that belong to session-local temp tables.
        if (!((Sequence) obj).getBelongsToTable()) {
            list.add(obj);
        }
    }
    // maybe constraints and triggers on system tables will be allowed in
    // the future
    list.addAll(db.getAllSchemaObjects(DbObject.CONSTRAINT));
    list.addAll(db.getAllSchemaObjects(DbObject.TRIGGER));
    list.addAll(db.getAllSchemaObjects(DbObject.CONSTANT));
    list.addAll(db.getAllSchemaObjects(DbObject.FUNCTION_ALIAS));
    for (SchemaObject obj : list) {
        if (obj.isHidden()) {
            continue;
        }
        db.removeSchemaObject(session, obj);
    }
    for (User user : db.getAllUsers()) {
        if (user != session.getUser()) {
            db.removeDatabaseObject(session, user);
        }
    }
    for (Role role : db.getAllRoles()) {
        String sql = role.getCreateSQL();
        // the role PUBLIC must not be dropped
        if (sql != null) {
            db.removeDatabaseObject(session, role);
        }
    }
    ArrayList<DbObject> dbObjects = New.arrayList();
    dbObjects.addAll(db.getAllRights());
    dbObjects.addAll(db.getAllAggregates());
    dbObjects.addAll(db.getAllUserDataTypes());
    for (DbObject obj : dbObjects) {
        String sql = obj.getCreateSQL();
        // the role PUBLIC must not be dropped
        if (sql != null) {
            db.removeDatabaseObject(session, obj);
        }
    }
}