Example #1
0
def migratedb():
    """ Updates the database and SQLAlchemy-migrate repository
        to a new version containing all of the tables defined
        in the SQLAlchemy data models.
    """

    # Obtain Current Verison
    ver = api.db_version(app.config['SQLALCHEMY_DATABASE_URI'],
                         app.config['SQLALCHEMY_MIGRATE_REPO'])

    # Create Migration Script To Apply Model Changes
    mgr = app.config['SQLALCHEMY_MIGRATE_REPO'] +\
        ('/versions/%03d_migration.py' % (ver+1))
    tmp_module = imp.new_module('old_model')
    old_model = api.create_model(app.config['SQLALCHEMY_DATABASE_URI'],
                                 app.config['SQLALCHEMY_MIGRATE_REPO'])
    exec(old_model, tmp_module.__dict__)
    script = api.make_update_script_for_model(
        app.config['SQLALCHEMY_DATABASE_URI'],
        app.config['SQLALCHEMY_MIGRATE_REPO'],
        tmp_module.meta, db.metadata)
    open(mgr, "wt").write(script)

    # Update Database With Migration Script
    api.upgrade(app.config['SQLALCHEMY_DATABASE_URI'],
                app.config['SQLALCHEMY_MIGRATE_REPO'])

    # Obtain & Display Current Version & Migration
    ver = api.db_version(app.config['SQLALCHEMY_DATABASE_URI'],
                         app.config['SQLALCHEMY_MIGRATE_REPO'])
    print('New migration saved as: ' + mgr)
    print('Current databse version: ' + str(ver))
Example #2
0
def migrate(args):
    """
    Create DB migrations for current version
    """

    # Get the configruation
    config = get_config()
    DB_URI = config.DATABASE_URI
    M_REPO = config.MIGRATIONS

    v = api.db_version(DB_URI, M_REPO)
    m = os.path.join(M_REPO, 'versions', '%03d_migration.py' % (v + 1))

    tmpmod = imp.new_module('old_model')
    oldmod = api.create_model(DB_URI, M_REPO)
    exec(oldmod, tmpmod.__dict__)

    script = api.make_update_script_for_model(
        DB_URI, M_REPO, tmpmod.meta, elmr.db.metadata
    )

    with open(m, 'wt') as f:
        f.write(script)

    v = api.db_version(DB_URI, M_REPO)

    return "New migration saved as %s\nCurrent database version: %d" % (m, v)
Example #3
0
def _generateMigrationScript(dryrun):
    newVersion = findMaxAvailableVersion() + 1
    migration = SQLALCHEMY_MIGRATE_REPO + \
                '/versions/%03d_migration.py' % (newVersion)
    tmp_module = imp.new_module('old_model')
    old_model = api.create_model(SQLALCHEMY_DATABASE_URI,
                                 SQLALCHEMY_MIGRATE_REPO)

    exec old_model in tmp_module.__dict__
    script = api.make_update_script_for_model(SQLALCHEMY_DATABASE_URI,
                                              SQLALCHEMY_MIGRATE_REPO,
                                              tmp_module.meta,
                                              db.metadata)
    if not dryrun:
        open(migration, "wt").write(script)
        api.upgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
        print 'New migration saved as ' + migration
        print 'Current database version: ' + \
              str(api.db_version(SQLALCHEMY_DATABASE_URI,
                                 SQLALCHEMY_MIGRATE_REPO))
    else:
        print 'Dryrun:'
        print '\nNew migration will be as ' + migration
        print '\nNew migration script will be:\n"\n%s"' % str(script)
        print '\nNew database version will be: ' + str(newVersion)
Example #4
0
 def __init__(self,database):
     migration=SQLALCHEMY_MIGRATE_CONT+"/versions/%03d_migration.py" % (api.db_version(SQLALCHEMY_DATABASE_URI,SQLALCHEMY_MIGRATE_CONT)+1)
     tmp_module=imp.new_module("old_model")
     old_model=api.create_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_CONT)
     exec old_model in tmp_module.__dict__
     script=api.make_update_script_for_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_CONT, tmp_module.meta, database.metadata)
     open(migration,"wt").write(script)
     a=api.upgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_CONT)
Example #5
0
def migrate_database():
    migration = c.SQLALCHEMY_MIGRATE_REPO + '/versions/%03d_migration.py' % (api.db_version(c.SQLALCHEMY_DATABASE_URI, c.SQLALCHEMY_MIGRATE_REPO) + 1)
    tmp_module = imp.new_module('old_model')
    old_model = api.create_model(c.SQLALCHEMY_DATABASE_URI, c.SQLALCHEMY_MIGRATE_REPO)
    exec old_model in tmp_module.__dict__
    script = api.make_update_script_for_model(c.SQLALCHEMY_DATABASE_URI, c.SQLALCHEMY_MIGRATE_REPO, tmp_module.meta, db.metadata)
    open(migration, "wt").write(script)
    api.upgrade(c.SQLALCHEMY_DATABASE_URI, c.SQLALCHEMY_MIGRATE_REPO)
    print 'New migration saved as ' + migration
    print 'Current database version: ' + str(api.db_version(c.SQLALCHEMY_DATABASE_URI, c.SQLALCHEMY_MIGRATE_REPO))
Example #6
0
def migratedb():
    """Creates a migration file and version."""
    migration = app.config.get('SQLALCHEMY_MIGRATE_REPO') + '/versions/%03d_migration.py' % (api.db_version(app.config.get('SQLALCHEMY_DATABASE_URI'), app.config.get('SQLALCHEMY_MIGRATE_REPO')) + 1)
    tmp_module = imp.new_module('old_model')
    old_model = api.create_model(app.config.get('SQLALCHEMY_DATABASE_URI'), app.config.get('SQLALCHEMY_MIGRATE_REPO'))
    exec old_model in tmp_module.__dict__
    script = api.make_update_script_for_model(app.config.get('SQLALCHEMY_DATABASE_URI'), app.config.get('SQLALCHEMY_MIGRATE_REPO'), tmp_module.meta, db.metadata)
    open(migration, "wt").write(script)
    api.upgrade(app.config.get('SQLALCHEMY_DATABASE_URI'), app.config.get('SQLALCHEMY_MIGRATE_REPO'))
    print 'New migration saved as ' + migration
    print 'Current database version: ' + str(api.db_version(app.config.get('SQLALCHEMY_DATABASE_URI'), app.config.get('SQLALCHEMY_MIGRATE_REPO')))
Example #7
0
def migrate_db():
    migration = os.path.join(MG_REPO, 'versions', '%03d_migration.py' % (api.db_version(DB_URI, MG_REPO) + 1))
    tmp_module = imp.new_module('old_model')
    old_model = api.create_model(DB_URI, MG_REPO)
    exec(old_model, tmp_module.__dict__)
    script = api.make_update_script_for_model(DB_URI, MG_REPO, tmp_module.meta, db.metadata)
    # ?
    open(migration, 'wt').write(script)
    api.upgrade(DB_URI, MG_REPO)
    print('New migration saved as ' + migration)
    print('Current database version: ' + str(api.db_version(DB_URI, MG_REPO)))
Example #8
0
def migrate():
    from migrate.versioning import api
    migration = SQLALCHEMY_MIGRATE_REPO + '/versions/%03d_migration.py' % (api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO) + 1)
    tmp_module = imp.new_module('old_model')
    old_model = api.create_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
    exec old_model in tmp_module.__dict__
    script = api.make_update_script_for_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO, tmp_module.meta, db.metadata)
    open(migration, "wt").write(script)
    api.upgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
    print u'Миграция успешна: ' + migration
    print u'Версия базы данных: ' + str(api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO))
Example #9
0
def migrate_db():
    import imp
    v = api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
    migration = SQLALCHEMY_MIGRATE_REPO + ('/versions/%03d_migration.py' % (v+1))
    tmp_module = imp.new_module('old_model')
    old_model = api.create_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
    exec(old_model, tmp_module.__dict__)
    script = api.make_update_script_for_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO, tmp_module.meta, Base.metadata)
    open(migration, "wt").write(script)
    api.upgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
    v = api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
Example #10
0
def migrate_db():
    v = api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
    migration = SQLALCHEMY_MIGRATE_REPO + ('/versions/%03d_migration.py' % (v + 1))
    tmp_module = imp.new_module('old_model')
    old_model = api.create_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
    exec(old_model, tmp_module.__dict__)
    script = api.make_update_script_for_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO, tmp_module.meta, db.metadata)
    open(migration, "wt").write(script)
    api.upgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
    v = api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
    print('New migration saved as ' + migration)
    print('Current database version: ' + str(v))
def db_migrate():
    import imp
    migration = SQLALCHEMY_MIGRATE_REPO + '/versions/%03d_migration.py' % (api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO) + 1)
    tmp_module = imp.new_module('old_model')
    old_model = api.create_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
    #exec old_model in tmp_module.__dict__ # python2
    exec (old_model, tmp_module.__dict__)
    script = api.make_update_script_for_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO, tmp_module.meta, db.metadata)
    open(migration, "wt").write(script)
    api.upgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
    print ('New migration saved as ' + migration)
    print ('Current database version: ' + str(api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)))
Example #12
0
def db_migrate():
    import imp
    import re
    from migrate.versioning import api
    from wpcgi.db import db
    migration = SQLALCHEMY_MIGRATE_REPO + '/versions/%04d_migration.py' % (api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO) + 1)
    tmp_module = imp.new_module('old_model')
    old_model = api.create_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
    exec old_model in tmp_module.__dict__
    script = api.make_update_script_for_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO, tmp_module.meta, db.metadata)
    script = re.sub('INTEGER\(.*?\)', 'INTEGER', script)
    open(migration, "wt").write(script)
    print 'New migration saved as ' + migration
Example #13
0
def db_migrate():
    # This is used for database migration. Newly created database should go through this as well.
    migration = SQLALCHEMY_MIGRATE_REPO + '/versions/%03d_migration.py' % (api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO) + 1)
    tmp_module = imp.new_module('old_model')
    old_model = api.create_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)

    exec old_model in tmp_module.__dict__
    script = api.make_update_script_for_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO, tmp_module.meta, db.metadata)

    open(migration, "wt").write(script)
    api.upgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)

    print 'New migration saved as ' + migration
    print 'Current database version: ' + str(api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)) + '\n'
Example #14
0
def migrate():
    migration = SQLALCHEMY_MIGRATE_REPO + "/versions/%03d_migration.py" % (
        api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO) + 1
    )
    tmp_module = imp.new_module("old_model")
    old_model = api.create_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
    exec old_model in tmp_module.__dict__
    script = api.make_update_script_for_model(
        SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO, tmp_module.meta, db.metadata
    )
    open(migration, "wt").write(script)
    api.upgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
    print "New migration saved as " + migration
    print "Current database version: " + str(api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO))
Example #15
0
def migrateDB():
    repo = app.config['SQLALCHEMY_MIGRATE_REPO']
    uri = app.config['SQLALCHEMY_DATABASE_URI']

    v = api.db_version(uri, repo)
    migration = repo + ('/versions/%03d_migration.py' % (v+1))
    tmp_module = imp.new_module('old_model')
    old_model = api.create_model(uri, repo)
    exec(old_model, tmp_module.__dict__)
    script = api.make_update_script_for_model(uri, repo, 
                                    tmp_module.meta, db.metadata)
    open(migration, "wt").write(script)
    api.upgrade(uri, repo)
    v = api.db_version(uri, repo)
    print('New migration saved as ' + migration)
    print('Current database version: ' + str(v))
Example #16
0
	def db_migrate(self):
		print "DataBase Migrate"
		import imp
		from migrate.versioning import api
		from fpost.app import db
		from fpost.config import SQLALCHEMY_DATABASE_URI
		from fpost.config import SQLALCHEMY_MIGRATE_REPO
		migration = SQLALCHEMY_MIGRATE_REPO + '/versions/%03d_migration.py' % (api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO) + 1)
		tmp_module = imp.new_module('old_model')
		old_model = api.create_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
		exec old_model in tmp_module.__dict__
		script = api.make_update_script_for_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO, tmp_module.meta, db.metadata)
		open(migration, "wt").write(script)
		api.upgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
		print 'New migration saved as ' + migration
		print 'Current database version: ' + str(api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO))
Example #17
0
def migrate():
    """Compare the database against the app models and make a migration
    and upgrade to that version"""

    version = api.db_version(uri, repo) + 1
    migration = repo + '/versions/%03d_migration.py' % version
    tmp_module = imp.new_module('old_model')
    old_model = api.create_model(uri, repo)
    exec old_model in tmp_module.__dict__
    script = api.make_update_script_for_model(uri,
                                              repo,
                                              tmp_module.meta, db.metadata)
    open(migration, "wt").write(script)
    api.upgrade(uri, repo)

    print 'New migration saved as ' + migration
    show_version()
Example #18
0
def migrate_db(db_uri, migrate_repo):
    v = api.db_version(db_uri, migrate_repo)
    migration = migrate_repo + ('/versions/%03d_migration.py' % (v+1))
    tmp_module = imp.new_module('old_model')
    old_model = api.create_model(db_uri, migrate_repo)

    exec(old_model, tmp_module.__dict__)

    script = api.make_update_script_for_model(db_uri, migrate_repo, tmp_module.meta, db.metadata)

    open(migration, "wt").write(script)

    api.upgrade(db_uri, migrate_repo)

    v = api.db_version(db_uri, migrate_repo)
    print('New migration saved as ' + migration)
    print('Current database version: ' + str(v))
 def _create_migration_script(self, migration_name, oldmodel, newmodel,
                                 stdout=False, quiet=False):
     '''Generate migration script'''
     version = self._get_db_version() + 1
     migration = '{0}/versions/{1:03}_{2}.py'.format(
         self.sqlalchemy_migration_path, version, migration_name)
     script = api.make_update_script_for_model(self.sqlalchemy_database_uri,
         self.sqlalchemy_migration_path, oldmodel, newmodel)
     header = '# __VERSION__: {0}\n'.format(version)
     script = header + script
     if stdout:
         print(script)
     else:
         with open(migration, 'wt') as f:
             f.write(script)
         if not quiet:
             print('New migration saved as {0}'.format(migration))
             print('To apply migration, run: "manage.py dbmigrate migrate"')
Example #20
0
    def migrate(self):
        # DB迁移,空数据库或原始数据库的版本号是 0,每迁移一次版本加 1
        # 每次修改数据库模型的时候就需要生成新的记录(migration)
        
        dversion = self.get_current_db_version() + 1
        
        # 生成迁移脚本
        migration = self.SQLALCHEMY_MIGRATE_REPO + '/versions/%03d_migration.py' % (dversion)        
        tmp_module = imp.new_module('old_model')
        old_model = api.create_model(self.SQLALCHEMY_DATABASE_URI, self.SQLALCHEMY_MIGRATE_REPO)
        exec old_model in tmp_module.__dict__        
        script = api.make_update_script_for_model(self.SQLALCHEMY_DATABASE_URI, self.SQLALCHEMY_MIGRATE_REPO, tmp_module.meta, self.__dba.db.metadata)
#         script = api.make_update_script_for_model(self.SQLALCHEMY_DATABASE_URI, self.SQLALCHEMY_MIGRATE_REPO, tmp_module.meta, Base.metadata)
        open(migration, "wt").write(script)
        
        # 升级
        api.upgrade(self.SQLALCHEMY_DATABASE_URI, self.SQLALCHEMY_MIGRATE_REPO)
        print 'New migration saved as ' + migration
        print 'Current database version: ' + str(self.get_current_db_version())
Example #21
0
def migrate_db():
    import imp
    from migrate.versioning import api
    from database.model import db
    
    print("Migrating the database...")
    v = api.db_version(app.config.get('SQLALCHEMY_DATABASE_URI'), app.config.get('SQLALCHEMY_MIGRATE_REPO'))
    migration = app.config.get('SQLALCHEMY_MIGRATE_REPO') + ('/versions/%03d_migration.py' % (v+1))

    tmp_module = imp.new_module('old_model')
    old_model = api.create_model(app.config.get('SQLALCHEMY_DATABASE_URI'), app.config.get('SQLALCHEMY_MIGRATE_REPO'))
    exec(old_model, tmp_module.__dict__)

    script = api.make_update_script_for_model(app.config.get('SQLALCHEMY_DATABASE_URI'), app.config.get('SQLALCHEMY_MIGRATE_REPO'), tmp_module.meta, db.metadata)
    open(migration, "wt").write(script)

    api.upgrade(app.config.get('SQLALCHEMY_DATABASE_URI'), app.config.get('SQLALCHEMY_MIGRATE_REPO'))
    v = api.db_version(app.config.get('SQLALCHEMY_DATABASE_URI'), app.config.get('SQLALCHEMY_MIGRATE_REPO'))
    print("New migration saved as " + migration)
    print("Current database version: " + str(v))
Example #22
0
def db_migrate():
    ''' Migrate the DB creating a new version '''
    import imp
    from migrate.versioning import api
    from app import db
    migration = (app.config['SQLALCHEMY_MIGRATE_REPO'] + '/versions/%03d_migration.py' %
                 (api.db_version(app.config['SQLALCHEMY_DATABASE_URI'],
                                 app.config['SQLALCHEMY_MIGRATE_REPO']) + 1))
    tmp_module = imp.new_module('old_model')
    old_model = api.create_model(app.config['SQLALCHEMY_DATABASE_URI'],
                                 app.config['SQLALCHEMY_MIGRATE_REPO'])
    exec old_model in tmp_module.__dict__
    script = api.make_update_script_for_model(app.config['SQLALCHEMY_DATABASE_URI'],
                                              app.config['SQLALCHEMY_MIGRATE_REPO'],
                                              tmp_module.meta, db.metadata)
    open(migration, "wt").write(script)
    api.upgrade(app.config['SQLALCHEMY_DATABASE_URI'], app.config['SQLALCHEMY_MIGRATE_REPO'])
    print 'New migration saved as ' + migration
    print 'Current database version: ' + str(api.db_version(
        app.config['SQLALCHEMY_DATABASE_URI'],
        app.config['SQLALCHEMY_MIGRATE_REPO']))
def migrate():
    # 创建迁移文件
    migration = SQLALCHEMY_MIGRATE_REPO + "/versions/%03d_migration.py" % (
        api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO) + 1
    )
    # 新建模型
    tmp_module = imp.new_module("old_model")
    # 原来的模型
    old_model = api.create_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
    exec old_model in tmp_module.__dict__
    # 生成迁移脚本
    script = api.make_update_script_for_model(
        SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO, tmp_module.meta, db.metadata
    )
    # 将更新脚本写入迁移文件
    open(migration, "wt").write(script)
    # 更新数据库到最新版本
    api.upgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
    print u"New migration saved as " + migration + u"Current database version:" + str(
        api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
    )
Example #24
0
 def migrate(self):
     try:
         import imp
         v = api.db_version(self.app.config.db_uri, self.app.db.db_repo)
         migration = f'{self.app.db.db_repo}/versions/{v+1:02}_migration.py'
         tmp_module = imp.new_module('old_model')
         old_model = api.create_model(self.app.config.db_uri, self.app.db.db_repo)
         exec(old_model, tmp_module.__dict__)
         script = api.make_update_script_for_model(self.app.config.db_uri,
                                                   self.app.db.db_repo,
                                                   tmp_module.meta,
                                                   self.app.db.metadata)
         open(migration, "wt").write(script)
         api.upgrade(self.app.config.db_uri, self.app.db.db_repo)
         v = api.db_version(self.app.config.db_uri, self.app.db.db_repo)
     except:
         print(f'{CRED}ERROR!{CEND} Unable to migrate the database schema.')
         print(traceback.format_exc())
     else:
         print('New migration saved as ' + migration)
         print('Current database version: ' + str(v))
Example #25
0
def dbmigrate():
    app = Flask(__name__)
    conf = app.config.from_object('config.ProductionConfig')

    sqlalchemy_migrate_repo = app.config['SQLALCHEMY_MIGRATE_REPO']
    sqlalchemy_database_uri = app.config['SQLALCHEMY_DATABASE_URI']

    v = api.db_version(sqlalchemy_database_uri, sqlalchemy_migrate_repo)
    migration = sqlalchemy_migrate_repo + ('/versions/%03d_migration.py' %
                                           (v + 1))
    tmp_module = imp.new_module('old_model')
    old_model = api.create_model(sqlalchemy_database_uri,
                                 sqlalchemy_migrate_repo)
    exec(old_model, tmp_module.__dict__)
    script = api.make_update_script_for_model(sqlalchemy_database_uri,
                                              sqlalchemy_migrate_repo,
                                              tmp_module.meta, db.metadata)
    open(migration, "wt").write(script)
    api.upgrade(sqlalchemy_database_uri, sqlalchemy_migrate_repo)
    v = api.db_version(sqlalchemy_database_uri, sqlalchemy_migrate_repo)
    print('New migration saved as ' + migration)
    print('Current database version: ' + str(v))
Example #26
0
 def db_migrate(self):
     print "DataBase Migrate"
     import imp
     from migrate.versioning import api
     from fpost.app import db
     from fpost.config import SQLALCHEMY_DATABASE_URI
     from fpost.config import SQLALCHEMY_MIGRATE_REPO
     migration = SQLALCHEMY_MIGRATE_REPO + '/versions/%03d_migration.py' % (
         api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO) +
         1)
     tmp_module = imp.new_module('old_model')
     old_model = api.create_model(SQLALCHEMY_DATABASE_URI,
                                  SQLALCHEMY_MIGRATE_REPO)
     exec old_model in tmp_module.__dict__
     script = api.make_update_script_for_model(SQLALCHEMY_DATABASE_URI,
                                               SQLALCHEMY_MIGRATE_REPO,
                                               tmp_module.meta, db.metadata)
     open(migration, "wt").write(script)
     api.upgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
     print 'New migration saved as ' + migration
     print 'Current database version: ' + str(
         api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO))
Example #27
0
def db_migrate():
    with app.app_context():
        import imp
        from migrate.versioning import api

        SQLALCHEMY_MIGRATE_REPO = app.config['SQLALCHEMY_MIGRATE_REPO']
        SQLALCHEMY_DATABASE_URI = app.config['SQLALCHEMY_DATABASE_URI']

        v = api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
        migration = SQLALCHEMY_MIGRATE_REPO + ('/versions/%03d_migration.py' %
                                               (v + 1))
        tmp_module = imp.new_module('old_model')
        old_model = api.create_model(SQLALCHEMY_DATABASE_URI,
                                     SQLALCHEMY_MIGRATE_REPO)
        exec(old_model, tmp_module.__dict__)
        script = api.make_update_script_for_model(SQLALCHEMY_DATABASE_URI,
                                                  SQLALCHEMY_MIGRATE_REPO,
                                                  tmp_module.meta, db.metadata)
        open(migration, "wt").write(script)
        api.upgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
        v = api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
        print('New migration saved as ' + migration)
        print('Current database version: ' + str(v))
Example #28
0
def migrate():
    import imp
    from app import db

    v = api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
    migration = SQLALCHEMY_MIGRATE_REPO + \
            ('/versions/%03d_migration.py' % (v+1))

    tmp_module = imp.new_module('old_model')
    old_model = api.create_model(SQLALCHEMY_DATABASE_URI,
                                 SQLALCHEMY_MIGRATE_REPO)
    exec(old_model, tmp_module.__dict__)

    script = api.make_update_script_for_model(SQLALCHEMY_DATABASE_URI,
                                              SQLALCHEMY_MIGRATE_REPO,
                                              tmp_module.meta, db.metadata)
    open(migration, "wt").write(script)

    api.upgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
    v = api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)

    print('New migration saved as {}'.format(migration))
    print('Current database version: {}'.format(str(v)))
Example #29
0
def db_migrate():
    ''' Migrate the DB creating a new version '''
    import imp
    from migrate.versioning import api
    from app import db
    migration = (app.config['SQLALCHEMY_MIGRATE_REPO'] +
                 '/versions/%03d_migration.py' %
                 (api.db_version(app.config['SQLALCHEMY_DATABASE_URI'],
                                 app.config['SQLALCHEMY_MIGRATE_REPO']) + 1))
    tmp_module = imp.new_module('old_model')
    old_model = api.create_model(app.config['SQLALCHEMY_DATABASE_URI'],
                                 app.config['SQLALCHEMY_MIGRATE_REPO'])
    exec old_model in tmp_module.__dict__
    script = api.make_update_script_for_model(
        app.config['SQLALCHEMY_DATABASE_URI'],
        app.config['SQLALCHEMY_MIGRATE_REPO'], tmp_module.meta, db.metadata)
    open(migration, "wt").write(script)
    api.upgrade(app.config['SQLALCHEMY_DATABASE_URI'],
                app.config['SQLALCHEMY_MIGRATE_REPO'])
    print 'New migration saved as ' + migration
    print 'Current database version: ' + str(
        api.db_version(app.config['SQLALCHEMY_DATABASE_URI'],
                       app.config['SQLALCHEMY_MIGRATE_REPO']))
Example #30
0
def main():
    db_version = api.db_version(config.Flask.SQLALCHEMY_DATABASE_URI,
                                config.App.MIGRATE_REPO_PATH)
    migration = '%s/versions/%03d_migration.py' % (
        config.App.MIGRATE_REPO_PATH, db_version + 1)

    tmp_module = imp.new_module('old_model')
    old_model = api.create_model(config.Flask.SQLALCHEMY_DATABASE_URI,
                                 config.App.MIGRATE_REPO_PATH)
    exec(old_model, tmp_module.__dict__)

    script = api.make_update_script_for_model(
        config.Flask.SQLALCHEMY_DATABASE_URI, config.App.MIGRATE_REPO_PATH,
        tmp_module.meta, db.metadata)
    with open(migration, "wt") as fd:
        fd.write(script)
    api.upgrade(config.Flask.SQLALCHEMY_DATABASE_URI,
                config.App.MIGRATE_REPO_PATH)
    db_version = api.db_version(config.Flask.SQLALCHEMY_DATABASE_URI,
                                config.App.MIGRATE_REPO_PATH)

    print('New migration saved as %s' % migration)
    print('Current database version: %d' % db_version)
Example #31
0
def migrate_db(*opts):
    '''
    Migrates the Database to what the current codebase expects.
    '''
    migration = ''.join([SQLALCHEMY_MIGRATE_REPO, 
                        '/versions/%03d_migration.py' % (\
                            api.db_version(SQLALCHEMY_DATABASE_URI, 
                                           SQLALCHEMY_MIGRATE_REPO) + 1)])

    tmp_module = imp.new_module('old_model')
    old_model = api.create_model(SQLALCHEMY_DATABASE_URI, 
                                 SQLALCHEMY_MIGRATE_REPO)

    exec old_model in tmp_module.__dict__
    script = api.make_update_script_for_model(SQLALCHEMY_DATABASE_URI, 
                                              SQLALCHEMY_MIGRATE_REPO, 
                                              tmp_module.meta, 
                                              db.metadata)
    open(migration, "wt").write(script)
    api.upgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)

    print 'New migration saved as ' + migration
    print 'Current database version: ' + str(api.db_version(SQLALCHEMY_DATABASE_URI, 
                                                            SQLALCHEMY_MIGRATE_REPO))
Example #32
0
#! /usr/bin/env python

#creates a migration by comparing structure for the db (app.db) against structure of our models (app/models.py) - Difference b/n two are recorded as migration script inside migration repository

#migration script knows how to apply or undo a migration, so it's always possible to upgrade or downgrade a database format

import imp
from migrate.versioning import api
from app import db
from settings import settings

mrepo = settings.sqlalchemy_migrations_repo
db_url = settings.database.url

migration = mrepo + '/versions/%03d_migration.py' % (
    api.db_version(db_url, mrepo) + 1)
tmp_module = imp.new_module('old_model')
old_model = api.create_model(db_url, mrepo)
exec old_model in tmp_module.__dict__
script = api.make_update_script_for_model(db_url, mrepo, tmp_module.meta,
                                          db.metadata)
open(migration, "wt").write(script)
api.upgrade(db_url, mrepo)
print 'New migration saved as ' + migration
print 'Current database version: ' + str(api.db_version(db_url, mrepo))
#!flask/bin/python
import imp
from migrate.versioning import api
import sys
sys.path.append('../')

from app import app, db

uri = app.config['SQLALCHEMY_DATABASE_URI']
repo = app.config['SQLALCHEMY_MIGRATE_REPO']

migration = repo + '/versions/%03d_migration.py' %\
                   (api.db_version(uri, repo) + 1)
tmp_module = imp.new_module('old_model')
old_model = api.create_model(uri, repo)
exec old_model in tmp_module.__dict__
script = api.make_update_script_for_model(uri, repo, tmp_module.meta,
                                          db.metadata)
open(migration, "wt").write(script)
api.upgrade(uri, repo)
print 'New migration saved as ' + migration
print 'Current database version: ' + str(api.db_version(uri, repo))
Example #34
0
#!flask/bin/python
import imp
from migrate.versioning import api
from app import db, app

migration = app.config['SQLALCHEMY_MIGRATE_REPO'] + '/versions/%03d_migration.py' % (api.db_version(app.config['SQLALCHEMY_DATABASE_URI'], app.config['SQLALCHEMY_MIGRATE_REPO']) + 1)
tmp_module = imp.new_module('old_model')
old_model = api.create_model(app.config['SQLALCHEMY_DATABASE_URI'], app.config['SQLALCHEMY_MIGRATE_REPO'])
exec old_model in tmp_module.__dict__
script = api.make_update_script_for_model(app.config['SQLALCHEMY_DATABASE_URI'], app.config['SQLALCHEMY_MIGRATE_REPO'], tmp_module.meta, db.metadata)
open(migration, "wt").write(script)
api.upgrade(app.config['SQLALCHEMY_DATABASE_URI'], app.config['SQLALCHEMY_MIGRATE_REPO'])
print 'New migration saved as ' + migration
print 'Current database version: ' + str(api.db_version(app.config['SQLALCHEMY_DATABASE_URI'], app.config['SQLALCHEMY_MIGRATE_REPO']))
Example #35
0
#!flask/bin/python
import imp
from migrate.versioning import api
from app import db
from config import SQLALCHEMY_DATABASE_URI
from config import SQLALCHEMY_MIGRATE_REPO

migration = SQLALCHEMY_MIGRATE_REPO + '/version/%03_migrate.py' % (api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO) + 1)
tmp_mdel = imp.new_module('old_model')
old_mdel = api.create_module(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO) 
exec old_model in tmp_module.__dict__
script = api.make_update_script_for_model(SQLALCHEMY_MIGRATE_REPO)
open(migration, "wt").write(script)
a = api.upgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
print "New migration saved as " + migration
print "Current database version: " + str(api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO))
Example #36
0
import UserDatabase

UserDatabase.setup()
import imp
from migrate.versioning import api
from UserDatabase import DATABASE_URI
from UserDatabase import MIGRATE_REPO
v = api.db_version(DATABASE_URI, MIGRATE_REPO)
migration = MIGRATE_REPO + ('/versions/%03d_migration.py' % (v + 1))
tmp_module = imp.new_module('old_model')
old_model = api.create_model(DATABASE_URI, MIGRATE_REPO)
exec(old_model, tmp_module.__dict__)
script = api.make_update_script_for_model(DATABASE_URI, MIGRATE_REPO,
                                          tmp_module.meta,
                                          UserDatabase.base.metadata)
open(migration, "wt").write(script)
# api.upgrade(DATABASE_URI, MIGRATE_REPO)
# v = api.db_version(DATABASE_URI, MIGRATE_REPO)
# print('New migration saved as ' + migration)
# print('Current database version: ' + str(v))
Example #37
0
 def test_make_update_script_for_model(self):
     model = api.make_update_script_for_model(self.url, self.repo, models.meta_old_rundiffs, models.meta_rundiffs)
Example #38
0
 def test_make_update_script_for_model(self):
     model = api.make_update_script_for_model(self.url, self.repo,
                                              models.meta_old_rundiffs,
                                              models.meta_rundiffs)
Example #39
0
"""Migration script to be run whenever there changes in app database structure"""

from __future__ import print_function
import imp
from migrate.versioning import api
from app import db
from config import SQLALCHEMY_DATABASE_URI
from config import SQLALCHEMY_MIGRATE_REPO

VERSION = api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
MIGRATION = SQLALCHEMY_MIGRATE_REPO + ('/versions/%03d_migration.py' %
                                       (VERSION + 1))
TMP_MODULE = imp.new_module('old_model')
OLD_MODEL = api.create_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)

exec(OLD_MODEL, TMP_MODULE.__dict__)

SCRIPT = api.make_update_script_for_model(SQLALCHEMY_DATABASE_URI,
                                          SQLALCHEMY_MIGRATE_REPO,
                                          TMP_MODULE.meta, db.metadata)
open(MIGRATION, "wt").write(SCRIPT)
api.upgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
VERSION = api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
print('New migration saved as ' + MIGRATION)
print('Current database version: ' + str(VERSION))
Example #40
0
#!flask/bin/python

# Utilized with changes from:
# https://github.com/miguelgrinberg/microblog/blob/6b193afe4748f25018fe086bc7faee452e024828/db_migrate.py

import imp
from migrate.versioning import api
from app import db
from config import SQLALCHEMY_DATABASE_URI
from config import SQLALCHEMY_MIGRATIONS

migration = SQLALCHEMY_MIGRATIONS + '/versions/%03d_migration.py' % (
    api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATIONS) + 1)
tmp_module = imp.new_module('old_model')
old_model = api.create_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATIONS)
exec old_model in tmp_module.__dict__
script = api.make_update_script_for_model(SQLALCHEMY_DATABASE_URI,
                                          SQLALCHEMY_MIGRATIONS,
                                          tmp_module.meta, db.metadata)
open(migration, "wt").write(script)
api.upgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATIONS)
print 'New migration saved as ' + migration
print 'Current database version: ' + str(
    api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATIONS))
Example #41
0
#!flask/bin/python
import imp
from migrate.versioning import api
from app import db
from config import SQLALCHEMY_DATABASE_URI
from config import SQLALCHEMY_BINDS
from config import SQLALCHEMY_MIGRATE_REPO
from config import SQLALCHEMY_BINDS_MIGRATE_REPO

migration = SQLALCHEMY_MIGRATE_REPO + '/versions/%03d_migration.py' % (
    api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO) + 1)
tmp_module = imp.new_module('old_model')
old_model = api.create_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
exec old_model in tmp_module.__dict__
script = api.make_update_script_for_model(SQLALCHEMY_DATABASE_URI,
                                          SQLALCHEMY_MIGRATE_REPO,
                                          tmp_module.meta, db.metadata)
open(migration, "wt").write(script)
api.upgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
print 'New migration saved as ' + migration
print 'Current database version: ' + str(
    api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO))

for name, uri in SQLALCHEMY_BINDS.items():
    migration = SQLALCHEMY_BINDS_MIGRATE_REPO[
        name] + '/versions/%03d_migration.py' % (
            api.db_version(uri, SQLALCHEMY_BINDS_MIGRATE_REPO[name]) + 1)
    tmp_module = imp.new_module('old_model')
    old_model = api.create_model(uri, SQLALCHEMY_BINDS_MIGRATE_REPO[name])
    exec old_model in tmp_module.__dict__
    script = api.make_update_script_for_model(
Example #42
0
#!bin/python3
import imp
from migrate.versioning import api
import app
from app import config

v = api.db_version(
    config.SQLALCHEMY_DATABASE_URI, config.SQLALCHEMY_MIGRATE_REPO
)

migration = config.SQLALCHEMY_MIGRATE_REPO + ('/versions/%03d_migration.py' % (v+1))
tmp_module = imp.new_module('old_model')

old_model = api.create_model(
    config.SQLALCHEMY_DATABASE_URI,
    config.SQLALCHEMY_MIGRATE_REPO
)

exec(old_model, tmp_module.__dict__)

script = api.make_update_script_for_model(
    config.SQLALCHEMY_DATABASE_URI,
    config.SQLALCHEMY_MIGRATE_REPO, tmp_module.meta, app.db.metadata
)

open(migration, "wt").write(script)
api.upgrade( config.SQLALCHEMY_DATABASE_URI, config.SQLALCHEMY_MIGRATE_REPO)
v = api.db_version( config.SQLALCHEMY_DATABASE_URI, config.SQLALCHEMY_MIGRATE_REPO)
print('New migration saved as ' + migration)
print('Current database version: ' + str(v))
Example #43
0
#####数据库迁移脚本
import sys
sys.path.append('..')
import imp
from migrate.versioning import api
from app import db
from conf import SQLALCHEMY_MIGRATE_REPO, SQLALCHEMY_DATABASE_URI

v = api.db_version(url=SQLALCHEMY_DATABASE_URI,
                   repository=SQLALCHEMY_MIGRATE_REPO)  #获取当的版本号
migration = SQLALCHEMY_MIGRATE_REPO + ('/versions/%03d_migration.py' %
                                       (v + 1))  ###

tmp_model = imp.new_module('old_model')
old_model = api.create_model(url=SQLALCHEMY_DATABASE_URI,
                             repository=SQLALCHEMY_MIGRATE_REPO)
exec(old_model, tmp_model.__dict__)
script = api.make_update_script_for_model(url=SQLALCHEMY_DATABASE_URI,
                                          repository=SQLALCHEMY_MIGRATE_REPO,
                                          oldmodel=tmp_model.meta,
                                          model=db.metadata)
open(migration, 'wt').write(script)
api.upgrade(url=SQLALCHEMY_DATABASE_URI, repository=SQLALCHEMY_MIGRATE_REPO)
v = api.db_version(url=SQLALCHEMY_DATABASE_URI,
                   repository=SQLALCHEMY_MIGRATE_REPO)

print('new migration saved as ' + migration)
print('current db version: ' + str(v))
Example #44
0
import imp
from migrate.versioning import api
from application import db
from config import SQLALCHEMY_DATABASE_URI as SDU
from config import SQLALCHEMY_MIGRATE_REPO as SMR

v = api.db_version(SDU, SMR)
migration = SMR + '/versions/{:03}_migration.py'.format(v+1)
tmp_module = imp.new_module('old_model')
old_model = api.create_model(SDU, SMR)
exec(old_model, tmp_module.__dict__)

script = api.make_update_script_for_model(
         SDU, SMR, tmp_module.meta, db.metadata)
open(migration, "wt").write(script)
api.upgrade(SDU, SMR)
v = api.db_version(SDU, SMR)

print('New migration saved as {}'.format(migration))
print('Current Database version: {}'.format(v))
Example #45
0
import imp
from migrate.versioning import api
from settings import SQLALCHEMY_DB_URI, SQLALCHEMY_MIGRATE_REPO
from stats import db, Base

migration = SQLALCHEMY_MIGRATE_REPO + '/versions/%03d_migration.py' % (
    api.db_version(SQLALCHEMY_DB_URI, SQLALCHEMY_MIGRATE_REPO) + 1)

tmp_module = imp.new_module('old_model')
old_model = api.create_model(SQLALCHEMY_DB_URI, SQLALCHEMY_MIGRATE_REPO)

exec old_model in tmp_module.__dict__

script = api.make_update_script_for_model(SQLALCHEMY_DB_URI,
                                          SQLALCHEMY_MIGRATE_REPO,
                                          tmp_module.meta, Base.metadata)
open(migration, "wt").write(script)
a = api.upgrade(SQLALCHEMY_DB_URI, SQLALCHEMY_MIGRATE_REPO)

print 'New migration saved as ' + migration
print 'Current DB version: ' + str(
    api.db_version(SQLALCHEMY_DB_URI, SQLALCHEMY_MIGRATE_REPO))
Example #46
0
#! /usr/bin/env python

# creates a migration by comparing structure for the db (app.db) against structure of our models (app/models.py) - Difference b/n two are recorded as migration script inside migration repository

# migration script knows how to apply or undo a migration, so it's always possible to upgrade or downgrade a database format

import imp
from migrate.versioning import api
from app import db
from settings import settings

mrepo = settings.sqlalchemy_migrations_repo
db_url = settings.database.url

migration = mrepo + "/versions/%03d_migration.py" % (api.db_version(db_url, mrepo) + 1)
tmp_module = imp.new_module("old_model")
old_model = api.create_model(db_url, mrepo)
exec old_model in tmp_module.__dict__
script = api.make_update_script_for_model(db_url, mrepo, tmp_module.meta, db.metadata)
open(migration, "wt").write(script)
api.upgrade(db_url, mrepo)
print "New migration saved as " + migration
print "Current database version: " + str(api.db_version(db_url, mrepo))
import os.path
import sys
import imp

cwd = os.path.dirname(os.path.realpath(__file__))
sys.path.insert(0, os.path.abspath(cwd + '/../'))

from migrate.versioning import api

from app import app, db

migration = app.config['SQLALCHEMY_MIGRATE_REPO'] + '/versions/%03d_migration.py' % \
    (api.db_version(app.config['SQLALCHEMY_DATABASE_URI'],
                    app.config['SQLALCHEMY_MIGRATE_REPO']) + 1)
tmp_module = imp.new_module('old_model')

old_model = api.create_model(app.config['SQLALCHEMY_DATABASE_URI'],
                             app.config['SQLALCHEMY_MIGRATE_REPO'])
exec old_model in tmp_module.__dict__

script = api.make_update_script_for_model(
    app.config['SQLALCHEMY_DATABASE_URI'],
    app.config['SQLALCHEMY_MIGRATE_REPO'], tmp_module.meta, db.metadata)
open(migration, "wt").write(script)
api.upgrade(app.config['SQLALCHEMY_DATABASE_URI'],
            app.config['SQLALCHEMY_MIGRATE_REPO'])
print 'New migration saved as ' + migration
print 'Current database version: ' + str(
    api.db_version(app.config['SQLALCHEMY_DATABASE_URI'],
                   app.config['SQLALCHEMY_MIGRATE_REPO']))
Example #48
0
from imp import new_module
from migrate.versioning import api
from helptux import db
from config import SQLALCHEMY_MIGRATE_REPO, SQLALCHEMY_DATABASE_URI

v = api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)

migration = '{0}/versions/{1}_migration.py'.format(SQLALCHEMY_MIGRATE_REPO,
                                                   (v + 1))

m_old_model = new_module('old_model')
old_model = api.create_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)

exec(old_model, m_old_model.__dict__)

script = api.make_update_script_for_model(SQLALCHEMY_DATABASE_URI,
                                          SQLALCHEMY_MIGRATE_REPO,
                                          m_old_model.meta, db.metadata)
open(migration, 'wt').write(script)

api.upgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
v = api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)

print('New migration saved as {0}'.format(migration))
print('Current database version: {0}'.format(str(v)))
Example #49
0
#!flask/bin/python
import imp
from migrate.versioning import api
from app import db
from config import Config
v = api.db_version(Config.SQLALCHEMY_DATABASE_URI,
                   Config.SQLALCHEMY_MIGRATE_REPO)
migration = Config.SQLALCHEMY_MIGRATE_REPO + ('/versions/%03d_migration.py' %
                                              (v + 1))
tmp_module = imp.new_module('old_model')
old_model = api.create_model(Config.SQLALCHEMY_DATABASE_URI,
                             Config.SQLALCHEMY_MIGRATE_REPO)
exec(old_model, tmp_module.__dict__)
script = api.make_update_script_for_model(Config.SQLALCHEMY_DATABASE_URI,
                                          Config.SQLALCHEMY_MIGRATE_REPO,
                                          tmp_module.meta, db.metadata)
open(migration, "wt").write(script)
api.upgrade(Config.SQLALCHEMY_DATABASE_URI, Config.SQLALCHEMY_MIGRATE_REPO)
v = api.db_version(Config.SQLALCHEMY_DATABASE_URI,
                   Config.SQLALCHEMY_MIGRATE_REPO)
print('New migration saved as ' + migration)
print('Current database version: ' + str(v))
Example #50
0
#!flask/bin/python
import imp
from migrate.versioning import api
from frmwk import orm_db
from config import SQLALCHEMY_DATABASE_URI
from config import SQLALCHEMY_MIGRATE_REPO
migration = SQLALCHEMY_MIGRATE_REPO + '/versions/%03d_migration.py' % (
    api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO) + 1)
tmp_module = imp.new_module('old_model')
old_model = api.create_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
exec old_model in tmp_module.__dict__
script = api.make_update_script_for_model(SQLALCHEMY_DATABASE_URI,
                                          SQLALCHEMY_MIGRATE_REPO,
                                          tmp_module.meta, orm_db.metadata)
open(migration, "wt").write(script)
api.upgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
print 'New migration saved as ' + migration
print 'Current database version: ' + str(
    api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO))
Example #51
0
import imp
from migrate.versioning import api
from app import db
from config import SQLALCHEMY_DATABASE_URI
from config import SQLALCHEMY_MIGRATE_REPO

migration = SQLALCHEMY_MIGRATE_REPO + '/versions/%03d_migration.py' % (api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO) + 1)
tmp_module = imp.new_module('old_model')
old_model = api.create_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
exec old_model in tmp_module.__dict__
script = api.make_update_script_for_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO, tmp_module.meta,
db.metadata)
open(migration, 'wt').write(script)
a = api.upgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
print 'New migration saved as ' + migration
print 'Current database version: ' + str(api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO))

Example #52
0
import imp
from migrate.versioning import api
from app import db
from config import DATABASE_URI
from config import MIGRATE_REPO

migration = MIGRATE_REPO + '/versions/%03d_migration.py' % (
    api.db_version(DATABASE_URI, MIGRATE_REPO) + 1)
tmp_module = imp.new_module('old_model')
old_model = api.create_model(DATABASE_URI, MIGRATE_REPO)
exec old_model in tmp_module.__dict__
script = api.make_update_script_for_model(
    DATABASE_URI, MIGRATE_REPO, tmp_module.meta, db.metadata)
open(migration, "wt").write(script)

api.upgrade(DATABASE_URI, MIGRATE_REPO)

print 'New migration saved as ' + migration
print 'Current database version: ' + str(api.db_version(DATABASE_URI, MIGRATE_REPO))