def __init__(self, file, repository, echoresults):
#for backward compatibelity
if re.match('^\w+://', file) == None:
file = 'sqlite:///'+file
self.version = 2
self.dbfile = file
self.repository = repository
#migrate code
try:
dbversion = api.db_version(file, self.repository)
#print dbversion
except :
dbversion = 0
api.version_control(file, self.repository, dbversion)
if dbversion < self.version:
api.upgrade(file, self.repository, self.version)
elif dbversion > self.version:
api.downgrade(file, self.repository, self.version)
engine = create_engine(file , echo=False)#edit by hassan : echoresults to True
metadata = Base.metadata
metadata.create_all(engine)
Session = sessionmaker(engine)
self.session = Session()
def execute(self, parsed_args):
url = cfg.CONF['backend:powerdns'].database_connection
if not os.path.exists(REPOSITORY):
raise Exception('Migration Repository Not Found')
try:
target_version = int(parsed_args.to_version) \
if parsed_args.to_version else None
current_version = versioning_api.db_version(url=url,
repository=REPOSITORY)
except DatabaseNotControlledError:
raise Exception('PowerDNS database not yet initialized')
LOG.info("Attempting to synchronize PowerDNS database from version "
"'%s' to '%s'",
current_version,
target_version if target_version is not None else "latest")
if target_version and target_version < current_version:
versioning_api.downgrade(url=url, repository=REPOSITORY,
version=parsed_args.to_version)
else:
versioning_api.upgrade(url=url, repository=REPOSITORY,
version=parsed_args.to_version)
LOG.info('PowerDNS database synchronized successfully')
def sync(self, version=None):
url = cfg.CONF['storage:sqlalchemy'].database_connection
if not os.path.exists(REPOSITORY):
raise Exception('Migration Repository Not Found')
try:
target_version = int(version) if version else None
current_version = versioning_api.db_version(url=url,
repository=REPOSITORY)
except DatabaseNotControlledError:
raise Exception('Database not yet initialized')
LOG.info("Attempting to synchronize database from version "
"'%s' to '%s'",
current_version,
target_version if target_version is not None else "latest")
if target_version and target_version < current_version:
versioning_api.downgrade(url=url, repository=REPOSITORY,
version=version)
else:
versioning_api.upgrade(url=url, repository=REPOSITORY,
version=version)
LOG.info('Database synchronized successfully')
def execute(self, parsed_args):
url = cfg.CONF['storage:sqlalchemy'].database_connection
if not os.path.exists(REPOSITORY):
raise Exception('Migration Respository Not Found')
try:
target_version = int(parsed_args.to_version) \
if parsed_args.to_version else None
current_version = versioning_api.db_version(url=url,
repository=REPOSITORY)
except DatabaseNotControlledError:
raise Exception('Database not yet initialized')
LOG.info("Attempting to synchronize database from version '%s' to '%s'"
% (current_version, target_version))
if target_version and target_version < current_version:
versioning_api.downgrade(url=url, repository=REPOSITORY,
version=parsed_args.to_version)
else:
versioning_api.upgrade(url=url, repository=REPOSITORY,
version=parsed_args.to_version)
LOG.info('Database synchronized sucessfully')
def downgrade_db(*opts):
'''
Downgrades the Database 1 rev.
'''
v = api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
api.downgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO, v - 1)
print 'Current database version: ' + str(api.db_version(SQLALCHEMY_DATABASE_URI,
SQLALCHEMY_MIGRATE_REPO))
def db_downgrade(version):
"""Downgrade the database"""
v1 = get_db_version()
migrate_api.downgrade(url=db_url, repository=db_repo, version=version)
v2 = get_db_version()
if v1 == v2:
print 'No changes made.'
else:
print 'Downgraded: %s ... %s' % (v1, v2)
def downgraddb():
v = api.db_version(Config.SQLALCHEMY_DATABASE_URI,
Config.SQLALCHEMY_MIGRATE_REPO)
api.downgrade(Config.SQLALCHEMY_DATABASE_URI,
Config.SQLALCHEMY_MIGRATE_REPO, v - 1)
v = api.db_version(Config.SQLALCHEMY_DATABASE_URI,
Config.SQLALCHEMY_MIGRATE_REPO)
print 'Current database version: ' + str(v)
def downgrade_db(v):
"""downgrade database schema to specified version"""
from_version = db_version(url=db, repository=repo)
to_version = int(v)
print("Downgrading db from version %d to %d. " % (from_version, to_version))
print("Schema upgrade ... ")
downgrade(url=db, repository=repo, version=v)
print("Data upgrade ... ")
datamigrations.run_downgrade_scripts(app, from_version, to_version)
print("Done!")
def _migrate_down(self, engine, version, with_data=False):
migration_api.downgrade(engine, TestMigrations.REPOSITORY, version)
self.assertEqual(version, migration_api.db_version(engine, TestMigrations.REPOSITORY))
# NOTE(sirp): `version` is what we're downgrading to (i.e. the 'target'
# version). So if we have any downgrade checks, they need to be run for
# the previous (higher numbered) migration.
if with_data:
post_downgrade = getattr(self, "_post_downgrade_%03d" % (version + 1), None)
if post_downgrade:
post_downgrade(engine)
def rollback(count):
if (rollbacks > v) or (rollbacks < 0):
print "Invalid rollbacks count. Current version is %d." % v
rollbacks = int(raw_input("Input valid count:"))
rollback(rollbacks)
else:
api.downgrade(SQLALCHEMY_DATABASE_URI,
SQLALCHEMY_MIGRATE_REPO,
v - count)
print ('Current database version: ' +
str(api.db_version(SQLALCHEMY_DATABASE_URI,
SQLALCHEMY_MIGRATE_REPO)))
def _downgradeDB(expectedVersion, dryrun):
if not dryrun:
api.downgrade(SQLALCHEMY_DATABASE_URI,
SQLALCHEMY_MIGRATE_REPO,
expectedVersion)
print 'Current database version: ' + \
str(api.db_version(SQLALCHEMY_DATABASE_URI,
SQLALCHEMY_MIGRATE_REPO))
if dryrun:
print 'Dryrun'
print '\tNew database version will be: ' + str(expectedVersion)
def db_downgrade(version=None):
# This is used to downgrade the database schema to a certain version or to one version before.
# If you know exactly the version you wish to use then you can directly downgrade to that version.
if not version:
current_version = api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
downgrade_version = current_version - 1
else:
downgrade_version = version
api.downgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO, downgrade_version)
print 'Database downgrade completed!'
print 'Current database version: ' + str(api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO))
def downgrade(args):
"""
Restores the database one previous version, run multiple times to go
back multiple versions if needed.
"""
# Get the configruation
config = get_config()
DB_URI = config.DATABASE_URI
M_REPO = config.MIGRATIONS
v = api.db_version(DB_URI, M_REPO)
api.downgrade(DB_URI, M_REPO, v - 1)
v = api.db_version(DB_URI, M_REPO)
return "Current database version: %i" % v
def db_sync(engine, abs_path, version=None, init_version=0, sanity_check=True):
"""Upgrade or downgrade a database.
Function runs the upgrade() or downgrade() functions in change scripts.
:param engine: SQLAlchemy engine instance for a given database
:param abs_path: Absolute path to migrate repository.
:param version: Database will upgrade/downgrade until this version.
If None - database will update to the latest
available version.
:param init_version: Initial database version
:param sanity_check: Require schema sanity checking for all tables
"""
if version is not None:
try:
version = int(version)
except ValueError:
raise exception.DbMigrationError(
message=_("version should be an integer"))
current_version = db_version(engine, abs_path, init_version)
repository = _find_migrate_repo(abs_path)
if sanity_check:
_db_schema_sanity_check(engine)
if version is None or version > current_version:
return versioning_api.upgrade(engine, repository, version)
else:
return versioning_api.downgrade(engine, repository,
version)
def db_sync(engine, version=None, init_version=INIT_VERSION):
"""Upgrade or downgrade a database.
Function runs the upgrade() or downgrade() functions in change scripts.
:param engine: SQLAlchemy engine instance for a given database
:param version: Database will upgrade/downgrade until this version.
If None - database will update to the latest
available version.
:param init_version: Initial database version
"""
if version is not None:
try:
version = int(version)
except ValueError:
raise exception.DbMigrationError(
message='version should be an integer')
current_version = db_version(engine, init_version)
repository = _find_migrate_repo()
if version is None or version > current_version:
return versioning_api.upgrade(engine, repository, version)
else:
return versioning_api.downgrade(engine, repository, version)
def db_sync(abs_path, version=None, init_version=0):
"""Upgrade or downgrade a database.
Function runs the upgrade() or downgrade() functions in change scripts.
:param abs_path: Absolute path to migrate repository.
:param version: Database will upgrade/downgrade until this version.
If None - database will update to the latest
available version.
:param init_version: Initial database version
"""
if version is not None:
try:
version = int(version)
except ValueError:
raise exception.DbMigrationError(
message=_("version should be an integer"))
current_version = db_version(abs_path, init_version)
repository = _find_migrate_repo(abs_path)
if version is None or version > current_version:
return versioning_api.upgrade(get_engine(), repository, version)
else:
return versioning_api.downgrade(get_engine(), repository,
version)
def downgrade(version):
"""Downgrade the database's current migration level."""
db_version() # Ensure db is under migration control
repo_path = get_migrate_repo_path()
sql_connection = CFG.db.sql_connection
logger.info("Downgrading %(sql_connection)s to version %(version)s" %
locals())
return versioning_api.downgrade(sql_connection, repo_path, version)
def downgradedb():
""" Downgrades the database from the current to the previous
version contained in the SQLAlchemy-migrate repository.
"""
# Obtain Current Version
ver = api.db_version(app.config['SQLALCHEMY_DATABASE_URI'],
app.config['SQLALCHEMY_MIGRATE_REPO'])
# Downgrade Database To Previous Revision
api.downgrade(app.config['SQLALCHEMY_DATABASE_URI'],
app.config['SQLALCHEMY_MIGRATE_REPO'], ver-1)
# Obtain & Display Current Version
ver = api.db_version(app.config['SQLALCHEMY_DATABASE_URI'],
app.config['SQLALCHEMY_MIGRATE_REPO'])
print("Current database version: " + str(ver))
def migrate_repository(version, current_version, repo_path):
if version is None or version > current_version:
result = versioning_api.upgrade(CONF.sql.connection,
repo_path, version)
else:
result = versioning_api.downgrade(
CONF.sql.connection, repo_path, version)
return result
def do_db(self, line=''):
args = line.split()
action = args[0]
if not action in self.db_actions:
self.help_db()
return 1
self._register_config()
import shakespeare.model as model
import shakespeare
migrate_repository = 'shakespeare/migration/'
if action == 'create':
model.repo.create_db()
elif action == 'clean':
model.repo.clean_db()
elif action == 'rebuild':
model.repo.rebuild_db()
elif action == 'upgrade':
version = None
if len(args) > 1:
version = args[1]
import migrate.versioning.exceptions
import migrate.versioning.api
import migrate.versioning.api as mig
try:
mig.version_control(model.meta.engine.url, migrate_repository)
except migrate.versioning.exceptions.DatabaseAlreadyControlledError:
pass
mig.upgrade(model.meta.engine.url, migrate_repository,
version=version)
elif action == 'downgrade':
if len(args) < 2:
print 'You need to supply a version to downgrade to'
return 1
version = args[1]
import migrate.versioning.api
import migrate.versioning.api as mig
mig.downgrade(model.meta.engine.url, migrate_repository,
version=version)
elif action.startswith('init_'):
modname = action.strip()[5:]
mod = __import__(modname+'.cli', fromlist='cli')
mod.LoadTexts.load_texts()
else:
print self.help_db()
def downgrade(version):
"""
Downgrade the database's current migration level
:param version: version to downgrade to
:retval version number
"""
db_version() # Ensure db is under migration control
repository = _get_migrate_repo()
LOG.info(_("Downgrading database to version %s") % version)
return versioning_api.downgrade(get_engine(), repository, version)
def downgrade(version):
"""
Downgrade the database's current migration level
:param version: version to downgrade to
:retval version number
"""
db_version() # Ensure db is under migration control
repo_path = get_migrate_repo_path()
sql_connection = CONF.sql_connection
LOG.info(_("Downgrading database to version %s") % version)
return versioning_api.downgrade(sql_connection, repo_path, version)
def downgrade(options, version):
"""
Downgrade the database's current migration level
:param options: options dict
:param version: version to downgrade to
:retval version number
"""
db_version(options) # Ensure db is under migration control
repo_path = get_migrate_repo_path()
sql_connection = options["sql_connection"]
logger.info(_("Downgrading %(sql_connection)s to version %(version)s") % locals())
return versioning_api.downgrade(sql_connection, repo_path, version)
def downgrade(sql_connection, version):
"""
Downgrade the database's current migration level
:param sql_connection: sqlalchemy connection string
:param version: version to downgrade to
:retval version number
"""
db_version(sql_connection) # Ensure db is under migration control
repo_path = get_migrate_repo_path()
logger.info(_("Downgrading %(sql_connection)s to version %(version)s") %
locals())
return versioning_api.downgrade(sql_connection, repo_path, version)
def db_sync(version=None):
if version is not None:
try:
version = int(version)
except ValueError:
raise exception.Error(_("version should be an integer"))
current_version = db_version()
repository = _find_migrate_repo()
if version is None or version > current_version:
return versioning_api.upgrade(get_engine(), repository, version)
else:
return versioning_api.downgrade(get_engine(), repository,
version)
def downgrade(options, version, repo_path=None):
"""Downgrade the database's current migration level.
:param options: options dict
:param version: version to downgrade to
:retval version number
"""
db_version(options, repo_path) # Ensure db is under migration control
repo_path = get_migrate_repo_path(repo_path)
sql_connection = options['database']['connection']
logger.info("Downgrading %(sql_connection)s to version %(version)s" %
{'sql_connection': sql_connection, 'version': version})
return versioning_api.downgrade(sql_connection, repo_path, version)
def db_sync(version=None):
if version is not None:
try:
version = int(version)
except ValueError:
raise Exception('version should be an integer')
current_version = db_version()
repo_path = _find_migrate_repo()
if version is None or version > current_version:
return versioning_api.upgrade(CONF.sql.connection, repo_path, version)
else:
return versioning_api.downgrade(
CONF.sql.connection, repo_path, version)
def db_sync(version=None):
if version is not None:
try:
version = int(version)
except ValueError:
raise Exception("version should be an integer")
current_version = db_version()
repo_path = _find_migrate_repo()
if version is None or version > current_version:
return versioning_api.upgrade(
CONF.sql.connection, repo_path, version)
else:
return versioning_api.downgrade(
CONF.sql.connection, repo_path, version)
def db_sync(version=None):
if version is not None:
try:
version = int(version)
except ValueError:
raise exception.Error(_("version should be an integer"))
current_version = db_version()
repo_path = _find_migrate_repo()
if version is None or version > current_version:
versioning_api.upgrade(FLAGS.sql_connection, repo_path, version)
return fix_dns_domains.run(get_engine())
else:
return versioning_api.downgrade(FLAGS.sql_connection, repo_path,
version)
def _walk_versions(self, engine=None, snake_walk=False):
# Determine latest version script from the repo, then
# upgrade from 1 through to the latest, with no data
# in the databases. This just checks that the schema itself
# upgrades successfully.
# Place the database under version control
migration_api.version_control(engine, TestMigrations.REPOSITORY)
self.assertEqual(0,
migration_api.db_version(engine,
TestMigrations.REPOSITORY))
LOG.debug('latest version is %s' % TestMigrations.REPOSITORY.latest)
for version in xrange(1, TestMigrations.REPOSITORY.latest + 1):
# upgrade -> downgrade -> upgrade
migration_api.upgrade(engine, TestMigrations.REPOSITORY, version)
self.assertEqual(version,
migration_api.db_version(engine,
TestMigrations.REPOSITORY))
if snake_walk:
migration_api.downgrade(engine,
TestMigrations.REPOSITORY,
version - 1)
self.assertEqual(version - 1,
migration_api.db_version(engine,
TestMigrations.REPOSITORY))
migration_api.upgrade(engine,
TestMigrations.REPOSITORY,
version)
self.assertEqual(version,
migration_api.db_version(engine,
TestMigrations.REPOSITORY))
# Now walk it back down to 0 from the latest, testing
# the downgrade paths.
for version in reversed(
xrange(0, TestMigrations.REPOSITORY.latest)):
# downgrade -> upgrade -> downgrade
migration_api.downgrade(engine, TestMigrations.REPOSITORY, version)
self.assertEqual(version,
migration_api.db_version(engine,
TestMigrations.REPOSITORY))
if snake_walk:
migration_api.upgrade(engine,
TestMigrations.REPOSITORY,
version + 1)
self.assertEqual(version + 1,
migration_api.db_version(engine,
TestMigrations.REPOSITORY))
migration_api.downgrade(engine,
TestMigrations.REPOSITORY,
version)
self.assertEqual(version,
migration_api.db_version(engine,
TestMigrations.REPOSITORY))
def _walk_versions(self, engine=None, snake_walk=False):
# Determine latest version script from the repo, then
# upgrade from 1 through to the latest, with no data
# in the databases. This just checks that the schema itself
# upgrades successfully.
# Place the database under version control
migration_api.version_control(engine, TestMigrations.REPOSITORY)
self.assertEqual(0,
migration_api.db_version(engine,
TestMigrations.REPOSITORY))
LOG.debug('latest version is %s' % TestMigrations.REPOSITORY.latest)
for version in xrange(1, TestMigrations.REPOSITORY.latest + 1):
# upgrade -> downgrade -> upgrade
migration_api.upgrade(engine, TestMigrations.REPOSITORY, version)
self.assertEqual(version,
migration_api.db_version(engine,
TestMigrations.REPOSITORY))
if snake_walk:
migration_api.downgrade(engine,
TestMigrations.REPOSITORY,
version - 1)
self.assertEqual(version - 1,
migration_api.db_version(engine,
TestMigrations.REPOSITORY))
migration_api.upgrade(engine,
TestMigrations.REPOSITORY,
version)
self.assertEqual(version,
migration_api.db_version(engine,
TestMigrations.REPOSITORY))
# Now walk it back down to 0 from the latest, testing
# the downgrade paths.
for version in reversed(
xrange(0, TestMigrations.REPOSITORY.latest)):
# downgrade -> upgrade -> downgrade
migration_api.downgrade(engine, TestMigrations.REPOSITORY, version)
self.assertEqual(version,
migration_api.db_version(engine,
TestMigrations.REPOSITORY))
if snake_walk:
migration_api.upgrade(engine,
TestMigrations.REPOSITORY,
version + 1)
self.assertEqual(version + 1,
migration_api.db_version(engine,
TestMigrations.REPOSITORY))
migration_api.downgrade(engine,
TestMigrations.REPOSITORY,
version)
self.assertEqual(version,
migration_api.db_version(engine,
TestMigrations.REPOSITORY))
def db_sync(version=None, database='main', context=None):
if version is not None:
try:
version = int(version)
except ValueError:
raise exception.NovaException(_("version should be an integer"))
current_version = db_version(database, context=context)
repository = _find_migrate_repo(database)
if version is None or version > current_version:
return versioning_api.upgrade(get_engine(database, context=context),
repository, version)
else:
return versioning_api.downgrade(get_engine(database, context=context),
repository, version)
def test_workflow(self):
self.assertEqual(api.db_version(self.url, self.repo), 0)
api.script('First Version', self.repo)
self.assertEqual(api.db_version(self.url, self.repo), 0)
api.upgrade(self.url, self.repo, 1)
self.assertEqual(api.db_version(self.url, self.repo), 1)
api.downgrade(self.url, self.repo, 0)
self.assertEqual(api.db_version(self.url, self.repo), 0)
api.test(self.url, self.repo)
self.assertEqual(api.db_version(self.url, self.repo), 0)
# preview
# TODO: test output
out = api.upgrade(self.url, self.repo, preview_py=True)
out = api.upgrade(self.url, self.repo, preview_sql=True)
api.upgrade(self.url, self.repo, 1)
api.script_sql('default', 'desc', self.repo)
self.assertRaises(UsageError, api.upgrade, self.url, self.repo, 2, preview_py=True)
out = api.upgrade(self.url, self.repo, 2, preview_sql=True)
# cant upgrade to version 1, already at version 1
self.assertEqual(api.db_version(self.url, self.repo), 1)
self.assertRaises(KnownError, api.upgrade, self.url, self.repo, 0)
def db_sync(version=None, database='main', context=None):
if version is not None:
try:
version = int(version)
except ValueError:
raise exception.NovaException(_("version should be an integer"))
current_version = db_version(database, context=context)
repository = _find_migrate_repo(database)
if version is None or version > current_version:
return versioning_api.upgrade(get_engine(database, context=context),
repository, version)
else:
return versioning_api.downgrade(get_engine(database, context=context),
repository, version)
def db_sync(version=None):
if version is not None:
try:
version = int(version)
except ValueError:
raise exception.NovaException(_("version should be an integer"))
current_version = db_version()
repository = _find_migrate_repo()
if version is None or version > current_version:
return versioning_api.upgrade(session.get_engine(), repository,
version)
else:
return versioning_api.downgrade(session.get_engine(), repository,
version)
def test_workflow(self):
self.assertEqual(api.db_version(self.url, self.repo), 0)
api.script('First Version', self.repo)
self.assertEqual(api.db_version(self.url, self.repo), 0)
api.upgrade(self.url, self.repo, 1)
self.assertEqual(api.db_version(self.url, self.repo), 1)
api.downgrade(self.url, self.repo, 0)
self.assertEqual(api.db_version(self.url, self.repo), 0)
api.test(self.url, self.repo)
self.assertEqual(api.db_version(self.url, self.repo), 0)
# preview
# TODO: test output
out = api.upgrade(self.url, self.repo, preview_py=True)
out = api.upgrade(self.url, self.repo, preview_sql=True)
api.upgrade(self.url, self.repo, 1)
api.script_sql('default', self.repo)
self.assertRaises(UsageError, api.upgrade, self.url, self.repo, 2, preview_py=True)
out = api.upgrade(self.url, self.repo, 2, preview_sql=True)
# cant upgrade to version 1, already at version 1
self.assertEqual(api.db_version(self.url, self.repo), 1)
self.assertRaises(KnownError, api.upgrade, self.url, self.repo, 0)
def downgrade(options, version, repo_path=None):
"""Downgrade the database's current migration level.
:param options: options dict
:param version: version to downgrade to
:retval version number
"""
db_version(options, repo_path) # Ensure db is under migration control
repo_path = get_migrate_repo_path(repo_path)
sql_connection = options['database']['connection']
logger.info("Downgrading %(sql_connection)s to version %(version)s" % {
'sql_connection': sql_connection,
'version': version
})
return versioning_api.downgrade(sql_connection, repo_path, version)
def db_sync(version=None):
if version is not None:
try:
version = int(version)
except ValueError:
raise exception.Error(_("version should be an integer"))
current_version = db_version()
repository = _find_migrate_repo()
migrate_engine = get_engine()
if version is None or version > current_version:
result = versioning_api.upgrade(migrate_engine, repository, version)
else:
result = versioning_api.downgrade(migrate_engine, repository, version)
_ensure_reservations_index(migrate_engine)
return result
def db_sync(engine, abs_path, version=None, init_version=0):
"""
Upgrade or downgrade a database.
"""
if version is not None:
try:
version = int(version)
except ValueError:
raise exception.DbMigrationError(
message=_("version should be an integer"))
current_version = db_version(engine, abs_path, init_version)
repository = _find_migrate_repo(abs_path)
_db_schema_sanity_check(engine)
if version is None or version > current_version:
return versioning_api.upgrade(engine, repository, version)
else:
return versioning_api.downgrade(engine, repository,
version)
def db_sync(version=None, database='main'):
if version is not None:
try:
version = int(version)
except ValueError:
raise exception.NovaException(_("version should be an integer"))
current_version = db_version(database)
repository = _find_migrate_repo(database)
if _db_sync_locked(repository):
msg = _("Cannot run 'db sync' until 'db contract' is run")
raise exception.DatabaseMigrationError(reason=msg)
if version is None or version > current_version:
return versioning_api.upgrade(get_engine(database), repository,
version)
else:
return versioning_api.downgrade(get_engine(database), repository,
version)
def db_sync(engine, abs_path, version=None, init_version=0, sanity_check=True):
"""Upgrade or downgrade a database.
Function runs the upgrade() or downgrade() functions in change scripts.
:param engine: SQLAlchemy engine instance for a given database
:param abs_path: Absolute path to migrate repository.
:param version: Database will upgrade/downgrade until this version.
If None - database will update to the latest
available version.
:param init_version: Initial database version
:param sanity_check: Require schema sanity checking for all tables
"""
if version is not None:
try:
version = int(version)
except ValueError:
raise exception.DBMigrationError(_("version should be an integer"))
current_version = db_version(engine, abs_path, init_version)
repository = _find_migrate_repo(abs_path)
if sanity_check:
_db_schema_sanity_check(engine)
if version is None or version > current_version:
try:
migration = versioning_api.upgrade(engine, repository, version)
except Exception as ex:
raise exception.DBMigrationError(ex)
else:
migration = versioning_api.downgrade(engine, repository,
version)
if sanity_check:
_db_schema_sanity_check(engine)
return migration
def db_sync(abs_path, version=None, init_version=0):
"""Upgrade or downgrade a database.
Function runs the upgrade() or downgrade() functions in change scripts.
:param abs_path: Absolute path to migrate repository.
:param version: Database will upgrade/downgrade until this version.
If None - database will update to the latest
available version.
:param init_version: Initial database version
"""
if version is not None:
try:
version = int(version)
except ValueError:
raise exception.DbMigrationError(
message=_("version should be an integer"))
current_version = db_version(abs_path, init_version)
repository = _find_migrate_repo(abs_path)
if version is None or version > current_version:
return versioning_api.upgrade(get_engine(), repository, version)
else:
return versioning_api.downgrade(get_engine(), repository, version)
./db_downgrade.py -1
To roll back to version 5:
./db_downgrade 5
"""
import sys
from migrate.versioning import api
from config import SQLALCHEMY_DATABASE_URI as URI
from config import SQLALCHEMY_MIGRATE_REPO as REPO
if __name__ == '__main__':
v1 = api.db_version(URI, REPO)
try:
target_version = sys.argv[1]
if target_version.startswith('-'):
target_version = v1 - 1
except IndexError:
target_version = v1 - 1
print("Attempting to downgrade from %s to %s" %
(str(v1), str(target_version)))
api.downgrade(URI, REPO, target_version)
v2 = api.db_version(URI, REPO)
print("Downgraded DB from %s to %s" % (str(v1), str(v2)))
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# @Time : 2019/4/8 16:05
# @Author : Jianfeng Ding
# @Site :
# @File : db_downgrade.py
# @Software: PyCharm
from migrate.versioning import api
from config import Config
v = api.db_version(Config.SQLALCHEMY_DATABASE_URI,
Config.SQLALCHEMY_MIGRATE_JEFF)
api.downgrade(Config.SQLALCHEMY_DATABASE_URI, Config.SQLALCHEMY_MIGRATE_JEFF,
v - 1)
v = api.db_version(Config.SQLALCHEMY_DATABASE_URI,
Config.SQLALCHEMY_MIGRATE_JEFF)
print('Current database version: ' + str(v))
#!/usr/bin/env python
# coding: utf-8
#**********************************
# author: h3idan
# datetime: 2013-07-19 17:12
#**********************************
'''
回滚数据库，每次向前回滚一个版本
'''
import sys
sys.path.append('../')
from migrate.versioning import api
from app.models import app
v = api.db_version(app.config['SQLALCHEMY_DATABASE_URI'],\
app.config['SQLALCHEMY_MIGRATE_REPO'])
if v == 1:
print 'Current database version %d , only version 2 can downgrade' % v
else:
api.downgrade(app.config['SQLALCHEMY_DATABASE_URI'], \
app.config.get('SQLALCHEMY_MIGRATE_REPO'), v - 1)
print 'Current database version: ' + str(api.db_version(app.config\
['SQLALCHEMY_DATABASE_URI'], app.config['SQLALCHEMY_MIGRATE_REPO']))
from migrate.versioning import api
from config import SQLALCHEMY_DATABASE_URI as SDU
from config import SQLALCHEMY_MIGRATE_REPO as SMR
v = api.db_version(SDU, SMR)
api.downgrade(SDU, SMR, v - 1)
v = api.db_version(SDU, SMR)
print('Current database version: {}'.format(v))
#!/usr/bin/env python
from app import app
from migrate.versioning import api
SQLALCHEMY_DATABASE_URI = app.config['SQLALCHEMY_DATABASE_URI']
SQLALCHEMY_MIGRATE_REPO = app.config['SQLALCHEMY_MIGRATE_REPO']
v = api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
api.downgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO, v - 1)
v = api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
print('Current database version: ' + str(v))
#!flask/bin/python
from migrate.versioning import api
import config
v = api.db_version(
config.SQLALCHEMY_DATABASE_URI,
config.SQLALCHEMY_MIGRATE_REPO)
api.downgrade(
config.SQLALCHEMY_DATABASE_URI,
config.SQLALCHEMY_MIGRATE_REPO,
v - 1)
print("Current database version: %s" % (api.db_version(
config.SQLALCHEMY_DATABASE_URI,
config.SQLALCHEMY_MIGRATE_REPO)))
def DowngradeDB():
v = api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
api.downgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO, v - 1)
print 'Current database version: ' + str(api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO))
#!flask/bin/python
from migrate.versioning import api
from config import SQLALCHEMY_DATABASE_URI as URI
from config import SQLALCHEMY_MIGRATE_REPO as REPO
v=api.db_version(URI,REPO)
api.downgrade(URI,REPO,v-1)
v=api.db_version(URI,REPO)
print('Current database version: '+str(v))
def _migrate_down(self, engine, version):
"""Migrate down to an old version of database."""
migration_api.downgrade(engine, self.REPOSITORY, version)
assert_equal(version, migration_api.db_version(engine,
self.REPOSITORY))
def downgrade_database():
v = api.db_version(c.SQLALCHEMY_DATABASE_URI, c.SQLALCHEMY_MIGRATE_REPO)
api.downgrade(c.SQLALCHEMY_DATABASE_URI, c.SQLALCHEMY_MIGRATE_REPO, v - 1)
print 'Current database version: ' + str(api.db_version(c.SQLALCHEMY_DATABASE_URI, c.SQLALCHEMY_MIGRATE_REPO))
# -*- coding: utf-8 -*- # @Author: Dang Kai # @Email : [email protected] # @Date: 2019-04-29 09:28:15 # @Last Modified time: 2019-04-29 09:28:15 #回滚数据库 from migrate.versioning import api from Api_Manager.config.setting import Config, TestingConfig v = api.db_version(TestingConfig.SQLALCHEMY_DATABASE_URI, Config.SQLALCHEMY_MIGRATE_REPO) api.downgrade(TestingConfig.SQLALCHEMY_DATABASE_URI, Config.SQLALCHEMY_MIGRATE_REPO, v - 1) print('Current database version: ' + str( api.db_version(TestingConfig.SQLALCHEMY_DATABASE_URI, Config.SQLALCHEMY_MIGRATE_REPO)))
#!flask/bin/python from migrate.versioning import api from settings import settings mrepo = settings.sqlalchemy_migrations_repo db_url = settings.database.url v = api.db_version(db_url, mrepo) api.downgrade(db_url, mrepo, v - 1) print 'Current database version: ' + str(api.db_version(db_url, mrepo))
def _migrate_down(self, engine, version):
versioning_api.downgrade(engine, repository=self.REPOSITORY,
version=version)
#!/home/gianluca/.virtualenvs/microblog/bin/python3
from migrate.versioning import api
from config import SQLALCHEMY_DATABASE_URI
from config import SQLALCHEMY_MIGRATE_REPO
version = api.db_version(url=SQLALCHEMY_DATABASE_URI,
repository=SQLALCHEMY_MIGRATE_REPO)
api.downgrade(url=SQLALCHEMY_DATABASE_URI,
repository=SQLALCHEMY_MIGRATE_REPO,
version=version - 1)
version = api.db_version(url=SQLALCHEMY_DATABASE_URI,
repository=SQLALCHEMY_MIGRATE_REPO)
print('Current database version: {}'.format(str(version)))
def tearDown(self):
db.downgrade(os.environ['DATABASE_URL'], 'migrations', 0)
#!/usr/bin/env python2
from migrate.versioning import api
from flask_app import config
v = api.db_version(config['SQLALCHEMY_DATABASE_URI'],
config['SQLALCHEMY_MIGRATE_REPO'])
api.downgrade(config['SQLALCHEMY_DATABASE_URI'],
config['SQLALCHEMY_MIGRATE_REPO'], v - 1)
print 'Current database version: ' + str(
api.db_version(config['SQLALCHEMY_DATABASE_URI'],
config['SQLALCHEMY_MIGRATE_REPO']))
def downgrade_db():
v = api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
api.downgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO, v - 1)
v = api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
print('Current database version: ' + str(v))
#!flask/bin/python
from migrate.versioning import api
from config import Config
v = api.db_version(Config.SQLALCHEMY_DATABASE_URI, Config.SQLALCHEMY_DATABASE_URI)
api.downgrade(Config.SQLALCHEMY_DATABASE_URI,Config.SQLALCHEMY_DATABASE_URI, v - 1)
print ('Current database version: ' + str(api.db_version(Config.SQLALCHEMY_DATABASE_URI, Config.SQLALCHEMY_DATABASE_URI)))