def upgrade_to_0_2_4(env, db, installed_version):
if installed_version>=[0,2,4]:
return True
milestones_shema_ext = [
Table('milestone_change', key=('milestone', 'time', 'field'))[
Column('milestone'),
Column('time', type='int'),
Column('author'),
Column('field'),
Column('oldvalue'),
Column('newvalue'),
Index(['milestone']),
Index(['time'])],
Table('milestone_custom', key=('milestone', 'name'))[
Column('milestone'),
Column('name'),
Column('value')]
]
db = db or env.get_db_cnx()
cursor = db.cursor()
db_backend, _ = DatabaseManager(env)._get_connector()
for table in milestones_shema_ext:
for stmt in db_backend.to_sql(table):
cursor.execute(stmt)
return True
def do_upgrade(env, ver, cursor):
# Change repository key from reponame to a surrogate id
cursor.execute("SELECT id FROM repository "
"UNION SELECT repos AS id FROM revision "
"UNION SELECT repos AS id FROM node_change "
"ORDER BY id")
id_name_list = [(i + 1, name) for i, (name,) in enumerate(cursor)]
cursor.execute("CREATE TEMPORARY TABLE repo_old "
"AS SELECT * FROM repository")
cursor.execute("DROP TABLE repository")
cursor.execute("CREATE TEMPORARY TABLE rev_old "
"AS SELECT * FROM revision")
cursor.execute("DROP TABLE revision")
cursor.execute("CREATE TEMPORARY TABLE nc_old "
"AS SELECT * FROM node_change")
cursor.execute("DROP TABLE node_change")
tables = [Table('repository', key=('id', 'name'))[
Column('id', type='int'),
Column('name'),
Column('value')],
Table('revision', key=('repos', 'rev'))[
Column('repos', type='int'),
Column('rev', key_size=20),
Column('time', type='int'),
Column('author'),
Column('message'),
Index(['repos', 'time'])],
Table('node_change', key=('repos', 'rev', 'path', 'change_type'))[
Column('repos', type='int'),
Column('rev', key_size=20),
Column('path', key_size=255),
Column('node_type', size=1),
Column('change_type', size=1, key_size=2),
Column('base_path'),
Column('base_rev'),
Index(['repos', 'rev'])]]
db_connector, _ = DatabaseManager(env)._get_connector()
for table in tables:
for stmt in db_connector.to_sql(table):
cursor.execute(stmt)
cursor.executemany("INSERT INTO repository (id,name,value) "
"VALUES (%s,'name',%s)", id_name_list)
cursor.executemany("INSERT INTO repository (id,name,value) "
"SELECT %s,name,value FROM repo_old WHERE id=%s",
id_name_list)
cursor.execute("DROP TABLE repo_old")
cursor.executemany("INSERT INTO revision (repos,rev,time,author,message) "
"SELECT %s,rev,time,author,message FROM rev_old "
"WHERE repos=%s", id_name_list)
cursor.execute("DROP TABLE rev_old")
cursor.executemany("INSERT INTO node_change (repos,rev,path,node_type,"
" change_type,base_path,base_rev) "
"SELECT %s,rev,path,node_type,change_type,base_path,"
" base_rev FROM nc_old WHERE repos=%s", id_name_list)
cursor.execute("DROP TABLE nc_old")
def do_upgrade(env, ver, cursor):
cursor.execute("CREATE TEMPORARY TABLE session_old AS SELECT * FROM session")
cursor.execute("DROP TABLE session")
cursor.execute("CREATE TEMPORARY TABLE ticket_change_old AS SELECT * FROM ticket_change")
cursor.execute("DROP TABLE ticket_change")
# A more normalized session schema where the attributes are stored in
# a separate table
tables = [Table('session', key=('sid', 'authenticated'))[
Column('sid'),
Column('authenticated', type='int'),
Column('last_visit', type='int'),
Index(['last_visit']),
Index(['authenticated'])],
Table('session_attribute', key=('sid', 'authenticated', 'name'))[
Column('sid'),
Column('authenticated', type='int'),
Column('name'),
Column('value')],
Table('ticket_change', key=('ticket', 'time', 'field'))[
Column('ticket', type='int'),
Column('time', type='int'),
Column('author'),
Column('field'),
Column('oldvalue'),
Column('newvalue'),
Index(['ticket']),
Index(['time'])]]
db_connector, _ = DatabaseManager(env)._get_connector()
for table in tables:
for stmt in db_connector.to_sql(table):
cursor.execute(stmt)
# Add an index to the temporary table to speed up the conversion
cursor.execute("CREATE INDEX session_old_sid_idx ON session_old(sid)")
# Insert the sessions into the new table
db = env.get_db_cnx()
cursor.execute("INSERT INTO session (sid, last_visit, authenticated) "
"SELECT distinct s.sid,COALESCE(%s,0),s.authenticated "
"FROM session_old AS s LEFT JOIN session_old AS s2 "
"ON (s.sid=s2.sid AND s2.var_name='last_visit') "
"WHERE s.sid IS NOT NULL"
% db.cast('s2.var_value', 'int'))
cursor.execute("INSERT INTO session_attribute "
"(sid, authenticated, name, value) "
"SELECT s.sid, s.authenticated, s.var_name, s.var_value "
"FROM session_old s "
"WHERE s.var_name <> 'last_visit' AND s.sid IS NOT NULL")
# Insert ticket change data into the new table
cursor.execute("INSERT INTO ticket_change "
"(ticket, time, author, field, oldvalue, newvalue) "
"SELECT ticket, time, author, field, oldvalue, newvalue "
"FROM ticket_change_old")
cursor.execute("DROP TABLE session_old")
cursor.execute("DROP TABLE ticket_change_old")
def do_upgrade(env, ver, cursor):
# Make changeset cache multi-repository aware
cursor.execute("CREATE TEMPORARY TABLE rev_old "
"AS SELECT * FROM revision")
cursor.execute("DROP TABLE revision")
cursor.execute("CREATE TEMPORARY TABLE nc_old "
"AS SELECT * FROM node_change")
cursor.execute("DROP TABLE node_change")
tables = [
Table('repository', key=('id', 'name'))[Column('id'),
Column('name'),
Column('value')],
Table('revision', key=('repos', 'rev'))[Column('repos'),
Column('rev', key_size=20),
Column('time', type='int'),
Column('author'),
Column('message'),
Index(['repos', 'time'])],
Table('node_change',
key=('repos', 'rev', 'path',
'change_type'))[Column('repos', key_size=56),
Column('rev', key_size=20),
Column('path', key_size=255),
Column('node_type', size=1),
Column('change_type', size=1, key_size=2),
Column('base_path'),
Column('base_rev'),
Index(['repos', 'rev'])]
]
db_connector, _ = DatabaseManager(env)._get_connector()
for table in tables:
for stmt in db_connector.to_sql(table):
cursor.execute(stmt)
cursor.execute("INSERT INTO revision (repos,rev,time,author,message) "
"SELECT '',rev,time,author,message FROM rev_old")
cursor.execute("DROP TABLE rev_old")
cursor.execute("INSERT INTO node_change (repos,rev,path,node_type,"
"change_type,base_path,base_rev) "
"SELECT '',rev,path,node_type,change_type,base_path,"
"base_rev FROM nc_old")
cursor.execute("DROP TABLE nc_old")
cursor.execute("INSERT INTO repository (id,name,value) "
"SELECT '',name,value FROM system "
"WHERE name IN ('repository_dir', 'youngest_rev')")
cursor.execute("DELETE FROM system "
"WHERE name IN ('repository_dir', 'youngest_rev')")
def add_log_table(env, db):
"""Add a table for storing the builds logs."""
INFO_LEVEL = 'I'
cursor = db.cursor()
build_log_schema_v3 = [
Table('bitten_log', key='id')[
Column('id', auto_increment=True), Column('build', type='int'),
Column('step'), Column('type')
],
Table('bitten_log_message', key=('log', 'line'))[
Column('log', type='int'), Column('line', type='int'),
Column('level', size=1), Column('message')
]
]
build_step_schema_v3 = [
Table('bitten_step', key=('build', 'name'))[
Column('build', type='int'), Column('name'), Column('description'),
Column('status', size=1), Column('started', type='int'),
Column('stopped', type='int')
]
]
connector, _ = DatabaseManager(env)._get_connector()
for table in build_log_schema_v3:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
update_cursor = db.cursor()
cursor.execute("SELECT build,name,log FROM bitten_step "
"WHERE log IS NOT NULL")
for build, step, log in cursor:
update_cursor.execute("INSERT INTO bitten_log (build, step) "
"VALUES (%s,%s)", (build, step))
log_id = db.get_last_id(update_cursor, 'bitten_log')
messages = [(log_id, line, INFO_LEVEL, msg)
for line, msg in enumerate(log.splitlines())]
update_cursor.executemany("INSERT INTO bitten_log_message (log, line, level, message) "
"VALUES (%s, %s, %s, %s)", messages)
cursor.execute("CREATE TEMPORARY TABLE old_step AS SELECT * FROM bitten_step")
cursor.execute("DROP TABLE bitten_step")
for table in build_step_schema_v3:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
cursor.execute("INSERT INTO bitten_step (build,name,description,status,"
"started,stopped) SELECT build,name,description,status,"
"started,stopped FROM old_step")
def test_db_table():
# Create a EnvironmentStub
env = EnvironmentStub()
# Create a test table
table = Table('test', key=['id'])[Column('id', type='integer'),
Column(Key.NAME, type='text')]
# Get The Databse Manager
dbm = DatabaseManager(env)
# Get the Connector Object for the current DB schema
connector, args = dbm._get_connector()
# Ask the connector to generate the proper DDL for the table
ddl_gen = connector.to_sql(table)
# Get a DB Connection from the pool, create a cursor and the table
conn = dbm.get_connection()
try:
cursor = conn.cursor()
for statement in ddl_gen:
print "Table: %s\n%s" % (table.name, statement)
cursor.execute(statement)
conn.commit()
print "Successfully Created Table %s" % table.name
except Exception, e:
conn.rollback()
print "[ERROR]: Unable to Create Table %s, an error occurred: %s" % \
(table.name, str(e))
def do_upgrade(env, ver, cursor):
"""Add the cache table."""
table = Table('cache', key='id')[Column('id'),
Column('generation', type='int')]
db_connector, _ = DatabaseManager(env).get_connector()
for stmt in db_connector.to_sql(table):
cursor.execute(stmt)
def new_table(self):
return Table('agilo_backlog_ticket',
key=['name', 'scope',
'ticket_id'])[Column('name'),
Column('scope'),
Column('ticket_id', type='integer'),
Column('pos', type='integer'), ]
def do_upgrade(env, ver, cursor, db_connector):
link_table = Table('link',
key=('src', 'dest'))[Column('src', type='integer'),
Column('dest', type='integer')]
create_table_with_cursor(link_table, cursor, db_connector)
return True
def upgrade_to_0_1_9(env, db, installed_version):
if installed_version >= [0, 1, 9]:
return
cursor = db.cursor()
mil_table = None
for table in schema:
if table.name == 'milestone':
mil_table = table
break
if mil_table:
cols = ",".join([c.name for c in mil_table.columns])
cursor.execute(
"CREATE TEMPORARY TABLE milestone_old as SELECT %s FROM milestone;"
% cols)
cursor.execute("DROP TABLE milestone;")
new_mil_table = Table('milestone',
key='id')[mil_table.columns + mil_table.indices +
[Column('started', type='int')]]
db_backend, _ = DatabaseManager(env)._get_connector()
for stmt in db_backend.to_sql(new_mil_table):
cursor.execute(stmt)
cursor.execute(
"INSERT INTO milestone (%s) SELECT %s FROM milestone_old;" %
(cols, cols))
env.log.debug("Upgrading: upgrade_to_0_1_9")
class MindMapMacro(Component):
"""
Website: http://trac-hacks.org/wiki/MindMapMacro
`$Id$`
"""
implements(IWikiMacroProvider, IHTMLPreviewRenderer, ITemplateProvider,
IRequestHandler, IRequestFilter, IEnvironmentSetupParticipant)
default_width = Option('mindmap', 'default_width', '100%',
'Default width for mindmaps')
default_height = Option('mindmap', 'default_height', '600',
'Default height for mindmaps')
default_flashvars = ListOption(
'mindmap', 'default_flashvars',
['openUrl = _blank', 'startCollapsedToLevel = 5'],
'Default flashvars for mindmaps')
resizable = Option(
'mindmap', 'resizable', True,
'Allow mindmaps to be resized. Needs several script and style files.')
default_resizable = BoolOption(
'mindmap', 'default_resizable', True,
'Default setting if mindmaps are resizable.')
SCHEMA = [
Table('mindmapcache', key='hash')[Column('hash'),
Column('content'), ]
]
DB_VERSION = 0
def environment_created(self):
self._upgrade_db(self.env.get_db_cnx())
def environment_needs_upgrade(self, db):
cursor = db.cursor()
try:
cursor.execute("select count(*) from mindmapcache")
cursor.fetchone()
return False
except:
db.rollback()
return True
def upgrade_environment(self, db):
self._upgrade_db(db)
def _upgrade_db(self, db):
try:
db_backend, _ = DatabaseManager(self.env)._get_connector()
cursor = db.cursor()
for table in self.SCHEMA:
for stmt in db_backend.to_sql(table):
self.log.debug(stmt)
cursor.execute(stmt)
except Exception, e:
db.rollback()
self.log.error(e, exc_info=True)
raise TracError(unicode(e))
def add_indexes(env, db):
""" Add indexes on fields id and time. """
table = Table('pastes', key='id')[Column('id', auto_increment=True),
Column('title'),
Column('author'),
Column('mimetype'),
Column('data'),
Column('time', type='int'),
Index([
'id',
]),
Index([
'time',
])]
cursor = db.cursor()
try:
cursor.execute("CREATE TEMPORARY TABLE pastes_old AS "
"SELECT * FROM pastes")
cursor.execute("DROP TABLE pastes")
for stmt in _to_sql(env, table):
env.log.debug(stmt)
cursor.execute(stmt)
cursor.execute(
"INSERT INTO pastes (id,title,author,mimetype,data,time) "
"SELECT id,title,author,mimetype,data,time "
"FROM pastes_old")
cursor.execute("DROP TABLE pastes_old")
except Exception, e:
env.log.error(e, exc_info=1)
raise TracError(str(e))
class TagModelProvider(Component):
implements(IEnvironmentSetupParticipant)
SCHEMA = [
Table('tags',
key=('tagspace', 'name', 'tag'))[Column('tagspace'),
Column('name'),
Column('tag'),
Index(['tagspace', 'name']),
Index(['tagspace', 'tag']), ]
]
# IEnvironmentSetupParticipant methods
def environment_created(self):
self._upgrade_db(self.env.get_db_cnx())
def environment_needs_upgrade(self, db):
if self._need_migration(db):
return True
try:
cursor = db.cursor()
cursor.execute("select count(*) from tags")
cursor.fetchone()
return False
except Exception, e:
self.log.error("DatabaseError: %s", e)
db.rollback()
return True
def do_upgrade(env, ver, cursor):
"""Rename the columns `kind` and `change` in the `node_change` table for
compatibity with MySQL.
"""
cursor.execute(
"CREATE TEMPORARY TABLE nc_old AS SELECT * FROM node_change")
cursor.execute("DROP TABLE node_change")
table = Table('node_change',
key=('rev', 'path',
'change_type'))[Column('rev'),
Column('path'),
Column('node_type', size=1),
Column('change_type', size=1),
Column('base_path'),
Column('base_rev'),
Index(['rev'])]
db_connector, _ = DatabaseManager(env).get_connector()
for stmt in db_connector.to_sql(table):
cursor.execute(stmt)
cursor.execute("INSERT INTO node_change (rev,path,node_type,change_type,"
"base_path,base_rev) SELECT rev,path,kind,change,"
"base_path,base_rev FROM nc_old")
cursor.execute("DROP TABLE nc_old")
def upgrade_environment(self, db):
"""Actually perform an environment upgrade.
Implementations of this method should not commit any database
transactions. This is done implicitly after all participants have
performed the upgrades they need without an error being raised.
"""
# create a table for ticket location
ticket_location_table = Table(
'ticket_location', key='ticket')[Column('ticket', type='int'),
Column('latitude', type='float'),
Column('longitude', type='float'),
Index(['ticket'])]
create_table(self.env, ticket_location_table)
# update ticket locations
tickets = get_column(self.env, 'ticket', 'id')
tickets = [Ticket(self.env, ticket) for ticket in tickets]
for ticket in tickets:
try:
location, (lat, lon) = self.locate_ticket(ticket)
self.set_location(ticket.id, lat, lon)
except GeolocationException:
pass
# note the DB version
execute_non_query(
self.env,
"insert into system (name, value) values ('geoticket.db_version', '1');"
)
# add a default dashboard panel
self.default_dashboard()
def add_last_activity_to_build(env, db):
"""Add a column for storing the last activity to the build table."""
cursor = db.cursor()
build_table_schema_v12 = Table('bitten_build', key='id')[
Column('id', auto_increment=True), Column('config'), Column('rev'),
Column('rev_time', type='int'), Column('platform', type='int'),
Column('slave'), Column('started', type='int'),
Column('stopped', type='int'), Column('status', size=1),
Column('last_activity', type='int'),
Index(['config', 'rev', 'platform'], unique=True)
]
cursor.execute("CREATE TEMPORARY TABLE old_build_v11 AS "
"SELECT * FROM bitten_build")
cursor.execute("DROP TABLE bitten_build")
connector, _ = DatabaseManager(env)._get_connector()
for stmt in connector.to_sql(build_table_schema_v12):
cursor.execute(stmt)
# it's safe to make the last activity the stop time of the build
cursor.execute("INSERT INTO bitten_build (id,config,rev,rev_time,platform,"
"slave,started,stopped,last_activity,status) "
"SELECT id,config,rev,rev_time,platform,"
"slave,started,stopped,stopped,status FROM old_build_v11")
update_sequence(env, db, 'bitten_build', 'id')
def test_quote_column_names(self):
table = Table('foo')
table[Column('my name'), ]
sql_generator = PostgreSQLConnector(self.env).to_sql(table)
sql_commands = self._normalize_sql(sql_generator)
self.assertEqual(1, len(sql_commands))
self.assertEqual('CREATE TABLE "foo" ( "my name" text)',
sql_commands[0])
def add_query_table(self):
time_query_table = Table('ticket_time_query', key=('id'))[
Column('id', auto_increment=True),
Column('title', unique=True),
Column('description'),
Column('query')]
create_table(self.env, time_query_table)
def upgrade_to_0_2_0(env, db, installed_version):
if installed_version>=[0,2,0]:
return True
tables = [
Table('calendar', key='id')[
Column('id', auto_increment=True),
Column('name'),
Column('owner'),
Column('type', size=1),
Column('alias'),
Column('theme', type='int'),
Column('ref', type='int'),
Column('created', type='int'),
Column('modified', type='int'),
Index(['alias'])],
Table('cal_event', key='id')[
Column('id', auto_increment=True),
Column('title'),
Column('description'),
Column('calendar_id', type='int'),#calendar id
Column('ticket', type='int'),#referenced ticket
Column('dtstart', type='int'),
Column('dtend', type='int'),
Column('created', type='int'),
Column('modified', type='int'),
Index(['dtstart']),
Index(['dtend'])],
Table('time_track', key=('event_id', 'owner'))[
Column('event_id'),
Column('owner'),
Column('auto', type='int'),
Column('time', type='int'),
Index(['owner'])]
]
db = db or env.get_db_cnx()
cursor = db.cursor()
db_backend, _ = DatabaseManager(env)._get_connector()
for table in tables:
for stmt in db_backend.to_sql(table):
cursor.execute(stmt)
for stmt in _sql:
cursor.execute(stmt)
return True
class UpgradeHelperTestCase(BaseUpgradeTestCase):
schema = [
Table('test_update_sequence',
key='id')[Column('id', auto_increment=True),
Column('name'), ],
Table('test_drop_index', key='id')[Column('id', type='int'),
Column('name', size=20),
Index(['name'])],
]
def test_update_sequence(self):
db = self.env.get_db_cnx()
cursor = db.cursor()
for rowid, name in [(1, 'a'), (2, 'b'), (3, 'c')]:
cursor.execute(
"INSERT INTO test_update_sequence (id, name)"
" VALUES (%s, %s)", (rowid, name))
update_sequence(self.env, db, 'test_update_sequence', 'id')
cursor.execute(
"INSERT INTO test_update_sequence (name)"
" VALUES (%s)", ('d', ))
cursor.execute("SELECT id FROM test_update_sequence WHERE name = %s",
('d', ))
row = cursor.fetchone()
self.assertEqual(row[0], 4)
def test_drop_index(self):
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute(
"INSERT INTO test_drop_index (id, name)"
" VALUES (%s, %s)", (1, 'a'))
def do_drop():
drop_index(self.env, db, 'test_drop_index',
'test_drop_index_name_idx')
# dropping the index should succeed the first time and fail the next
do_drop()
self.assertRaises(Exception, do_drop)
def create_burndown_changes_table(self):
burndown_changes_table = Table('agilo_burndown_data_change', key=('id',))[
Column('id', type='integer', auto_increment=True),
Column('burndown_type'),
Column('scope'),
Column('timestamp', type='int'),
Column('value')
]
create_table_with_cursor(burndown_changes_table, self.cursor, self.db_connector)
def do_initial_setup(env, db, installed_version):
if installed_version >= [0, 1]:
return
tables = [
Table('milestone_struct', key=['name', 'parent'])[Column('name'),
Column('parent')],
Table('tkt_links', key=['src', 'dest'])[Column('src', type='integer'),
Column('dest', type='integer')]
]
db = db or env.get_db_cnx()
cursor = db.cursor()
db_backend, _ = DatabaseManager(env)._get_connector()
for table in tables:
for stmt in db_backend.to_sql(table):
cursor.execute(stmt)
env.log.debug("Upgrading: do_initial_setup")
def add_report_tables(env, db):
"""Add database tables for report storage."""
cursor = db.cursor()
report_schema_v6 = Table('bitten_report', key='id')[
Column('id', auto_increment=True), Column('build', type='int'),
Column('step'), Column('category'), Column('generator'),
Index(['build', 'step', 'category'])
]
report_item_schema_v6 = Table('bitten_report_item', key=('report', 'item', 'name'))[
Column('report', type='int'), Column('item', type='int'),
Column('name'), Column('value')
]
connector, _ = DatabaseManager(env)._get_connector()
for table in [report_schema_v6, report_item_schema_v6]:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
def db00(self, env, cursor):
"""Create the major tables."""
tables = [
Table('tracform_forms',
key='id')[Column('tracform_id', auto_increment=True),
Column('context'),
Column('state'),
Column('updater'),
Column('updated_on', type='int')],
Table('tracform_history')[Column('tracform_id', type='int'),
Column('updater'),
Column('updated_on', type='int'),
Column('old_states')]
]
db_connector, _ = DatabaseManager(env)._get_connector()
for table in tables:
for stmt in db_connector.to_sql(table):
cursor.execute(stmt)
def _create_new_tables(cursor, db_connector):
contingent = \
Table('agilo_contingent', key=('name', 'sprint'))[
Column('name'),
Column('sprint'),
Column('amount', type='real'),
Column('actual', type='real'),
]
create_table_with_cursor(contingent, cursor, db_connector)
class BlogPartsProvider(Component):
implements(IEnvironmentSetupParticipant)
SCHEMA = [
Table('blogpart', key=('name'))[Column('name'),
Column('summery'),
Column('description'),
Column('header'),
Column('body'),
Column('argnum'),
Column('time'), ]
]
# IEnvironmentSetupParticipant methods
def environment_created(self):
self._upgrade_db(self.env.get_db_cnx())
def environment_needs_upgrade(self, db):
cursor = db.cursor()
#if self._need_migration(db):
# return True
try:
cursor.execute("select count(*) from blogpart")
cursor.fetchone()
return False
except:
db.rollback()
return True
def upgrade_environment(self, db):
self._upgrade_db(db)
def _upgrade_db(self, db):
try:
try:
from trac.db import DatabaseManager
db_backend, _ = DatabaseManager(self.env)._get_connector()
except ImportError:
db_backend = self.env.get_db_cnx()
cursor = db.cursor()
for table in self.SCHEMA:
for stmt in db_backend.to_sql(table):
self.env.log.debug(stmt)
cursor.execute(stmt)
db.commit()
# Migrate old data
#if self._need_migration(db):
# cursor = db.cursor()
# cursor.execute("INSERT INTO tags (tagspace, name, tag) SELECT "
# "'wiki', name, namespace FROM wiki_namespace")
# cursor.execute("DROP TABLE wiki_namespace")
# db.commit()
except:
db.rollback()
raise
def test_quote_index_declaration_for_multiple_indexes(self):
table = Table('foo')
table[Column('a'), Column('b'), Index(['a', 'b'])]
sql_generator = PostgreSQLConnector(self.env).to_sql(table)
sql_commands = self._normalize_sql(sql_generator)
self.assertEqual(2, len(sql_commands))
self.assertEqual('CREATE TABLE "foo" ( "a" text, "b" text)',
sql_commands[0])
index_sql = 'CREATE INDEX "foo_a_b_idx" ON "foo" ("a","b")'
self.assertEqual(index_sql, sql_commands[1])
def test_quote_index_declaration(self):
table = Table('foo')
table[Column('my name'), Index(['my name'])]
sql_generator = PostgreSQLConnector(self.env).to_sql(table)
sql_commands = self._normalize_sql(sql_generator)
self.assertEqual(2, len(sql_commands))
self.assertEqual('CREATE TABLE "foo" ( "my name" text)',
sql_commands[0])
index_sql = 'CREATE INDEX "foo_my name_idx" ON "foo" ("my name")'
self.assertEqual(index_sql, sql_commands[1])
def test_quote_compound_primary_key_declaration(self):
table = Table('foo bar', key=['my name', 'your name'])
table[Column('my name'), Column('your name'), ]
sql_generator = PostgreSQLConnector(self.env).to_sql(table)
sql_commands = self._normalize_sql(sql_generator)
self.assertEqual(1, len(sql_commands))
expected_sql = 'CREATE TABLE "foo bar" ( "my name" text, ' + \
'"your name" text, CONSTRAINT "foo bar_pk" ' +\
'PRIMARY KEY ("my name","your name"))'
self.assertEqual(expected_sql, sql_commands[0])
def _create_tables(self, db):
table = Table('task_list_ticket',
key='id')[Column('id', auto_increment=True),
Column('tasklist', type='int'),
Column('ticket', type='int'),
Index(['tasklist', 'ticket']), ]
cursor = db.cursor()
backend, __ = DatabaseManager(self.env)._get_connector()
for stmt in backend.to_sql(table):
cursor.execute(stmt)
