Java HsqlName.setSchemaIfNull方法代码示例

import org.hsqldb.HsqlNameManager.HsqlName; //导入方法依赖的package包/类
StatementSchema compileCreateTable(int type) {

        boolean  ifNot = readIfNotExists();
        HsqlName name  = readNewSchemaObjectName(SchemaObject.TABLE, false);

        name.setSchemaIfNull(session.getCurrentSchemaHsqlName());

        Table table;

        switch (type) {

            case TableBase.TEMP_TEXT_TABLE :
            case TableBase.TEXT_TABLE : {
                table = new TextTable(database, name, type);

                break;
            }
            default : {
                table = new Table(database, name, type);
            }
        }

        if (token.tokenType == Tokens.AS) {
            return compileCreateTableAsSubqueryDefinition(table);
        }

        return compileCreateTableBody(table, ifNot);
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入方法依赖的package包/类
Statement compileRenameObject(HsqlName name, int type) {

        HsqlName newName = readNewSchemaObjectName(type, true);
        String   sql     = getLastPart();

        switch (type) {

            case SchemaObject.CATALOG :
                break;

            case SchemaObject.SCHEMA :
                checkSchemaUpdateAuthorisation(session, name);
                break;

            default :
                name.setSchemaIfNull(session.getCurrentSchemaHsqlName());
                checkSchemaUpdateAuthorisation(session, name.schema);
        }

        Object[] args = new Object[] {
            name, newName
        };
        HsqlName[] writeLockNames =
            database.schemaManager.getCatalogNameArray();

        return new StatementSchema(sql, StatementTypes.RENAME_OBJECT, args,
                                   null, writeLockNames);
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入方法依赖的package包/类
Routine readCreatePasswordCheckFunction() {

        Routine routine = new Routine(SchemaObject.FUNCTION);

        if (token.tokenType == Tokens.NONE) {
            read();

            return null;
        } else if (token.tokenType == Tokens.EXTERNAL) {
            routine.setLanguage(Routine.LANGUAGE_JAVA);
            routine.setDataImpact(Routine.NO_SQL);
        } else {
            routine.setLanguage(Routine.LANGUAGE_SQL);
            routine.setDataImpact(Routine.CONTAINS_SQL);
        }

        HsqlName hsqlName = database.nameManager.newHsqlName(Tokens.T_PASSWORD,
            false, SchemaObject.FUNCTION);

        hsqlName.setSchemaIfNull(SqlInvariants.SYSTEM_SCHEMA_HSQLNAME);
        routine.setName(hsqlName);

        hsqlName = database.nameManager.newHsqlName(Tokens.T_PASSWORD, false,
                SchemaObject.PARAMETER);

        ColumnSchema column = new ColumnSchema(hsqlName, Type.SQL_VARCHAR,
                                               false, false, null);

        routine.addParameter(column);
        routine.setReturnType(Type.SQL_BOOLEAN);
        readRoutineBody(routine);
        routine.resolve(session);

        return routine;
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入方法依赖的package包/类
StatementSchema compileCreateTable(int type) {

        boolean ifNot = false;

        if (token.tokenType == Tokens.IF) {
            int position = getPosition();

            read();

            if (token.tokenType == Tokens.NOT) {
                read();
                readThis(Tokens.EXISTS);

                ifNot = true;
            } else {
                rewind(position);
            }
        }

        HsqlName name = readNewSchemaObjectName(SchemaObject.TABLE, false);

        name.setSchemaIfNull(session.getCurrentSchemaHsqlName());

        Table table;

        switch (type) {

            case TableBase.TEMP_TEXT_TABLE :
            case TableBase.TEXT_TABLE : {
                table = new TextTable(database, name, type);

                break;
            }
            default : {
                table = new Table(database, name, type);
            }
        }

        return compileCreateTableBody(table, ifNot);
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入方法依赖的package包/类
HsqlName readNewSchemaObjectNameNoCheck(int type) {

        checkIsSchemaObjectName();

        HsqlName hsqlName = database.nameManager.newHsqlName(token.tokenString,
            isDelimitedIdentifier(), type);

        if (token.namePrefix != null) {
            if (type == SchemaObject.GRANTEE) {
                throw unexpectedToken();
            }

            HsqlName schemaName =
                session.database.schemaManager.findSchemaHsqlName(
                    token.namePrefix);

            if (schemaName == null) {
                schemaName = database.nameManager.newHsqlName(token.namePrefix,
                        isDelimitedIdentifier(), SchemaObject.SCHEMA);
            }

            hsqlName.setSchemaIfNull(schemaName);
        }

        read();

        return hsqlName;
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入方法依赖的package包/类
StatementSchema compileCreateCollation() {

        read();

        HsqlName name = readNewSchemaObjectName(SchemaObject.COLLATION, false);

        name.setSchemaIfNull(session.getCurrentSchemaHsqlName());
        readThis(Tokens.FOR);

        HsqlName charsetName = readNewSchemaObjectName(SchemaObject.CHARSET,
            false);

        readThis(Tokens.FROM);

        HsqlName sourceName = readNewSchemaObjectName(SchemaObject.COLLATION,
            false);
        Boolean padSpace = null;

        if (readIfThis(Tokens.NO)) {
            readThis(Tokens.PAD);

            padSpace = Boolean.FALSE;
        } else if (readIfThis(Tokens.PAD)) {
            readThis(Tokens.SPACE);

            padSpace = Boolean.TRUE;
        }

        String schemaName = charsetName.schema == null ? null
                                                       : charsetName.schema
                                                           .name;
        Charset charset =
            (Charset) database.schemaManager.getCharacterSet(session,
                charsetName.name, schemaName);

        if (charset == null) {
            throw Error.error(ErrorCode.X_42501,
                              charsetName.getSchemaQualifiedStatementName());
        }

        schemaName = sourceName.schema == null ? null
                                               : sourceName.schema.name;

        Collation source = database.schemaManager.getCollation(session,
            sourceName.name, schemaName);
        Collation  collation = new Collation(name, source, charset, padSpace);
        String     sql            = getLastPart();
        Object[]   args           = new Object[]{ collation };
        HsqlName[] writeLockNames = database.schemaManager.catalogNameArray;

        return new StatementSchema(sql, StatementTypes.CREATE_COLLATION, args,
                                   null, writeLockNames);
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入方法依赖的package包/类
StatementSchema compileCreateIndex(boolean unique) {

        Table    table;
        HsqlName indexHsqlName;

        read();

        Boolean ifNotExists = readIfNotExists();

        indexHsqlName = readNewSchemaObjectName(SchemaObject.INDEX, true);

        if (database.sqlSyntaxMys) {
            if (readIfThis(Tokens.USING)) {
                if (!readIfThis("HASH")) {
                    readThis("BTREE");
                }
            }
        }

        readThis(Tokens.ON);

        table = readTableName();

        HsqlName tableSchema = table.getSchemaName();

        indexHsqlName.setSchemaIfNull(tableSchema);

        indexHsqlName.parent = table.getName();

        if (indexHsqlName.schema != tableSchema) {
            throw Error.error(ErrorCode.X_42505);
        }

        indexHsqlName.schema = table.getSchemaName();

        int[] indexColumns = readColumnList(table, true);

        if (database.sqlSyntaxMys) {
            if (readIfThis(Tokens.USING)) {
                if (!readIfThis("HASH")) {
                    readThis("BTREE");
                }
            }

            if (readIfThis(Tokens.COMMENT)) {
                String comment = readQuotedString();

                indexHsqlName.comment = comment;
            }
        }

        String   sql  = getLastPart();
        Object[] args = new Object[] {
            table, indexColumns, indexHsqlName, Boolean.valueOf(unique), null,
            ifNotExists
        };

        return new StatementSchema(sql, StatementTypes.CREATE_INDEX, args,
                                   null, new HsqlName[] {
            database.getCatalogName(), table.getName()
        });
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入方法依赖的package包/类
StatementSchema compileCreateProcedureOrFunction(boolean orReplace) {

        int     routineType;
        boolean isAggregate = false;

        if (token.tokenType == Tokens.AGGREGATE) {
            isAggregate = true;

            read();

            if (token.tokenType == Tokens.PROCEDURE) {
                throw unexpectedToken();
            }
        }

        routineType = token.tokenType == Tokens.PROCEDURE
                      ? SchemaObject.PROCEDURE
                      : SchemaObject.FUNCTION;

        HsqlName name;

        read();

        name = readNewSchemaObjectName(routineType, true);

        name.setSchemaIfNull(session.getCurrentSchemaHsqlName());

        Routine routine = new Routine(routineType);

        routine.setName(name);
        routine.setAggregate(isAggregate);
        readThis(Tokens.OPENBRACKET);

        if (token.tokenType == Tokens.CLOSEBRACKET) {
            read();
        } else {
            while (true) {
                ColumnSchema newcolumn = readRoutineParameter(routine, true);

                routine.addParameter(newcolumn);

                if (token.tokenType == Tokens.COMMA) {
                    read();
                } else {
                    readThis(Tokens.CLOSEBRACKET);

                    break;
                }
            }
        }

        if (routineType != SchemaObject.PROCEDURE) {
            readThis(Tokens.RETURNS);

            if (token.tokenType == Tokens.TABLE) {
                read();

                TableDerived table =
                    new TableDerived(database, SqlInvariants.MODULE_HSQLNAME,
                                     TableBase.FUNCTION_TABLE);

                readTableDefinition(routine, table);
                routine.setReturnTable(table);
            } else {
                Type type = readTypeDefinition(false, true);

                routine.setReturnType(type);
            }
        }

        readRoutineCharacteristics(routine);
        readRoutineBody(routine);

        Object[] args = new Object[]{ routine };
        String   sql  = getLastPart();
        StatementSchema cs = new StatementSchema(sql,
            StatementTypes.CREATE_ROUTINE, args, null,
            database.schemaManager.getCatalogNameArray());

        return cs;
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入方法依赖的package包/类
HsqlName readNewSchemaObjectName(int type, boolean checkSchema) {

        checkIsSchemaObjectName();

        HsqlName hsqlName = database.nameManager.newHsqlName(token.tokenString,
            isDelimitedIdentifier(), type);

        if (token.namePrefix != null) {
            switch (type) {

                case SchemaObject.LABEL :
                case SchemaObject.VARIABLE :
                case SchemaObject.GRANTEE :
                case SchemaObject.CATALOG :
                    throw unexpectedToken();
                case SchemaObject.CURSOR : {
                    if (token.namePrePrefix == null
                            && !token.isDelimitedPrefix
                            && (Tokens.T_MODULE.equals(token.namePrefix))) {

                        // local
                    } else {
                        throw unexpectedTokenRequire(Tokens.T_MODULE);
                    }

                    break;
                }
                case SchemaObject.SCHEMA : {
                    checkValidCatalogName(token.namePrefix);

                    if (token.namePrePrefix != null) {
                        throw tooManyIdentifiers();
                    }

                    break;
                }
                case SchemaObject.SERVER :
                case SchemaObject.WRAPPER : {
                    checkValidCatalogName(token.namePrefix);

                    if (token.namePrePrefix != null) {
                        throw tooManyIdentifiers();
                    }

                    break;
                }
                case SchemaObject.COLUMN : {
                    throw tooManyIdentifiers();
                }
                default : {
                    checkValidCatalogName(token.namePrePrefix);

                    HsqlName schemaName;

                    if (checkSchema) {
                        schemaName =
                            session.getSchemaHsqlName(token.namePrefix);
                    } else {
                        schemaName =
                            session.database.schemaManager.findSchemaHsqlName(
                                token.namePrefix);

                        if (schemaName == null) {
                            schemaName = database.nameManager.newHsqlName(
                                token.namePrefix, isDelimitedIdentifier(),
                                SchemaObject.SCHEMA);
                        }
                    }

                    hsqlName.setSchemaIfNull(schemaName);

                    break;
                }
            }
        }

        read();

        return hsqlName;
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入方法依赖的package包/类
Routine readProcedureOrFunctionDeclaration() {

        int     routineType;
        boolean isAggregate = false;

        if (token.tokenType == Tokens.AGGREGATE) {
            isAggregate = true;

            read();

            if (token.tokenType == Tokens.PROCEDURE) {
                throw unexpectedToken();
            }
        }

        routineType = token.tokenType == Tokens.PROCEDURE
                      ? SchemaObject.PROCEDURE
                      : SchemaObject.FUNCTION;

        HsqlName name;

        read();

        name = readNewSchemaObjectName(routineType, true);

        name.setSchemaIfNull(session.getCurrentSchemaHsqlName());

        Routine routine = new Routine(routineType);

        routine.setName(name);
        routine.setAggregate(isAggregate);
        readRoutineArguments(routine);

        if (routineType != SchemaObject.PROCEDURE) {
            readThis(Tokens.RETURNS);

            if (token.tokenType == Tokens.TABLE) {
                read();

                TableDerived table =
                    new TableDerived(database, SqlInvariants.MODULE_HSQLNAME,
                                     TableBase.FUNCTION_TABLE);

                readTableDefinition(routine, table);
                routine.setReturnTable(table);
            } else {
                Type type = readTypeDefinition(false, true);

                routine.setReturnType(type);
            }
        }

        readRoutineCharacteristics(routine);

        return routine;
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入方法依赖的package包/类
StatementSchema compileCreateView() {

        read();

        HsqlName name = readNewSchemaObjectName(SchemaObject.VIEW);

        name.setSchemaIfNull(session.getCurrentSchemaHsqlName());

        HsqlName[] colList = null;

        if (token.tokenType == Tokens.OPENBRACKET) {
            colList = readColumnNames(name);
        }

        readThis(Tokens.AS);
        startRecording();

        int position = getPosition();
        QueryExpression queryExpression;

        try {
            queryExpression = XreadQueryExpression();
        } catch (HsqlException e) {
            queryExpression = XreadJoinedTable();
        }

        Token[] statement = getRecordedStatement();
        String sql = getLastPart(position);
        int check = SchemaObject.ViewCheckModes.CHECK_NONE;

        if (token.tokenType == Tokens.WITH) {
            read();

            check = SchemaObject.ViewCheckModes.CHECK_CASCADE;

            if (readIfThis(Tokens.LOCAL)) {
                check = SchemaObject.ViewCheckModes.CHECK_LOCAL;
            } else {
                readIfThis(Tokens.CASCADED);
            }

            readThis(Tokens.CHECK);
            readThis(Tokens.OPTION);
        }

        View view = new View(session, database, name, colList, sql, check);

        queryExpression.setAsTopLevel();
        queryExpression.setView(view);
        queryExpression.resolve(session);
        view.compile(session);
        checkSchemaUpdateAuthorisation(name.schema);
        database.schemaManager.checkSchemaObjectNotExists(name);

        String statementSQL = Token.getSQL(statement);

        view.statement = statementSQL;

        String fullSQL = getLastPart();
        Object[] args = new Object[] { view };

        return new StatementSchema(fullSQL, StatementTypes.CREATE_VIEW, args, null, null);
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入方法依赖的package包/类
HsqlName readNewSchemaObjectName(int type) {

        checkIsSchemaObjectName();

        HsqlName hsqlName = database.nameManager.newHsqlName(token.tokenString,
            isDelimitedIdentifier(), type);

        if (token.namePrefix != null) {
            if (type == SchemaObject.GRANTEE || type == SchemaObject.VARIABLE
                    || type == SchemaObject.CATALOG) {
                throw unexpectedToken();
            }

            HsqlName schemaName = session.getSchemaHsqlName(token.namePrefix);

            hsqlName.setSchemaIfNull(schemaName);
        }

        read();

        return hsqlName;
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入方法依赖的package包/类
StatementSchema compileCreateIndex(boolean unique) {

        Table         table;
        HsqlName      indexHsqlName;
        String[]      qualifiers = null;
        HsqlArrayList list       = new HsqlArrayList();

        read();

        indexHsqlName = readNewSchemaObjectName(SchemaObject.INDEX, true);

        while (token.tokenType != Tokens.ON) {
            checkIsIdentifier();
            list.add(token.tokenString);
            read();
        }

        qualifiers = new String[list.size()];

        list.toArray(qualifiers);
        readThis(Tokens.ON);

        table = readTableName();

        HsqlName tableSchema = table.getSchemaName();

        indexHsqlName.setSchemaIfNull(tableSchema);

        indexHsqlName.parent = table.getName();

        if (indexHsqlName.schema != tableSchema) {
            throw Error.error(ErrorCode.X_42505);
        }

        indexHsqlName.schema = table.getSchemaName();

        int[]    indexColumns = readColumnList(table, true);
        String   sql          = getLastPart();
        Object[] args         = new Object[] {
            table, indexColumns, indexHsqlName, Boolean.valueOf(unique),
            qualifiers
        };

        return new StatementSchema(sql, StatementTypes.CREATE_INDEX, args,
                                   null, new HsqlName[] {
            database.getCatalogName(), table.getName()
        });
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入方法依赖的package包/类
StatementSchema compileCreateIndex(boolean unique) {

        Table table;
        HsqlName indexHsqlName;

        read();

        indexHsqlName = readNewSchemaObjectName(SchemaObject.INDEX);

        readThis(Tokens.ON);

        table = readTableName();

        HsqlName tableSchema = table.getSchemaName();

        indexHsqlName.setSchemaIfNull(tableSchema);

        indexHsqlName.parent = table.getName();

        if (indexHsqlName.schema != tableSchema) {
            throw Error.error(ErrorCode.X_42505);
        }

        indexHsqlName.schema = table.getSchemaName();

        int[] indexColumns = readColumnList(table, true);
        String sql = getLastPart();
        Object[] args = new Object[] { table, indexColumns, indexHsqlName, Boolean.valueOf(unique) };

        return new StatementSchema(sql, StatementTypes.CREATE_INDEX, args, null, table.getName());
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入方法依赖的package包/类
HsqlName readNewDependentSchemaObjectName(HsqlName parentName, int type) {

        HsqlName name = readNewSchemaObjectName(type, true);

        name.parent = parentName;

        name.setSchemaIfNull(parentName.schema);

        if (name.schema != null && parentName.schema != null
                && name.schema != parentName.schema) {
            throw Error.error(ErrorCode.X_42505, token.namePrefix);
        }

        return name;
    }