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 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 create_table(env, table, conn=None):
"""
Creates a the given table in the given environment. The Table
has to be of type trac.db.Table, and the Environment a
trac.env.Environment.
"""
assert isinstance(env, Environment), \
"[DB]: env should be an instance of trac.env.Environment, got %s" % type(env)
assert isinstance(table, Table), \
"[DB]: table should be an instance of trac.sb.Table, got %s" % type(table)
# 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, handle_ta = get_db_for_write(env, conn)
try:
cursor = conn.cursor()
for statement in ddl_gen:
debug(env, "[DB]: Table: %s\n%s" % (table.name, statement))
cursor.execute(statement)
if handle_ta:
conn.commit()
debug(env, "[DB]: Successfully Created Table %s" % table.name)
except Exception, e:
if handle_ta:
conn.rollback()
error(env, "[DB]: Unable to Create Table %s, an error occurred: %s" % \
(table.name, exception_to_unicode(e)))
raise
def create_table(env, table, conn=None):
"""
Creates a the given table in the given environment. The Table
has to be of type trac.db.Table, and the Environment a
trac.env.Environment.
"""
assert isinstance(env, Environment), \
"[DB]: env should be an instance of trac.env.Environment, got %s" % type(env)
assert isinstance(table, Table), \
"[DB]: table should be an instance of trac.sb.Table, got %s" % type(table)
# 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, handle_ta = get_db_for_write(env, conn)
try:
cursor = conn.cursor()
for statement in ddl_gen:
debug(env, "[DB]: Table: %s\n%s" % (table.name, statement))
cursor.execute(statement)
if handle_ta:
conn.commit()
debug(env, "[DB]: Successfully Created Table %s" % table.name)
except Exception, e:
if handle_ta:
conn.rollback()
error(env, "[DB]: Unable to Create Table %s, an error occurred: %s" % \
(table.name, exception_to_unicode(e)))
raise
def _upgrade_db(self, db):
"""Each schema version should have its own upgrade module, named
upgrades/dbN.py, where 'N' is the version number (int).
"""
db_mgr = DatabaseManager(self.env)
schema_ver = db_default.get_current_schema_version(db)
cursor = db.cursor()
# Is this a new installation?
if not schema_ver:
# Perform a single-step install: Create plugin schema and
# insert default data into the database.
connector = db_mgr._get_connector()[0]
for table in db_default.schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
for table, cols, vals in db_default.get_data(db):
cursor.executemany("INSERT INTO %s (%s) VALUES (%s)" % (table,
','.join(cols),
','.join(['%s' for c in cols])), vals)
else:
# Perform incremental upgrades.
for i in range(schema_ver + 1, db_default.schema_version + 1):
(upgrades_module,_) = __name__.split('.',1)
upgrades_module += '.upgrades'
name = 'db%i' % i
try:
upgrades = __import__(upgrades_module, globals(),
locals(), [name])
script = getattr(upgrades, name)
except (AttributeError, ImportError) as e:
self.log.info("No upgrade module for version %(num)i (%(version)s.py) in %(module)s" % { 'num':i, 'version':name, 'module':upgrades_module})
script = None
if script:
script.do_upgrade(self.env, i, cursor)
cursor.execute("""
UPDATE system
SET value=%i
WHERE name='%s'
""" % (db_default.schema_version, db_default.name + '_version'))
self.log.info("Upgraded %s db schema from version %d to %d"
% (db_default.name, schema_ver, db_default.schema_version))
db.commit()
custom = self.config['ticket-custom']
config_dirty = False
if 'linked_crash' not in custom:
custom.set('linked_crash', 'text')
custom.set('linked_crash.label', 'Linked crash')
config_dirty = True
if config_dirty:
self.config.save()
def get_db_type(env):
"""Returns the DB type for the given trac Environment"""
assert isinstance(env, Environment), \
"env should be an instance of trac.Environment, got %s" % str(env)
# Get The Databse Manager
dbm = DatabaseManager(env)
# Get the Connector Object for the current DB schema
connector, args = dbm._get_connector()
# Since trac r8582 get_supported_schemes is now a generator so we need to
# unroll it first (also to stay compatible with trac < 0.11.6)
supported_schemes = [i for i in connector.get_supported_schemes()]
db_type, trans = supported_schemes[0]
return db_type
def get_db_type(env):
"""Returns the DB type for the given trac Environment"""
assert isinstance(env, Environment), \
"env should be an instance of trac.Environment, got %s" % str(env)
# Get The Databse Manager
dbm = DatabaseManager(env)
# Get the Connector Object for the current DB schema
connector, args = dbm._get_connector()
# Since trac r8582 get_supported_schemes is now a generator so we need to
# unroll it first (also to stay compatible with trac < 0.11.6)
supported_schemes = [i for i in connector.get_supported_schemes()]
db_type, trans = supported_schemes[0]
return db_type
def upgrade_environment(self, db):
"""Each schema version should have its own upgrade module, named
upgrades/dbN.py, where 'N' is the version number (int).
"""
db_mgr = DatabaseManager(self.env)
schema_ver = self.get_schema_version(db)
cursor = db.cursor()
# Is this a new installation?
if not schema_ver:
# Perform a single-step install: Create plugin schema and
# insert default data into the database.
connector = db_mgr._get_connector()[0]
for table in self.schema:
for stmt in connector.to_sql(table):
self.env.log.debug(stmt)
cursor.execute(stmt)
for table, cols, vals in self.db_data:
cursor.executemany(
"INSERT INTO %s (%s) VALUES (%s)" %
(table, ','.join(cols), ','.join(['%s' for c in cols])),
vals)
elif schema_ver < self.schema_version:
# Perform incremental upgrades.
for i in range(schema_ver + 1, self.schema_version + 1):
name = 'db%i' % i
try:
upgrades = __import__('tracvote.upgrades', globals(),
locals(), [name])
script = getattr(upgrades, name)
except AttributeError:
raise TracError(
"No upgrade module for version "
"%(num)i (%(version)s.py)",
num=i,
version=name)
script.do_upgrade(self.env, i, cursor)
else:
# Obsolete call handled gracefully.
return
cursor.execute(
"""
UPDATE system
SET value=%s
WHERE name='vote_version'
""", (self.schema_version, ))
self.log.info("Upgraded VotePlugin db schema from version %d to %d" %
(schema_ver, self.schema_version))
db.commit()
def upgrade_environment(self, db):
"""Each schema version should have its own upgrade module, named
upgrades/dbN.py, where 'N' is the version number (int).
"""
db_mgr = DatabaseManager(self.env)
schema_ver = self.get_schema_version(db)
cursor = db.cursor()
# Is this a new installation?
if not schema_ver:
# Perform a single-step install: Create plugin schema and
# insert default data into the database.
connector = db_mgr._get_connector()[0]
for table in self.schema:
for stmt in connector.to_sql(table):
self.env.log.debug(stmt)
cursor.execute(stmt)
for table, cols, vals in self.db_data:
cursor.executemany("INSERT INTO %s (%s) VALUES (%s)"
% (table, ','.join(cols),
','.join(['%s' for c in cols])), vals)
elif schema_ver < self.schema_version:
# Perform incremental upgrades.
for i in range(schema_ver + 1, self.schema_version + 1):
name = 'db%i' % i
try:
upgrades = __import__('tracvote.upgrades', globals(),
locals(), [name])
script = getattr(upgrades, name)
except AttributeError:
raise TracError("No upgrade module for version "
"%(num)i (%(version)s.py)",
num=i, version=name)
script.do_upgrade(self.env, i, cursor)
else:
# Obsolete call handled gracefully.
return
cursor.execute("""
UPDATE system
SET value=%s
WHERE name='vote_version'
""", (self.schema_version,))
self.log.info("Upgraded VotePlugin db schema from version %d to %d"
% (schema_ver, self.schema_version))
db.commit()
def run_upgrade_scripts(self, cursor, current_db_version):
dbm = DatabaseManager(self.env)
connector, args = dbm._get_connector()
upgrade_was_successful = True
expected_db_version = self.get_expected_db_version()
for i in xrange(current_db_version + 1, expected_db_version + 1):
name = 'db%i' % i
filename = '%s.py' % name
try:
pkg_name = self.get_package_name()
upgrades = __import__(pkg_name, globals(), locals(), [name])
script = getattr(upgrades, name)
except AttributeError:
msg = _('No upgrade module for version %(num)i (%(filename)s)')
raise TracError(msg, num=i, filename=filename)
upgrade_was_successful = script.do_upgrade(self.env, i, cursor, connector)
if not upgrade_was_successful:
msg = _('Upgrade script %s did not complete successfully')
self.env.log.error(msg % filename)
break
return upgrade_was_successful
def run_upgrade_scripts(self, cursor, current_db_version):
dbm = DatabaseManager(self.env)
connector, args = dbm._get_connector()
upgrade_was_successful = True
expected_db_version = self.get_expected_db_version()
for i in xrange(current_db_version + 1, expected_db_version + 1):
name = 'db%i' % i
filename = '%s.py' % name
try:
pkg_name = self.get_package_name()
upgrades = __import__(pkg_name, globals(), locals(), [name])
script = getattr(upgrades, name)
except AttributeError:
msg = _('No upgrade module for version %(num)i (%(filename)s)')
raise TracError(msg, num=i, filename=filename)
upgrade_was_successful = script.do_upgrade(self.env, i, cursor,
connector)
if not upgrade_was_successful:
msg = _('Upgrade script %s did not complete successfully')
self.env.log.error(msg % filename)
break
return upgrade_was_successful
