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(",")
def parse(database, statement): parser = Parser(statement) parser.expect("CREATE") parser.expectOptional("OR", "REPLACE") parser.expect("VIEW") viewName = parser.parseIdentifier() columnsExist = parser.expectOptional("(") columnNames = list() if (columnsExist): while not parser.expectOptional(")"): columnNames.append(ParserUtils.getObjectName(parser.parseIdentifier())) parser.expectOptional(",") parser.expect("AS") query = parser.getRest() view = PgView(ParserUtils.getObjectName(viewName)) view.columnNames = columnNames view.query = query schemaName = ParserUtils.getSchemaName(viewName, database) schema = database.getSchema(schemaName) if schema is None: raise Exception("CannotFindSchema" % (schemaName, statement)) schema.addView(view)
def parseFunction(parser, database): functionName = parser.parseIdentifier() objectName = ParserUtils.getObjectName(functionName) schemaName = ParserUtils.getSchemaName(functionName, database) schema = database.getSchema(schemaName) parser.expect("(") tmpFunction = PgFunction() tmpFunction.name = objectName while not parser.expectOptional(")"): mode = '' if parser.expectOptional("IN"): mode = "IN" elif parser.expectOptional("OUT"): mode = "OUT" elif parser.expectOptional("INOUT"): mode = "INOUT" elif parser.expectOptional("VARIADIC"): mode = "VARIADIC" else: mode = None position = parser.position argumentName = None dataType = parser.parseDataType() position2 = parser.position if not parser.expectOptional(")") and not parser.expectOptional(","): parser.position = position argumentName = ParserUtils.getObjectName(parser.parseIdentifier()) dataType = parser.parseDataType() else: parser.position = position2 argument = Argument() argument.dataType = dataType argument.mode = mode argument.name = argumentName tmpFunction.addArgument(argument) if parser.expectOptional(")"): break else: parser.expect(",") function = schema.functions.get(tmpFunction.getSignature()) parser.expect("IS") function.comment = CommentParser.getComment(parser) parser.expect(";")
def parseTrigger(parser, database): triggerName = ParserUtils.getObjectName(parser.parseIdentifier()) parser.expect("ON") tableName = parser.parseIdentifier() objectName = ParserUtils.getObjectName(tableName) schemaName = ParserUtils.getSchemaName(triggerName, database) trigger = database.getSchema(schemaName).tables[objectName].triggers[triggerName] parser.expect("IS") trigger.comment = CommentParser.getComment(parser) parser.expect(";")
def parseConstraint(parser, database): constraintName = ParserUtils.getObjectName(parser.parseIdentifier()) parser.expect("ON") tableName = parser.parseIdentifier() objectName = ParserUtils.getObjectName(tableName) schemaName = ParserUtils.getSchemaName(constraintName, database) constraint = database.getSchema(schemaName).getTable(objectName).constraints[constraintName] parser.expect("IS") constraint.comment = CommentParser.getComment(parser) parser.expect(";")
def parseColumn(parser, database): columnName = parser.parseIdentifier() objectName = ParserUtils.getObjectName(columnName) tableName = ParserUtils.getSecondObjectName(columnName) schemaName = ParserUtils.getThirdObjectName(columnName) schema = database.getSchema(schemaName) table = schema.getTable(tableName) if table is None: view = schema.views[tableName] parser.expect("IS") comment = CommentParser.getComment(parser) if comment is None: view.removeColumnComment(objectName) else: view.addColumnComment(objectName, comment) parser.expect(";") else: column = table.columns.get(objectName) if column is None: raise Error("Cannot find column '%s' in table '%s'" % (columnName, table.name)) parser.expect("IS") column.comment = CommentParser.getComment(parser) parser.expect(";")
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()
def parseSchema(parser, database): schemaName = ParserUtils.getObjectName(parser.parseIdentifier()) schema = database.getSchema(schemaName) parser.expect("IS") schema.comment = CommentParser.getComment(parser) parser.expect(";")
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()
def parseSequence(parser, database): sequenceName = parser.parseIdentifier(); objectName = ParserUtils.getObjectName(sequenceName) schemaName = ParserUtils.getSchemaName(sequenceName, database) sequence = database.getSchema(schemaName).sequences[objectName] parser.expect("IS") sequence.comment = CommentParser.getComment(parser) parser.expect(";")
def parseInherits(parser, table): parser.expect("(") while not parser.expectOptional(")"): table.addInherits(ParserUtils.getObjectName(parser.parseIdentifier())) if parser.expectOptional(")"): break else: parser.expect(",")
def parseView(parser, database): viewName = parser.parseIdentifier() objectName = ParserUtils.getObjectName(viewName) schemaName = ParserUtils.getSchemaName(viewName, database) view = database.getSchema(schemaName).views[objectName] parser.expect("IS") view.comment = CommentParser.getComment(parser) parser.expect(";")
def parseTable(parser, database): tableName = parser.parseIdentifier() objectName = ParserUtils.getObjectName(tableName) schemaName = ParserUtils.getSchemaName(tableName, database) table = database.getSchema(schemaName).getTable(objectName) parser.expect("IS") table.comment = CommentParser.getComment(parser) parser.expect(";")
def parseAddConstraint(parser, table, schema): constraintName = ParserUtils.getObjectName(parser.parseIdentifier()) constraint = PgConstraint(constraintName) constraint.tableName = table.name table.addConstraint(constraint) if parser.expectOptional("PRIMARY", "KEY"): schema.addPrimaryKey(constraint) constraint.definition = "PRIMARY KEY " + parser.getExpression() else: constraint.setDefinition = parser.getExpression()
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()
def parse(database, statement): parser = Parser(statement) parser.expect("CREATE", "SCHEMA") if parser.expectOptional("AUTHORIZATION"): schema = PgSchema(ParserUtils.getObjectName(parser.parseIdentifier())) database.addSchema(schema) schema.authorization = schema.name else: schemaName = ParserUtils.getObjectName(parser.parseIdentifier()) schema = PgSchema(schemaName) database.schemas[schemaName] = schema if parser.expectOptional("AUTHORIZATION"): schema.authorization = ParserUtils.getObjectName(parser.parseIdentifier()) definition = parser.getRest() if definition: schema.definition = definition
def parse(database, statement): parser = Parser(statement) parser.expect("CREATE") unique = parser.expectOptional("UNIQUE") parser.expect("INDEX") parser.expectOptional("CONCURRENTLY") indexName = ParserUtils.getObjectName(parser.parseIdentifier()) parser.expect("ON") tableName = parser.parseIdentifier() definition = parser.getRest() schemaName =ParserUtils.getSchemaName(tableName, database) schema = database.getSchema(schemaName) if (schema is None): print 'ERROR: CreateIndexParser[Line 21]' # throw new RuntimeException(MessageFormat.format( # Resources.getString("CannotFindSchema"), schemaName, # statement)); objectName = ParserUtils.getObjectName(tableName) table = schema.getTable(objectName) if (table is None): print 'ERROR: CreateIndexParser[Line 32]' # throw new RuntimeException(MessageFormat.format( # Resources.getString("CannotFindTable"), tableName, # statement)); index = PgIndex(indexName) table.addIndex(index) schema.addIndex(index) index.definition = definition.strip() index.tableName = table.name index.unique = unique
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()
def parseAlterColumn(parser, table): parser.expectOptional("COLUMN") columnName = ParserUtils.getObjectName(parser.parseIdentifier()); if parser.expectOptional("SET"): if parser.expectOptional("STATISTICS"): column = table.columns[columnName] if column is None: raise Exception("Cannot find column '%s' in table '%s' for statement '%s'.") % (columnName, table.name, parser.statement) column.statistics = parser.parseInteger() elif parser.expectOptional("DEFAULT"): defaultValue = parser.getExpression() if columnName in table.columns: column = table.columns[columnName] if column is None: raise Exception("Cannot find column '%s' in table '%s' for statement '%s'.") % (columnName, table.name, parser.statement) column.defaultValue = defaultValue else: raise Exception("Cannot find column '%s' in table '%s' for statement '%s'.") % (columnName, table.name, parser.statement) elif parser.expectOptional("STORAGE"): column = table.columns[columnName] if (column is None): raise Exception("Cannot find column '%s' in table '%s' for statement '%s'.") % (columnName, table.name, parser.statement) if parser.expectOptional("PLAIN"): column.storage = "PLAIN" elif parser.expectOptional("EXTERNAL"): column.storage = "EXTERNAL" elif parser.expectOptional("EXTENDED"): column.storage = "EXTENDED" elif parser.expectOptional("MAIN"): column.storage = "MAIN" else: parser.throwUnsupportedCommand() else: parser.throwUnsupportedCommand() else: parser.throwUnsupportedCommand()
def parseIndex(parser, database): indexName = parser.parseIdentifier() objectName = ParserUtils.getObjectName(indexName) schemaName = ParserUtils.getSchemaName(indexName, database) schema = database.getSchema(schemaName) index = schema.indexes.get(objectName) if index is None: primaryKey = schema.primaryKeys[objectName] parser.expect("IS") primaryKey.comment = CommentParser.getComment(parser) parser.expect(";") else: parser.expect("IS") index.comment = CommentParser.getComment(parser) parser.expect(";")
def parseView(parser, view, viewName, database): 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"): parser.parseIdentifier() else: parser.throwUnsupportedCommand()
def parseColumn(parser, table): column = PgColumn(ParserUtils.getObjectName(parser.parseIdentifier())) table.addColumn(column) column.parseDefinition(parser.getExpression())
def parse(database, statement): parser = Parser(statement) parser.expect("CREATE") parser.expectOptional("OR", "REPLACE") parser.expect("FUNCTION") functionName = parser.parseIdentifier(); schemaName = ParserUtils.getSchemaName(functionName, database) schema = database.getSchema(schemaName) if schema is None: raise Exception("Cannot find schema '%s' for statement '%s'. Missing CREATE SCHEMA statement?" % (schemaName, statement)) function = PgFunction() function.name = ParserUtils.getObjectName(functionName) parser.expect("(") while not parser.expectOptional(")"): mode = '' if parser.expectOptional("IN"): mode = "IN" elif parser.expectOptional("OUT"): mode = "OUT" elif parser.expectOptional("INOUT"): mode = "INOUT" elif parser.expectOptional("VARIADIC"): mode = "VARIADIC" else: mode = None position = parser.position argumentName = None dataType = parser.parseDataType() position2 = parser.position if (not parser.expectOptional(")") and not parser.expectOptional(",") and not parser.expectOptional("=") and not parser.expectOptional("DEFAULT")): parser.position = position argumentName = ParserUtils.getObjectName(parser.parseIdentifier()) dataType = parser.parseDataType() else: parser.position = position2 defaultExpression = '' if (parser.expectOptional("=") or parser.expectOptional("DEFAULT")): defaultExpression = parser.getExpression() else: defaultExpression = None argument = Argument() argument.dataType = dataType argument.defaultExpression = defaultExpression argument.mode = mode argument.name = argumentName function.addArgument(argument) if (parser.expectOptional(")")): break else: parser.expect(",") function.body = parser.getRest() schema.addFunction(function)
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()
def parseConstraint(parser, table): constraint = PgConstraint(ParserUtils.getObjectName(parser.parseIdentifier())); table.addConstraint(constraint) constraint.definition = parser.getExpression() constraint.tableName = table.name