def get_create_command(table):
schema = table.schema
case = schema.case
provider = schema.provider
quote_name = provider.quote_name
if_not_exists = False # provider.table_if_not_exists_syntax and provider.index_if_not_exists_syntax
cmd = []
if not if_not_exists: cmd.append(case('CREATE TABLE %s (') % quote_name(table.name))
else: cmd.append(case('CREATE TABLE IF NOT EXISTS %s (') % quote_name(table.name))
for column in table.column_list:
cmd.append(schema.indent + column.get_sql() + ',')
if len(table.pk_index.columns) > 1:
cmd.append(schema.indent + table.pk_index.get_sql() + ',')
indexes = [ index for index in itervalues(table.indexes)
if not index.is_pk and index.is_unique and len(index.columns) > 1 ]
for index in indexes: assert index.name is not None
indexes.sort(key=attrgetter('name'))
for index in indexes: cmd.append(schema.indent+index.get_sql() + ',')
if not schema.named_foreign_keys:
for foreign_key in sorted(itervalues(table.foreign_keys), key=lambda fk: fk.name):
if schema.inline_fk_syntax and len(foreign_key.child_columns) == 1: continue
cmd.append(schema.indent+foreign_key.get_sql() + ',')
cmd[-1] = cmd[-1][:-1]
cmd.append(')')
return '\n'.join(cmd)
def __init__(builder, provider, ast):
builder.provider = provider
builder.quote_name = provider.quote_name
builder.paramstyle = paramstyle = provider.paramstyle
builder.ast = ast
builder.indent = 0
builder.keys = {}
builder.inner_join_syntax = options.INNER_JOIN_SYNTAX
builder.result = flat(builder(ast))
builder.sql = u''.join(imap(unicode, builder.result)).rstrip('\n')
if paramstyle in ('qmark', 'format'):
params = tuple(x for x in builder.result if isinstance(x, Param))
def adapter(values):
return tuple(convert(values, params))
elif paramstyle == 'numeric':
params = tuple(param for param in sorted(itervalues(builder.keys), key=attrgetter('id')))
def adapter(values):
return tuple(convert(values, params))
elif paramstyle in ('named', 'pyformat'):
params = tuple(param for param in sorted(itervalues(builder.keys), key=attrgetter('id')))
def adapter(values):
return dict(('p%d' % param.id, value) for param, value in izip(params, convert(values, params)))
else: throw(NotImplementedError, paramstyle)
builder.params = params
builder.layout = tuple(param.paramkey for param in params)
builder.adapter = adapter
def _clear(dict, list1, list2):
url_cache.clear()
for route in list1: route.func.routes.remove(route)
list1[:] = []
for route in list2: route.func.routes.remove(route)
list2[:] = []
for inner_dict, list1, list2 in itervalues(dict):
_clear(inner_dict, list1, list2)
dict.clear()
def get_objects_to_create(table, created_tables=None):
if created_tables is None: created_tables = set()
result = [ table ]
indexes = [ index for index in itervalues(table.indexes) if not index.is_pk and not index.is_unique ]
for index in indexes: assert index.name is not None
indexes.sort(key=attrgetter('name'))
result.extend(indexes)
schema = table.schema
if schema.named_foreign_keys:
for foreign_key in sorted(itervalues(table.foreign_keys), key=lambda fk: fk.name):
if foreign_key.parent_table not in created_tables: continue
result.append(foreign_key)
for child_table in table.child_tables:
if child_table not in created_tables: continue
for foreign_key in sorted(itervalues(child_table.foreign_keys), key=lambda fk: fk.name):
if foreign_key.parent_table is not table: continue
result.append(foreign_key)
created_tables.add(table)
return result
def order_tables_to_create(schema):
tables = []
created_tables = set()
tables_to_create = sorted(itervalues(schema.tables), key=lambda table: table.name)
while tables_to_create:
for table in tables_to_create:
if table.parent_tables.issubset(created_tables):
created_tables.add(table)
tables_to_create.remove(table)
break
else: table = tables_to_create.pop()
tables.append(table)
return tables
def check_tables(schema, provider, connection):
cursor = connection.cursor()
for table in sorted(itervalues(schema.tables), key=lambda table: table.name):
if isinstance(table.name, tuple): alias = table.name[-1]
elif isinstance(table.name, basestring): alias = table.name
else: assert False # pragma: no cover
sql_ast = [ 'SELECT',
[ 'ALL', ] + [ [ 'COLUMN', alias, column.name ] for column in table.column_list ],
[ 'FROM', [ alias, 'TABLE', table.name ] ],
[ 'WHERE', [ 'EQ', [ 'VALUE', 0 ], [ 'VALUE', 1 ] ] ]
]
sql, adapter = provider.ast2sql(sql_ast)
if core.debug: log_sql(sql)
provider.execute(cursor, sql)
def check_tables(schema, provider, connection):
cursor = connection.cursor()
for table in sorted(itervalues(schema.tables),
key=lambda table: table.name):
if isinstance(table.name, tuple): alias = table.name[-1]
elif isinstance(table.name, basestring): alias = table.name
else: assert False # pragma: no cover
sql_ast = [
'SELECT', [
'ALL',
] + [['COLUMN', alias, column.name]
for column in table.column_list],
['FROM', [alias, 'TABLE', table.name]],
['WHERE', ['EQ', ['VALUE', 0], ['VALUE', 1]]]
]
sql, adapter = provider.ast2sql(sql_ast)
if core.debug: log_sql(sql)
provider.execute(cursor, sql)
def flush_all(cache):
cache._dict.clear()
cache._heap = []
cache._list.prev = cache._list.next = cache._list
for node in itervalues(cache._dict):
node.prev = node.next = None
def flush_all(cache):
cache._dict.clear()
cache._heap = []
cache._list.prev = cache._list.next = cache._list
for node in itervalues(cache._dict):
node.prev = node.next = None
