def parse(database, statement):
parser = Parser(statement)
parser.expect("CREATE")
parser.expect_optional("OR", "REPLACE")
parser.expect("VIEW")
viewName = parser.parse_identifier()
columnsExist = parser.expect_optional("(")
columnNames = list()
if (columnsExist):
while not parser.expect_optional(")"):
columnNames.append(ParserUtils.get_object_name(parser.parse_identifier()))
parser.expect_optional(",")
parser.expect("AS")
query = parser.get_rest()
view = PgView(ParserUtils.get_object_name(viewName))
view.columnNames = columnNames
view.query = query
schemaName = ParserUtils.get_schema_name(viewName, database)
schema = database.getSchema(schemaName)
if schema is None:
raise Exception("CannotFindSchema" % (schemaName, statement))
schema.addView(view)
def parse(database, statement):
parser = Parser(statement)
parser.expect("CREATE")
parser.expect_optional("OR", "REPLACE")
parser.expect("VIEW")
viewName = parser.parse_identifier()
columnsExist = parser.expect_optional("(")
columnNames = list()
if (columnsExist):
while not parser.expect_optional(")"):
columnNames.append(
ParserUtils.get_object_name(parser.parse_identifier()))
parser.expect_optional(",")
parser.expect("AS")
query = parser.get_rest()
view = PgView(ParserUtils.get_object_name(viewName))
view.columnNames = columnNames
view.query = query
schemaName = ParserUtils.get_schema_name(viewName, database)
schema = database.getSchema(schemaName)
if schema is None:
raise Exception("CannotFindSchema" % (schemaName, statement))
schema.addView(view)
def parse(database, statement):
parser = Parser(statement)
parser.expect("CREATE")
unique = parser.expect_optional("UNIQUE")
parser.expect("INDEX")
parser.expect_optional("CONCURRENTLY")
indexName = ParserUtils.get_object_name(parser.parse_identifier())
parser.expect("ON")
tableName = parser.parse_identifier()
definition = parser.get_rest()
schemaName =ParserUtils.get_schema_name(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.get_object_name(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")
unique = parser.expect_optional("UNIQUE")
parser.expect("INDEX")
parser.expect_optional("CONCURRENTLY")
indexName = ParserUtils.get_object_name(parser.parse_identifier())
parser.expect("ON")
tableName = parser.parse_identifier()
definition = parser.get_rest()
schemaName = ParserUtils.get_schema_name(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.get_object_name(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", "SCHEMA")
if parser.expect_optional("AUTHORIZATION"):
schema = PgSchema(
ParserUtils.get_object_name(parser.parse_identifier()))
database.addSchema(schema)
schema.authorization = schema.name
else:
schemaName = ParserUtils.get_object_name(parser.parse_identifier())
schema = PgSchema(schemaName)
database.schemas[schemaName] = schema
if parser.expect_optional("AUTHORIZATION"):
schema.authorization = ParserUtils.get_object_name(
parser.parse_identifier())
definition = parser.get_rest()
if definition:
schema.definition = definition
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("CREATE")
parser.expect_optional("OR", "REPLACE")
parser.expect("FUNCTION")
functionName = parser.parse_identifier();
schemaName = ParserUtils.get_schema_name(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.get_object_name(functionName)
parser.expect("(")
while not parser.expect_optional(")"):
mode = None
if parser.expect_optional("IN"):
mode = "IN"
elif parser.expect_optional("OUT"):
mode = "OUT"
elif parser.expect_optional("INOUT"):
mode = "INOUT"
elif parser.expect_optional("VARIADIC"):
mode = "VARIADIC"
position = parser.position
argumentName = None
dataType = parser.parse_data_type()
position2 = parser.position
if (not parser.expect_optional(")") and not parser.expect_optional(",")
and not parser.expect_optional("=")
and not parser.expect_optional("DEFAULT")):
parser.position = position
argumentName = ParserUtils.get_object_name(parser.parse_identifier())
dataType = parser.parse_data_type()
else:
parser.position = position2
defaultExpression = ''
if (parser.expect_optional("=")
or parser.expect_optional("DEFAULT")):
defaultExpression = parser.get_expression()
else:
defaultExpression = None
argument = Argument()
argument.dataType = dataType
argument.defaultExpression = defaultExpression
argument.mode = mode
argument.name = argumentName
function.addArgument(argument)
if (parser.expect_optional(")")):
break
else:
parser.expect(",")
function.body = parser.get_rest()
schema.addFunction(function)
def parse(database, statement):
parser = Parser(statement)
parser.expect("CREATE")
parser.expect_optional("OR", "REPLACE")
parser.expect("FUNCTION")
functionName = parser.parse_identifier()
schemaName = ParserUtils.get_schema_name(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.get_object_name(functionName)
parser.expect("(")
while not parser.expect_optional(")"):
mode = None
if parser.expect_optional("IN"):
mode = "IN"
elif parser.expect_optional("OUT"):
mode = "OUT"
elif parser.expect_optional("INOUT"):
mode = "INOUT"
elif parser.expect_optional("VARIADIC"):
mode = "VARIADIC"
position = parser.position
argumentName = None
dataType = parser.parse_data_type()
position2 = parser.position
if (not parser.expect_optional(")")
and not parser.expect_optional(",")
and not parser.expect_optional("=")
and not parser.expect_optional("DEFAULT")):
parser.position = position
argumentName = ParserUtils.get_object_name(
parser.parse_identifier())
dataType = parser.parse_data_type()
else:
parser.position = position2
defaultExpression = ''
if (parser.expect_optional("=")
or parser.expect_optional("DEFAULT")):
defaultExpression = parser.get_expression()
else:
defaultExpression = None
argument = Argument()
argument.dataType = dataType
argument.defaultExpression = defaultExpression
argument.mode = mode
argument.name = argumentName
function.addArgument(argument)
if (parser.expect_optional(")")):
break
else:
parser.expect(",")
function.body = parser.get_rest()
schema.addFunction(function)
