def parse(database, statement):
parser = Parser(statement)
parser.expect('CREATE', 'TABLE')
# Optional IF NOT EXISTS, irrelevant for our purposes
parser.expect_optional("IF", "NOT", "EXISTS")
tableName = ParserUtils.get_object_name(parser.parse_identifier())
table = PgTable(tableName)
# Figure it out why do we need this
schemaName = ParserUtils.get_schema_name(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.expect_optional(")"):
if parser.expect_optional("CONSTRAINT"):
CreateTableParser.parseConstraint(parser, table)
else:
CreateTableParser.parseColumn(parser, table)
if parser.expect_optional(")"):
break
else:
parser.expect(",")
while not parser.expect_optional(";"):
if parser.expect_optional("INHERITS"):
CreateTableParser.parseInherits(parser, table)
elif parser.expect_optional("WITHOUT"):
table.oids = "OIDS=false"
elif parser.expect_optional("WITH"):
if (parser.expect_optional("OIDS")
or parser.expect_optional("OIDS=true")):
table.oids = "OIDS=true"
elif parser.expect_optional("OIDS=false"):
table.oids = "OIDS=false"
else:
print 'table.setWith(parser.getExpression())'
elif parser.expect_optional("TABLESPACE"):
print 'table.setTablespace(parser.parseString()'
else:
parser.throw_unsupported_command()
def parse(database, statement):
parser = Parser(statement)
parser.expect("CREATE", "SEQUENCE")
sequenceName = parser.parse_identifier()
sequence = PgSequence(ParserUtils.get_object_name(sequenceName))
schemaName = ParserUtils.get_schema_name(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.expect_optional(";"):
if parser.expect_optional("INCREMENT"):
parser.expect_optional("BY")
sequence.increment = parser.parse_string()
elif parser.expect_optional("MINVALUE"):
sequence.minValue = parser.parse_string()
elif parser.expect_optional("MAXVALUE"):
sequence.maxValue = parser.parse_string()
elif parser.expect_optional("START"):
parser.expect_optional("WITH")
sequence.startWith = parser.parse_string()
elif parser.expect_optional("CACHE"):
sequence.cache = parser.parse_string()
elif parser.expect_optional("CYCLE"):
sequence.cycle = True
elif parser.expect_optional("OWNED", "BY"):
if parser.expect_optional("NONE"):
sequence.ownedBy = None
else:
sequence.ownedBy = ParserUtils.get_object_name(
parser.parse_identifier())
elif parser.expect_optional("NO"):
if parser.expect_optional("MINVALUE"):
sequence.minValue = None
elif parser.expect_optional("MAXVALUE"):
sequence.maxValue = None
elif parser.expect_optional("CYCLE"):
sequence.cycle = False
else:
parser.throw_unsupported_command()
else:
parser.throw_unsupported_command()
def parse(database, statement):
parser = Parser(statement)
parser.expect("CREATE", "SEQUENCE")
sequenceName = parser.parse_identifier();
sequence = PgSequence(ParserUtils.get_object_name(sequenceName))
schemaName = ParserUtils.get_schema_name(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.expect_optional(";"):
if parser.expect_optional("INCREMENT"):
parser.expect_optional("BY")
sequence.increment = parser.parse_string()
elif parser.expect_optional("MINVALUE"):
sequence.minValue = parser.parse_string()
elif parser.expect_optional("MAXVALUE"):
sequence.maxValue = parser.parse_string()
elif parser.expect_optional("START"):
parser.expect_optional("WITH")
sequence.startWith = parser.parse_string()
elif parser.expect_optional("CACHE"):
sequence.cache = parser.parse_string()
elif parser.expect_optional("CYCLE"):
sequence.cycle = True
elif parser.expect_optional("OWNED", "BY"):
if parser.expect_optional("NONE"):
sequence.ownedBy = None
else:
sequence.ownedBy = ParserUtils.get_object_name(parser.parse_identifier())
elif parser.expect_optional("NO"):
if parser.expect_optional("MINVALUE"):
sequence.minValue = None
elif parser.expect_optional("MAXVALUE"):
sequence.maxValue = None
elif parser.expect_optional("CYCLE"):
sequence.cycle = False
else:
parser.throw_unsupported_command()
else:
parser.throw_unsupported_command()
def parse(database, statement):
parser = Parser(statement)
parser.expect('CREATE', 'TABLE')
# Optional IF NOT EXISTS, irrelevant for our purposes
parser.expect_optional("IF", "NOT", "EXISTS")
tableName = ParserUtils.get_object_name(parser.parse_identifier())
table = PgTable(tableName)
# Figure it out why do we need this
schemaName = ParserUtils.get_schema_name(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.expect_optional(")"):
if parser.expect_optional("CONSTRAINT"):
CreateTableParser.parseConstraint(parser, table)
else:
CreateTableParser.parseColumn(parser, table)
if parser.expect_optional(")"):
break
else:
parser.expect(",")
while not parser.expect_optional(";"):
if parser.expect_optional("INHERITS"):
CreateTableParser.parseInherits(parser, table)
elif parser.expect_optional("WITHOUT"):
table.oids = "OIDS=false"
elif parser.expect_optional("WITH"):
if (parser.expect_optional("OIDS") or parser.expect_optional("OIDS=true")):
table.oids = "OIDS=true"
elif parser.expect_optional("OIDS=false"):
table.oids = "OIDS=false"
else:
print 'table.setWith(parser.getExpression())'
elif parser.expect_optional("TABLESPACE"):
print 'table.setTablespace(parser.parseString()'
else:
parser.throw_unsupported_command()
def parse(database, statement):
parser = Parser(statement)
parser.expect("ALTER", "VIEW")
viewName = parser.parse_identifier()
schemaName = ParserUtils.get_schema_name(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.get_object_name(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.expect_optional(";"):
if parser.expect_optional("ALTER"):
parser.expect_optional("COLUMN")
columnName = ParserUtils.get_object_name(
parser.parse_identifier())
if parser.expect_optional("SET", "DEFAULT"):
expression = parser.get_expression()
view.addColumnDefaultValue(columnName, expression)
elif parser.expect_optional("DROP", "DEFAULT"):
view.removeColumnDefaultValue(columnName)
else:
parser.throw_unsupported_command()
elif parser.expect_optional("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.parse_identifier()
# }
else:
parser.throw_unsupported_command()
def parse(database, statement):
parser = Parser(statement)
parser.expect("ALTER", "VIEW")
viewName = parser.parse_identifier()
schemaName = ParserUtils.get_schema_name(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.get_object_name(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.expect_optional(";"):
if parser.expect_optional("ALTER"):
parser.expect_optional("COLUMN")
columnName = ParserUtils.get_object_name(parser.parse_identifier())
if parser.expect_optional("SET", "DEFAULT"):
expression = parser.get_expression()
view.addColumnDefaultValue(columnName, expression)
elif parser.expect_optional("DROP", "DEFAULT"):
view.removeColumnDefaultValue(columnName)
else:
parser.throw_unsupported_command()
elif parser.expect_optional("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.parse_identifier()
# }
else:
parser.throw_unsupported_command()
def parse(database, statement, ignoreSlonyTriggers):
parser = Parser(statement)
parser.expect("CREATE", "TRIGGER")
triggerName = parser.parse_identifier()
objectName = ParserUtils.get_object_name(triggerName)
trigger = PgTrigger()
trigger.name = objectName
if parser.expect_optional("BEFORE"):
trigger.event = PgTrigger.EVENT_BEFORE
elif parser.expect_optional("AFTER"):
trigger.event = PgTrigger.EVENT_AFTER
elif parser.expect_optional("INSTEAD OF"):
trigger.event = PgTrigger.EVENT_INSTEAD_OF
first = True
while True:
if not first and not parser.expect_optional("OR"):
break
elif parser.expect_optional("INSERT"):
trigger.onInsert = True
elif parser.expect_optional("UPDATE"):
trigger.onUpdate = True
if parser.expect_optional("OF"):
while True:
trigger.updateColumns.append(parser.parse_identifier())
if not parser.expect_optional(","):
break
elif parser.expect_optional("DELETE"):
trigger.onDelete = True
elif parser.expect_optional("TRUNCATE"):
trigger.onTruncate = True
elif (first):
break
else:
parser.throw_unsupported_command()
first = False
parser.expect("ON")
trigger.tableName = ParserUtils.get_object_name(parser.parse_identifier())
if parser.expect_optional("FOR"):
parser.expect_optional("EACH")
if parser.expect_optional("ROW"):
trigger.forEachRow = True
elif parser.expect_optional("STATEMENT"):
trigger.forEachRow = False
else:
parser.throw_unsupported_command()
if parser.expect_optional("WHEN"):
parser.expect("(")
trigger.when = parser.get_expression()
parser.expect(")")
parser.expect("EXECUTE", "PROCEDURE")
trigger.function = parser.get_rest()
ignoreSlonyTrigger = ignoreSlonyTriggers and ("_slony_logtrigger" == trigger.name or "_slony_denyaccess" == trigger.name)
if (not ignoreSlonyTrigger):
schema = database.getSchema(ParserUtils.get_schema_name(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 parse(database, statement):
parser = Parser(statement)
parser.expect("ALTER", "TABLE")
parser.expect_optional("ONLY")
tableName = parser.parse_identifier()
schemaName = ParserUtils.get_schema_name(tableName, database)
schema = database.getSchema(schemaName)
if schema is None:
raise Exception("CannotFindSchema")
objectName = ParserUtils.get_object_name(tableName)
table = schema.tables.get(objectName)
if table is None:
logging.debug('Table %s was not fount in schema %s' %
(tableName, schema))
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.expect_optional(";"):
if parser.expect_optional("ALTER"):
AlterTableParser.parseAlterColumn(parser, table)
elif (parser.expect_optional("CLUSTER", "ON")):
table.clusterIndexName = ParserUtils.get_object_name(
parser.parse_identifier())
elif (parser.expect_optional("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.parse_identifier()
elif (parser.expect_optional("ADD")):
if (parser.expect_optional("FOREIGN", "KEY")):
print 'parseAddForeignKey(parser, table);'
elif (parser.expect_optional("CONSTRAINT")):
AlterTableParser.parseAddConstraint(parser, table, schema)
else:
parser.throw_unsupported_command()
elif (parser.expect_optional("ENABLE")):
print 'parseEnable(parser, outputIgnoredStatements, tableName, database);'
elif (parser.expect_optional("DISABLE")):
print 'parseDisable(parser, outputIgnoredStatements, tableName, database);'
else:
parser.throw_unsupported_command()
if (parser.expect_optional(";")):
break
else:
parser.expect(",")
def parse(database, statement):
parser = Parser(statement)
parser.expect("ALTER", "TABLE")
parser.expect_optional("ONLY")
tableName = parser.parse_identifier()
schemaName = ParserUtils.get_schema_name(tableName, database)
schema = database.getSchema(schemaName)
if schema is None:
raise Exception("CannotFindSchema")
objectName = ParserUtils.get_object_name(tableName)
table = schema.tables.get(objectName)
if table is None:
logging.debug('Table %s was not fount in schema %s' % (tableName, schema))
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.expect_optional(";"):
if parser.expect_optional("ALTER"):
AlterTableParser.parseAlterColumn(parser, table)
elif (parser.expect_optional("CLUSTER", "ON")):
table.clusterIndexName = ParserUtils.get_object_name(parser.parse_identifier())
elif (parser.expect_optional("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.parse_identifier()
elif (parser.expect_optional("ADD")):
if (parser.expect_optional("FOREIGN", "KEY")):
print 'parseAddForeignKey(parser, table);'
elif (parser.expect_optional("CONSTRAINT")):
AlterTableParser.parseAddConstraint(parser, table, schema)
else:
parser.throw_unsupported_command()
elif (parser.expect_optional("ENABLE")):
print 'parseEnable(parser, outputIgnoredStatements, tableName, database);'
elif (parser.expect_optional("DISABLE")):
print 'parseDisable(parser, outputIgnoredStatements, tableName, database);'
else:
parser.throw_unsupported_command()
if (parser.expect_optional(";")):
break
else:
parser.expect(",")
