Python api.db_version方法代码示例

# 需要导入模块: from migrate.versioning import api [as 别名]
# 或者: from migrate.versioning.api import db_version [as 别名]
def db_version():
    repository = _find_migrate_repo()
    try:
        return versioning_api.db_version(get_engine(), repository)
    except versioning_exceptions.DatabaseNotControlledError:
        meta = sqlalchemy.MetaData()
        engine = get_engine()
        meta.reflect(bind=engine)
        tables = meta.tables
        if len(tables) == 0:
            db_version_control(INIT_VERSION)
            return versioning_api.db_version(get_engine(), repository)
        else:
            # Some pre-Essex DB's may not be version controlled.
            # Require them to upgrade using Essex first.
            raise exception.EC2Exception(
                _("Upgrade DB using Essex release first.")) 

# 需要导入模块: from migrate.versioning import api [as 别名]
# 或者: from migrate.versioning.api import db_version [as 别名]
def upgrade_db(self, version=None):
        '''Upgrade db using sqlalchemy migrations.

        @param version: version to upgrade to (if None upgrade to latest)
        '''
        assert meta.engine.name in ('postgres', 'postgresql'), \
            'Database migration - only Postgresql engine supported (not %s).' \
                % meta.engine.name
        import migrate.versioning.api as mig
        self.setup_migration_version_control()
        version_before = mig.db_version(self.metadata.bind, self.migrate_repository)
        mig.upgrade(self.metadata.bind, self.migrate_repository, version=version)
        version_after = mig.db_version(self.metadata.bind, self.migrate_repository)
        if version_after != version_before:
            log.info('CKAN database version upgraded: %s -> %s', version_before, version_after)
        else:
            log.info('CKAN database version remains as: %s', version_after)

        ##this prints the diffs in a readable format
        ##import pprint
        ##from migrate.versioning.schemadiff import getDiffOfModelAgainstDatabase
        ##pprint.pprint(getDiffOfModelAgainstDatabase(self.metadata, self.metadata.bind).colDiffs) 

# 需要导入模块: from migrate.versioning import api [as 别名]
# 或者: from migrate.versioning.api import db_version [as 别名]
def db_version(engine, abs_path, init_version):
    """Show the current version of the repository.

    :param engine:  SQLAlchemy engine instance for a given database
    :param abs_path: Absolute path to migrate repository
    :param init_version:  Initial database version
    """
    repository = _find_migrate_repo(abs_path)
    try:
        return versioning_api.db_version(engine, repository)
    except versioning_exceptions.DatabaseNotControlledError:
        meta = sqlalchemy.MetaData()
        meta.reflect(bind=engine)
        tables = meta.tables
        if (len(tables) == 0 or 'alembic_version' in tables or
                'migrate_version' in tables):
            db_version_control(engine, abs_path, version=init_version)
            return versioning_api.db_version(engine, repository)
        else:
            raise exception.DBMigrationError(
                _("The database is not under version control, but has "
                  "tables. Please stamp the current version of the schema "
                  "manually.")) 

# 需要导入模块: from migrate.versioning import api [as 别名]
# 或者: from migrate.versioning.api import db_version [as 别名]
def db_sync(version=None):
    if version is not None:
        try:
            version = int(version)
        except ValueError:
            raise exception.EC2Exception(_("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) 

# 需要导入模块: from migrate.versioning import api [as 别名]
# 或者: from migrate.versioning.api import db_version [as 别名]
def __init__(self, file, repository, echoresults):

        # for backward compatibelity
        if re.match('^\w+://', file) == None:
            file = 'sqlite:///'+file

        self.version = 3
        self.dbfile = file
        self.repository = repository

        # migrate code
        try:
            dbversion = api.db_version(file, self.repository)
            logging.debug('Current DB version: "%d"' % dbversion)
        except:  # if no previous database found => first installing
            dbversion = 0
            api.version_control(file, self.repository, dbversion)

        versioningDone = False

        if dbversion < self.version:
            api.upgrade(file, self.repository, self.version)
            versioningDone = True
        elif dbversion > self.version:
            api.downgrade(file, self.repository, self.version)
            versioningDone = True

        # edit by hassan : echoresults to True
        engine = create_engine(file, echo=echoresults)
        self.engine = engine

        metadata = Base.metadata
        metadata.create_all(engine)

        Session = sessionmaker(engine)
        self.session = Session()
        if versioningDone:
            self.rebuild_nested_set(0, 0) 

# 需要导入模块: from migrate.versioning import api [as 别名]
# 或者: from migrate.versioning.api import db_version [as 别名]
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