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 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")
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()
