コード例 #1
0
    def parse(database, statement):
        parser = Parser(statement)

        parser.expect("ALTER", "TABLE")
        parser.expectOptional("ONLY")

        tableName = parser.parseIdentifier()
        schemaName = ParserUtils.getSchemaName(tableName, database)
        schema = database.getSchema(schemaName)

        if schema is None:
            raise Exception("CannotFindSchema")

        objectName = ParserUtils.getObjectName(tableName)
        table = schema.tables.get(objectName)

        if table is None:
            view = schema.views.get(objectName)

            if view is not None:
                AlterTableParser.parseView(parser, view, tableName, database)
                return

            sequence = schema.sequences.get(objectName)

            if sequence is not None:
                AlterTableParser.parseSequence(parser, sequence, tableName, database);
                return

            raise Exception("Cannot find object '%s' for statement '%s'." % (tableName, statement))

        while not parser.expectOptional(";"):
            if parser.expectOptional("ALTER"):
                AlterTableParser.parseAlterColumn(parser, table)
            elif (parser.expectOptional("CLUSTER", "ON")):
                table.clusterIndexName = ParserUtils.getObjectName(parser.parseIdentifier())
            elif (parser.expectOptional("OWNER", "TO")):
                # we do not parse this one so we just consume the identifier
                # if (outputIgnoredStatements):
                #     print 'database.addIgnoredStatement("ALTER TABLE " + tableName + " OWNER TO " + parser.parseIdentifier() + ';')'
                # else:
                    parser.parseIdentifier()
            elif (parser.expectOptional("ADD")):
                if (parser.expectOptional("FOREIGN", "KEY")):
                    print 'parseAddForeignKey(parser, table);'
                elif (parser.expectOptional("CONSTRAINT")):
                    AlterTableParser.parseAddConstraint(parser, table, schema)
                else:
                    parser.throwUnsupportedCommand()
            elif (parser.expectOptional("ENABLE")):
                print 'parseEnable(parser, outputIgnoredStatements, tableName, database);'
            elif (parser.expectOptional("DISABLE")):
                print 'parseDisable(parser, outputIgnoredStatements, tableName, database);'
            else:
                parser.throwUnsupportedCommand()

            if (parser.expectOptional(";")):
                break
            else:
                parser.expect(",")
コード例 #2
0
    def parse(database, statement):
        parser = Parser(statement)

        parser.expect("ALTER", "SEQUENCE")

        sequenceName = parser.parseIdentifier()
        schemaName = ParserUtils.getSchemaName(sequenceName, database)
        schema = database.getSchema(schemaName)

        if schema is None:
            raise Exception("CannotFindSchema")

        objectName = ParserUtils.getObjectName(sequenceName);
        sequence = schema.sequences[objectName]

        if sequence is None:
            raise Exception("Cannot find sequence '%s' for statement '%s'. Missing CREATE SEQUENCE?" % (sequenceName, statement))

        while not parser.expectOptional(";"):

            if (parser.expectOptional("OWNED", "BY")):
                if parser.expectOptional("NONE"):
                    sequence.ownedBy = None
                else:
                    sequence.ownedBy = parser.getExpression()
            else:
                parser.throwUnsupportedCommand()
コード例 #3
0
    def parse(database, statement):
        parser = Parser(statement)
        parser.expect('CREATE', 'TABLE')

        # Optional IF NOT EXISTS, irrelevant for our purposes
        parser.expectOptional("IF", "NOT", "EXISTS")

        tableName = ParserUtils.getObjectName(parser.parseIdentifier())
        table = PgTable(tableName)
        # Figure it out why do we need this
        schemaName = ParserUtils.getSchemaName(tableName, database)
        schema = database.getSchema(schemaName)

        if schema is None:
            raise Exception("Cannot find schema \'%s\' for statement \'%s\'. Missing CREATE SCHEMA statement?" % (schemaName, statement))

        schema.addTable(table)

        parser.expect("(")

        while not parser.expectOptional(")"):
            if parser.expectOptional("CONSTRAINT"):
                CreateTableParser.parseConstraint(parser, table)
            else:
                CreateTableParser.parseColumn(parser, table)

            if parser.expectOptional(")"):
                break
            else:
                parser.expect(",")


        while not parser.expectOptional(";"):
            if parser.expectOptional("INHERITS"):
                CreateTableParser.parseInherits(parser, table)
            elif parser.expectOptional("WITHOUT"):
                table.oids = "OIDS=false"
            elif parser.expectOptional("WITH"):
                if (parser.expectOptional("OIDS") or parser.expectOptional("OIDS=true")):
                    table.oids = "OIDS=true"
                elif parser.expectOptional("OIDS=false"):
                    table.oids = "OIDS=false"
                else:
                    print 'table.setWith(parser.getExpression())'
            elif parser.expectOptional("TABLESPACE"):
                print 'table.setTablespace(parser.parseString()'
            else:
                parser.throwUnsupportedCommand()
コード例 #4
0
    def parse(database, statement):
        parser = Parser(statement)
        parser.expect("CREATE", "SEQUENCE")

        sequenceName = parser.parseIdentifier();
        sequence = PgSequence(ParserUtils.getObjectName(sequenceName))
        schemaName = ParserUtils.getSchemaName(sequenceName, database)
        schema = database.getSchema(schemaName)

        if schema is None:
            raise Exception("Cannot find schema '%s' for statement '%s'. Missing CREATE SCHEMA statement?" % (schemaName, statement))

        schema.addSequence(sequence)

        while not parser.expectOptional(";"):
            if parser.expectOptional("INCREMENT"):
                parser.expectOptional("BY")
                sequence.increment = parser.parseString()
            elif parser.expectOptional("MINVALUE"):
                sequence.minValue = parser.parseString()
            elif parser.expectOptional("MAXVALUE"):
                sequence.maxValue = parser.parseString()
            elif parser.expectOptional("START"):
                parser.expectOptional("WITH")
                sequence.startWith = parser.parseString()
            elif parser.expectOptional("CACHE"):
                sequence.cache = parser.parseString()
            elif parser.expectOptional("CYCLE"):
                sequence.cycle = True
            elif parser.expectOptional("OWNED", "BY"):
                if parser.expectOptional("NONE"):
                    sequence.ownedBy = None
                else:
                    sequence.ownedBy = ParserUtils.getObjectName(parser.parseIdentifier())

            elif parser.expectOptional("NO"):
                if parser.expectOptional("MINVALUE"):
                    sequence.minValue = None
                elif parser.expectOptional("MAXVALUE"):
                    sequence.maxValue = None
                elif parser.expectOptional("CYCLE"):
                    sequence.cycle = False
                else:
                    parser.throwUnsupportedCommand()

            else:
                parser.throwUnsupportedCommand()
コード例 #5
0
    def parse(database, statement):
        parser = Parser(statement)
        parser.expect("ALTER", "VIEW")

        viewName = parser.parseIdentifier()
        schemaName = ParserUtils.getSchemaName(viewName, database)
        schema = database.getSchema(schemaName)

        if schema is None:
            raise Exception("Cannot find schema '%s' for statement '%s'. Missing CREATE SCHEMA statement?" % (schemaName, statement))

        objectName = ParserUtils.getObjectName(viewName)
        view = schema.views[objectName]

        if view is None:
            raise Exception("Cannot find view '%s' for statement '%s'. Missing CREATE VIEW statement?" % (viewName, statement))

        while not parser.expectOptional(";"):
            if parser.expectOptional("ALTER"):
                parser.expectOptional("COLUMN")

                columnName = ParserUtils.getObjectName(parser.parseIdentifier())

                if parser.expectOptional("SET", "DEFAULT"):
                    expression = parser.getExpression()
                    view.addColumnDefaultValue(columnName, expression)
                elif parser.expectOptional("DROP", "DEFAULT"):
                    view.removeColumnDefaultValue(columnName)
                else:
                    parser.throwUnsupportedCommand()

            elif parser.expectOptional("OWNER", "TO"):
                # we do not parse this one so we just consume the identifier
                # if (outputIgnoredStatements) {
                #     database.addIgnoredStatement("ALTER TABLE " + viewName
                #             + " OWNER TO " + parser.parseIdentifier() + ';');
                # } else {
                parser.parseIdentifier()
                # }
            else:
                parser.throwUnsupportedCommand()
コード例 #6
0
    def parse(database, statement, ignoreSlonyTriggers):
        parser = Parser(statement)
        parser.expect("CREATE", "TRIGGER")

        triggerName = parser.parseIdentifier()
        objectName = ParserUtils.getObjectName(triggerName)

        trigger = PgTrigger()
        trigger.name = objectName

        if parser.expectOptional("BEFORE"):
            trigger.event = PgTrigger.EVENT_BEFORE
        elif parser.expectOptional("AFTER"):
            trigger.event = PgTrigger.EVENT_AFTER
        elif parser.expectOptional("INSTEAD OF"):
            trigger.event = PgTrigger.EVENT_INSTEAD_OF

        first = True

        while True:
            if not first and not parser.expectOptional("OR"):
                break
            elif parser.expectOptional("INSERT"):
                trigger.onInsert = True
            elif parser.expectOptional("UPDATE"):
                trigger.onUpdate = True

                if parser.expectOptional("OF"):
                    while True:
                        trigger.updateColumns.append(parser.parseIdentifier())
                        if not parser.expectOptional(","):
                            break

            elif parser.expectOptional("DELETE"):
                trigger.onDelete = True
            elif parser.expectOptional("TRUNCATE"):
                trigger.onTruncate = True
            elif (first):
                break
            else:
                parser.throwUnsupportedCommand()

            first = False

        parser.expect("ON")

        trigger.tableName = ParserUtils.getObjectName(parser.parseIdentifier())

        if parser.expectOptional("FOR"):
            parser.expectOptional("EACH")

            if parser.expectOptional("ROW"):
                trigger.forEachRow = True
            elif parser.expectOptional("STATEMENT"):
                trigger.forEachRow = False
            else:
                parser.throwUnsupportedCommand()

        if parser.expectOptional("WHEN"):
            parser.expect("(")
            trigger.when = parser.getExpression()
            parser.expect(")")

        parser.expect("EXECUTE", "PROCEDURE")
        trigger.function = parser.getRest()

        ignoreSlonyTrigger = ignoreSlonyTriggers and ("_slony_logtrigger" == trigger.name or "_slony_denyaccess" == trigger.name)

        if (not ignoreSlonyTrigger):
            schema = database.getSchema(ParserUtils.getSchemaName(trigger.tableName, database))
            container = schema.tables.get(trigger.tableName)
            if not container:
                container = schema.views.get(trigger.tableName)

            if container:
                container.triggers[trigger.name] = trigger
            else:
                raise Exception()