def test_create_rev_depends_on_branch_label(self): self._env_fixture() command.revision(self.cfg) rev2 = command.revision(self.cfg, branch_label="foobar") rev3 = command.revision(self.cfg, depends_on="foobar") eq_(rev3.dependencies, "foobar") eq_(rev3._resolved_dependencies, (rev2.revision,))
def test_create_script_branches_old_template(self): script = ScriptDirectory.from_config(self.cfg) with open(os.path.join(script.dir, "script.py.mako"), "w") as file_: file_.write( "<%text>#</%text> ${message}\n" "revision = ${repr(up_revision)}\n" "down_revision = ${repr(down_revision)}\n" "def upgrade():\n" " ${upgrades if upgrades else 'pass'}\n\n" "def downgrade():\n" " ${downgrade if downgrades else 'pass'}\n\n" ) # works OK if no branch names command.revision(self.cfg, message="some message") assert_raises_message( util.CommandError, r"Version \w+ specified branch_labels foobar, " r"however the migration file .+?\b does not have them; have you " "upgraded your script.py.mako to include the 'branch_labels' " r"section\?", command.revision, self.cfg, message="some message", branch_label="foobar" )
def init_database(app): settings = None try: settings = DBSiteSettings.get_by_id(1) if not settings or not settings.inited: raise Exception("Can not get site settings") if settings.version < DBSiteSettings.VERSION: raise Exception("Database expired") except: from alembic import command # auto generate alembic version in local try: command.revision(app.config["MIGRATE_CFG"], "database v%s" % DBSiteSettings.VERSION, True) except: logging.exception("migrate revision error") command.upgrade(app.config["MIGRATE_CFG"], "head") if not settings: settings = create_default_settings(app) else: settings.inited = True settings.version = DBSiteSettings.VERSION settings.save() app.config["SiteTitle"] = settings.title app.config["SiteSubTitle"] = settings.subtitle app.config["OwnerEmail"] = settings.owner
def migrate(app, message=None, autogenerate=False, sql=False, head='head', splice=False, branch_label=None, version_path=None, rev_id=None): """Create new database migration. """ command.revision(app.migrations_config, message, sql=sql, head=head, autogenerate=autogenerate, splice=splice, branch_label=branch_label, version_path=version_path, rev_id=rev_id)
def revision( directory=None, message=None, autogenerate=False, sql=False, head="head", splice=False, branch_label=None, version_path=None, rev_id=None, ): """Create a new revision file.""" config = _get_config(directory) if alembic_version >= (0, 7, 0): command.revision( config, message, autogenerate=autogenerate, sql=sql, head=head, splice=splice, branch_label=branch_label, version_path=version_path, rev_id=rev_id, ) else: command.revision(config, message, autogenerate=autogenerate, sql=sql)
def migrate(self, directory=None, message=None, sql=False, head='head', splice=False, branch_label=None, version_path=None, rev_id=None, **kwargs): # pragma: no cover """Alias for 'revision --autogenerate'""" config = _get_config(directory) command.revision(config, message, autogenerate=True, sql=sql, head=head, splice=splice, branch_label=branch_label, version_path=version_path, rev_id=rev_id)
def migrate( directory=None, message=None, sql=False, head="head", splice=False, branch_label=None, version_path=None, rev_id=None, ): """Alias for 'revision --autogenerate'""" config = _get_config(directory) if alembic_version >= (0, 7, 0): command.revision( config, message, autogenerate=True, sql=sql, head=head, splice=splice, branch_label=branch_label, version_path=version_path, rev_id=rev_id, ) else: command.revision(config, message, autogenerate=True, sql=sql)
def revision(self, directory=None, message=None, autogenerate=False, sql=False, head='head', splice=False, branch_label=None, version_path=None, rev_id=None, **kwargs): """Create a new revision file.""" config = _get_config(directory) command.revision(config, message, autogenerate=autogenerate, sql=sql, head=head, splice=splice, branch_label=branch_label, version_path=version_path, rev_id=rev_id)
def test_create_rev_autogen_db_not_up_to_date(self): self._env_fixture() command.revision(self.cfg) assert_raises_message( util.CommandError, "Target database is not up to date.", command.revision, self.cfg, autogenerate=True )
def test_create_rev_invalid_depends_on(self): self._env_fixture() command.revision(self.cfg) assert_raises_message( util.CommandError, "Can't locate revision identified by 'invalid'", command.revision, self.cfg, depends_on='invalid' )
def test_create_rev_depends_on_partial_revid(self): self._env_fixture() command.revision(self.cfg) rev2 = command.revision(self.cfg) assert len(rev2.revision) > 7 rev3 = command.revision(self.cfg, depends_on=rev2.revision[0:4]) eq_(rev3.dependencies, rev2.revision) eq_(rev3._resolved_dependencies, (rev2.revision,))
def revision(self, message=None, auto=None): auto = auto or False if not message: raise AlembicCommandError('Please provide a message') revision_id = self.generate_revision_id() command.revision(self.config, message=message, autogenerate=auto, sql=self.offline, rev_id=revision_id)
def create_new_revision(args, msg=None): """Will create a new autogenerated revision file. An returns the path of the new generated file.""" cfg = get_alembic_config(args) command.revision(cfg, message=msg, autogenerate=True) revision_file = get_last_revision_file(args) while is_locked(revision_file): time.sleep(1) return revision_file
def test_autogen(self): m = sa.MetaData() sa.Table('t', m, sa.Column('x', sa.Integer)) def process_revision_directives(context, rev, generate_revisions): existing_upgrades = generate_revisions[0].upgrade_ops existing_downgrades = generate_revisions[0].downgrade_ops # model1 will run the upgrades, e.g. create the table, # model2 will run the downgrades as upgrades, e.g. drop # the table again generate_revisions[:] = [ ops.MigrationScript( util.rev_id(), existing_upgrades, ops.DowngradeOps(), version_path=os.path.join( _get_staging_directory(), "model1"), head="model1@head" ), ops.MigrationScript( util.rev_id(), existing_downgrades, ops.DowngradeOps(), version_path=os.path.join( _get_staging_directory(), "model2"), head="model2@head" ) ] with self._env_fixture(process_revision_directives, m): command.upgrade(self.cfg, "heads") eq_( Inspector.from_engine(self.engine).get_table_names(), ["alembic_version"] ) command.revision( self.cfg, message="some message", autogenerate=True) command.upgrade(self.cfg, "model1@head") eq_( Inspector.from_engine(self.engine).get_table_names(), ["alembic_version", "t"] ) command.upgrade(self.cfg, "model2@head") eq_( Inspector.from_engine(self.engine).get_table_names(), ["alembic_version"] )
def actionCreateMigration(self, message=None, auto=True): from alembic.config import Config from alembic import command if not message: self.parser.error("Please add comment") alembic_cfg = Config() alembic_cfg.set_main_option("script_location", "alembic") alembic_cfg.set_main_option("url", config.DB_URL) command.revision(alembic_cfg, message=message, autogenerate=auto)
def revision(config, message=None, autogenerate=False, sql=False, head='head', splice=False, branch_label=None, version_path=None, rev_id=None): """Create a new revision file.""" if alembic_version >= (0, 7, 0): command.revision(config, message, autogenerate=autogenerate, sql=sql, head=head, splice=splice, branch_label=branch_label, version_path=version_path, rev_id=rev_id) else: command.revision(config, message, autogenerate=autogenerate, sql=sql)
def migrate(config, message=None, sql=False, head='head', splice=False, branch_label=None, version_path=None, rev_id=None): """Alias for 'revision --autogenerate'""" setattr(config.cmd_opts, 'autogenerate', True) if alembic_version >= (0, 7, 0): command.revision(config, message, autogenerate=True, sql=sql, head=head, splice=splice, branch_label=branch_label, version_path=version_path, rev_id=rev_id) else: command.revision(config, message, autogenerate=True, sql=sql)
def migrate(context, directory='migrations', message=None, sql=False, head='head', splice=False, branch_label=None, version_path=None, rev_id=None): """Alias for 'revision --autogenerate'""" config = _get_config(directory, opts=['autogenerate']) if alembic_version >= (0, 7, 0): command.revision(config, message, autogenerate=True, sql=sql, head=head, splice=splice, branch_label=branch_label, version_path=version_path, rev_id=rev_id) else: command.revision(config, message, autogenerate=True, sql=sql)
def run(parser, options, args): cfg = config.Config() cfg.set_main_option( 'script_location', os.path.join( pkg_resources.require('kansha')[0].location, 'kansha/alembic' ) ) command.revision(cfg, message=options.message)
def _test_ignore_file_py(self, fname): command.revision(self.cfg, message="some rev") script = ScriptDirectory.from_config(self.cfg) path = os.path.join(script.versions, fname) with open(path, "w") as f: f.write("crap, crap -> crap") command.revision(self.cfg, message="another rev") script.get_revision("head")
def migrate(directory=None, message=None, sql=False, head='head', splice=False, branch_label=None, version_path=None, rev_id=None, x_arg=None): """Alias for 'revision --autogenerate'""" config = current_app.extensions['migrate'].migrate.get_config( directory, opts=['autogenerate'], x_arg=x_arg) if alembic_version >= (0, 7, 0): command.revision(config, message, autogenerate=True, sql=sql, head=head, splice=splice, branch_label=branch_label, version_path=version_path, rev_id=rev_id) else: command.revision(config, message, autogenerate=True, sql=sql)
def revision(directory=None, message=None, autogenerate=False, sql=False, head='head', splice=False, branch_label=None, version_path=None, rev_id=None): """Create a new revision file.""" config = current_app.extensions['migrate'].migrate.get_config(directory) if alembic_version >= (0, 7, 0): command.revision(config, message, autogenerate=autogenerate, sql=sql, head=head, splice=splice, branch_label=branch_label, version_path=version_path, rev_id=rev_id) else: command.revision(config, message, autogenerate=autogenerate, sql=sql)
def test_pk_constraint_normally_prevents_dupe_rows(self): self._env_fixture() command.revision(self.cfg) r2 = command.revision(self.cfg) db = _sqlite_file_db() command.upgrade(self.cfg, "head") assert_raises( sqla_exc.IntegrityError, db.execute, "insert into alembic_version values ('%s')" % r2.revision, )
def test_create_rev_depends_on(self): self._env_fixture() command.revision(self.cfg) rev2 = command.revision(self.cfg) rev3 = command.revision(self.cfg, depends_on=rev2.revision) eq_(rev3._resolved_dependencies, (rev2.revision,)) rev4 = command.revision( self.cfg, depends_on=[rev2.revision, rev3.revision] ) eq_(rev4._resolved_dependencies, (rev2.revision, rev3.revision))
def _test_ignore_init_py(self, ext): """test that __init__.py is ignored.""" command.revision(self.cfg, message="some rev") script = ScriptDirectory.from_config(self.cfg) path = os.path.join(script.versions, "__init__.%s" % ext) with open(path, "w") as f: f.write("crap, crap -> crap") command.revision(self.cfg, message="another rev") script.get_revision("head")
def test_create_rev_plain_post_merge(self): self._env_fixture() command.revision(self.cfg) rev2 = command.revision(self.cfg) command.revision(self.cfg) command.revision(self.cfg, head=rev2.revision, splice=True) command.merge(self.cfg, "heads") command.revision(self.cfg)
def revision(context, directory='migrations', message=None, autogenerate=False, sql=False, head='head', splice=False, branch_label=None, version_path=None, rev_id=None): """Create a new revision file.""" from app import create_app with create_app().app_context(): config = _get_config(directory) if alembic_version >= (0, 7, 0): command.revision(config, message, autogenerate=autogenerate, sql=sql, head=head, splice=splice, branch_label=branch_label, version_path=version_path, rev_id=rev_id) else: command.revision(config, message, autogenerate=autogenerate, sql=sql)
def test_create_rev_autogenerate_post_merge(self): self._env_fixture() command.revision(self.cfg) rev2 = command.revision(self.cfg) command.revision(self.cfg) command.revision(self.cfg, head=rev2.revision, splice=True) command.merge(self.cfg, "heads") command.upgrade(self.cfg, "heads") command.revision(self.cfg, autogenerate=True)
def test_err_correctly_raised_on_dupe_rows(self): self._env_fixture() command.revision(self.cfg) r2 = command.revision(self.cfg) db = _sqlite_file_db() command.upgrade(self.cfg, "head") db.execute("insert into alembic_version values ('%s')" % r2.revision) assert_raises_message( util.CommandError, "Online migration expected to match one row when " "updating .* in 'alembic_version'; 2 found", command.downgrade, self.cfg, "-1" )
def revision(): parser = argparse.ArgumentParser(description='Create a new db revision') parser.add_argument('dburl', help='Database URL for SQLAlchemy') parser.add_argument('message', help='Message for the new version') parser.add_argument('--autogenerate', help='Autogenerate', action='store_true') args = parser.parse_args() repositories.sa_pixort_data(url=args.dburl) command.revision( _get_config(args.dburl), message=args.message, autogenerate=args.autogenerate)
def test_new_locations_no_autogen(self): m = sa.MetaData() def process_revision_directives(context, rev, generate_revisions): generate_revisions[:] = [ ops.MigrationScript( util.rev_id(), ops.UpgradeOps(), ops.DowngradeOps(), version_path=os.path.join( _get_staging_directory(), "model1" ), head="model1@head", ), ops.MigrationScript( util.rev_id(), ops.UpgradeOps(), ops.DowngradeOps(), version_path=os.path.join( _get_staging_directory(), "model2" ), head="model2@head", ), ops.MigrationScript( util.rev_id(), ops.UpgradeOps(), ops.DowngradeOps(), version_path=os.path.join( _get_staging_directory(), "model3" ), head="model3@head", ), ] with self._env_fixture(process_revision_directives, m): revs = command.revision(self.cfg, message="some message") script = ScriptDirectory.from_config(self.cfg) for rev, model in [ (revs[0], "model1"), (revs[1], "model2"), (revs[2], "model3"), ]: rev_script = script.get_revision(rev.revision) eq_( rev_script.path, os.path.abspath( os.path.join( _get_staging_directory(), model, "%s_.py" % (rev_script.revision,), ) ), ) assert os.path.exists(rev_script.path)
def create_db_revision(): """Genereting alembic database migration script""" try: logger.info('Database does not fit metadata. Creating revision') rand = int(uuid.uuid4()) % 100000000000000 rand_str = str(hex(rand)[2:-1]) this.revision_id = 'v' + this.final_version + '_' + rand_str message = '' label = 'v' + this.final_version command.revision(ax_migration.alembic_cfg, message, rev_id=this.revision_id, autogenerate=True, branch_label=label) this.app_yaml['env_variables']['AX_DB_REVISION'] = this.revision_id except Exception: logger.exception('Error in creating database revision') raise
def test_create_script_splice(self): rev = command.revision(self.cfg, message="some message", head=self.b, splice=True) script = ScriptDirectory.from_config(self.cfg) rev = script.get_revision(rev.revision) eq_(rev.down_revision, self.b) assert "some message" in rev.doc eq_(set(script.get_heads()), set([rev.revision, self.c]))
def test_create_rev_autogen_db_not_up_to_date(self): self._env_fixture() assert command.revision(self.cfg) assert_raises_message( util.CommandError, "Target database is not up to date.", command.revision, self.cfg, autogenerate=True, )
def test_running_comments_not_in_sql(self): message = "this is a very long \nand multiline\nmessage" d = command.revision(self.cfg, message=message) with capture_context_buffer(transactional_ddl=True) as buf: command.upgrade(self.cfg, "%s:%s" % (a, d.revision), sql=True) assert not re.match(r".*-- .*and multiline", buf.getvalue(), re.S | re.M)
def make_migration(args_): target_db_setup(args_.target_db, args_.target_db_user, args_.target_db_password, args_.target_db_host, args_.target_db_port, args_.db_name) if not schema_verification(): sys.exit() tables_ = create_tables_from_rules(True) config = alembic.config.Config("./alembic.ini") config.set_main_option("sqlalchemy.url", target_db) config.set_main_option("script_location", "./migrate") script = ScriptDirectory.from_config(config) head_revision = "" try: command.revision(config, autogenerate=True) head_revision = script.get_current_head() migrate() except FileNotFoundError as Error: print("Error Occurred") print(Error) print("Rollback Migration") try: file = os.path.join(os.curdir, os.path.join("migrate/versions", (head_revision + "_.py"))) os.remove(file) except FileNotFoundError: pass finally: sys.exit() except CommandError as E: print(E) print("Target Database not in sync") print("Re-Run migration") try: engine.execute("drop table alembic_version") purge("./migrate/versions", "\w+.py") except exc.ProgrammingError: pass finally: pass return tables_
def test_bad_render(self): env_file_fixture(""" context.configure(dialect_name='sqlite', template_args={"somearg":"somevalue"}) """) script_file_fixture(""" <% z = x + y %> """) try: command.revision(self.cfg, message="some rev") except CommandError as ce: m = re.match( r"^Template rendering failed; see (.+?) " "for a template-oriented", str(ce)) assert m, "Command error did not produce a file" with open(m.group(1)) as handle: contents = handle.read() os.remove(m.group(1)) assert "<% z = x + y %>" in contents
def generate_migration(cfg, message='Initial Version'): # Alembic has a bug with ARRAY type. This is a temporary workaround command.revision(cfg, message='Initial Version', autogenerate=True) result = [] pattern = '_'.join([chunk.lower() for chunk in message.split(' ')]) for root, dirs, files in os.walk('./alembic/versions'): for name in files: if pattern in name: result.append(os.path.join(root, name)) with open(result[0], 'r') as file: filedata = file.read() # Replace the target string filedata = filedata.replace('ARRAY(', 'ARRAY(sa.') # Write the file out again with open(result[0], 'w') as file: file.write(filedata)
def run_revisions(alembic_directory: str, database_path: str = ""): ini_path = os.path.join(alembic_directory, "alembic.ini") script_location = os.path.join(alembic_directory, "alembic") full_database_path = f'sqlite:///{database_path}' alembic_cfg = Config(ini_path) alembic_cfg.set_main_option('script_location', script_location) alembic_cfg.set_main_option('sqlalchemy.url', full_database_path) x = command.upgrade(alembic_cfg, 'head') x = command.revision(alembic_cfg, autogenerate=True, message="content") print
def run_alembic_cmd(self, opt): ''' Logic for running different Alembic commands. ''' from alembic import command as alembic_cmd config = self.get_config() # command consume any number of parameters but first is command name cmd = opt.command.pop(0) # init command needs to point to lux template, not alembic default if cmd == 'init': dirname = config.get_main_option('script_location') # line 63 will be executed in: # https://github.com/zzzeek/alembic/blob/master/alembic/command.py # since we do not use any *.ini file, we simply silence error # about referenced before assignment as it have no negative impact. try: alembic_cmd.init(config, dirname, template='lux') except UnboundLocalError: # pragma nocover pass # merge required two revision name elif cmd == 'merge': if len(opt.command) != 2: raise CommandError('Command %s required revisions id.' % cmd) alembic_cmd.merge(config, opt.command, message=opt.msg, branch_label=opt.branch) elif cmd == 'revision': alembic_cmd.revision(config, message=opt.msg, branch_label=opt.branch) # auto command is a shortcut for `revision --autogenerate` elif cmd == 'auto': alembic_cmd.revision(config, autogenerate=True, message=opt.msg, branch_label=opt.branch) # this commands required revision name, but do not take any message or # branch labels elif cmd in ('show', 'stamp', 'upgrade', 'downgrade'): if len(opt.command) != 1: raise CommandError('Command %s required revision id' % cmd) getattr(alembic_cmd, cmd)(config, *opt.command) else: # execute commands without any additional params getattr(alembic_cmd, cmd)(config)
def migrate(directory=None, message=None, sql=False, head='head', splice=False, branch_label=None, version_path=None, rev_id=None, x_arg=None): """Alias for 'revision --autogenerate'""" config = get_config(directory, opts=['autogenerate'], x_arg=x_arg) command.revision(config, message, autogenerate=True, sql=sql, head=head, splice=splice, branch_label=branch_label, version_path=version_path, rev_id=rev_id)
def revision(self, *_): """ Create a revision, happen current date to revision name. :return: revision result. """ message = datetime.now().strftime("%Y-%m-%d_%H:%M") result = command.revision( self.config, message=message, autogenerate=True ) return result
def test_multiple_dir_chooses_base(self): command.revision(self.cfg, message="x", head="base", version_path=os.path.join(_get_staging_directory(), "model1")) script2 = command.revision(self.cfg, message="y", head="base", version_path=os.path.join( _get_staging_directory(), "model2")) script3 = command.revision(self.cfg, message="y2", head=script2.revision) eq_(os.path.dirname(script3.path), os.path.abspath(os.path.join(_get_staging_directory(), "model2"))) assert os.access(script3.path, os.F_OK)
def revision(directory=None, message=None, autogenerate=False, sql=False, head='head', splice=False, branch_label=None, version_path=None, rev_id=None): """Create a new revision file.""" config = current_app.extensions['migrate'].migrate.get_config(directory) command.revision(config, message, autogenerate=autogenerate, sql=sql, head=head, splice=splice, branch_label=branch_label, version_path=version_path, rev_id=rev_id)
def test_tmpl_args_revision(self): env_file_fixture( """ context.configure(dialect_name='sqlite', template_args={"somearg":"somevalue"}) """ ) script_file_fixture( """ # somearg: ${somearg} revision = ${repr(up_revision)} down_revision = ${repr(down_revision)} """ ) command.revision(self.cfg, message="some rev") script = ScriptDirectory.from_config(self.cfg) rev = script.get_revision("head") with open(rev.path) as f: text = f.read() assert "somearg: somevalue" in text
def simulate_autogenerate(config_path: str) -> t.List[tuple]: """Simulate the `alembic revision --autogenerate` command and return a list of generated operations. """ config = Config(config_path) revisions: t.List[MigrationScript] = [] def process_revision_directives(context, revision, directives): nonlocal revisions revisions = list(directives) # Prevent actually generating a migration directives[:] = [] revision( config=config, autogenerate=True, process_revision_directives=process_revision_directives, ) return list( itertools.chain.from_iterable(op.as_diffs() for script in revisions for op in script.upgrade_ops_list))
def _perform_makemigrations(directory=None, message=None, sql=False, head='head', splice=False, branch_label=None, version_path=None, rev_id=None, x_arg=None): """Alias for 'revision --autogenerate'""" config = current_app.extensions['migrate'].migrate.get_config( directory, opts=['autogenerate'], x_arg=x_arg) command.revision(config, message, autogenerate=True, sql=sql, head=head, splice=splice, branch_label=branch_label, version_path=version_path, rev_id=rev_id)
def revision(args, logger, baseguess): usable_modules, alembic_modules, alembic_config = alembic_setup(logger) from alembic import command if args.init: if args.module not in alembic_modules: print( '{} isn\'t a configured module. You can create revisions on one of these: {}' .format(args.module, ', '.join(alembic_modules))) return command.revision( config=alembic_config, message=args.message, head='base', branch_label=args.module, autogenerate=args.autogenerate, version_path=usable_modules[args.module].alembic['versions']) else: command.revision(config=alembic_config, message=args.message, autogenerate=args.autogenerate, head='{}@head'.format(args.module))
def make_migration(): conn = sql.session() alembic_cfg, script_, context = sql.get_alembic_ctx(conn) message = console.string('Enter a message for the migration') if not message: print('Skipping migration.') return res = command.revision(message=message, autogenerate=True, config=alembic_cfg) print('Generated Migration:', res) print('Finished.')
def test_create_rev_autogen_db_not_up_to_date_multi_heads(self): self._env_fixture() command.revision(self.cfg) rev2 = command.revision(self.cfg) rev3a = command.revision(self.cfg) command.revision(self.cfg, head=rev2.revision, splice=True) command.upgrade(self.cfg, "heads") command.revision(self.cfg, head=rev3a.revision) assert_raises_message(util.CommandError, "Target database is not up to date.", command.revision, self.cfg, autogenerate=True)
def test_create_rev_plain_db_not_up_to_date_multi_heads(self): self._env_fixture() command.revision(self.cfg) rev2 = command.revision(self.cfg) rev3a = command.revision(self.cfg) command.revision(self.cfg, head=rev2.revision, splice=True) command.upgrade(self.cfg, "heads") command.revision(self.cfg, head=rev3a.revision) assert_raises_message( util.CommandError, "Multiple heads are present; please specify the head revision " "on which the new revision should be based, or perform a merge.", command.revision, self.cfg)
def test_autogen(self): self._write_metadata( """ import sqlalchemy as sa m1 = sa.MetaData() m2 = sa.MetaData() m3 = sa.MetaData() target_metadata = {"engine1": m1, "engine2": m2, "engine3": m3} sa.Table('e1t1', m1, sa.Column('x', sa.Integer)) sa.Table('e2t1', m2, sa.Column('y', sa.Integer)) sa.Table('e3t1', m3, sa.Column('z', sa.Integer)) """ ) rev = command.revision( self.cfg, message="some message", autogenerate=True ) with mock.patch.object(rev.module, "op") as op_mock: rev.module.upgrade_engine1() eq_( op_mock.mock_calls[-1], mock.call.create_table('e1t1', mock.ANY) ) rev.module.upgrade_engine2() eq_( op_mock.mock_calls[-1], mock.call.create_table('e2t1', mock.ANY) ) rev.module.upgrade_engine3() eq_( op_mock.mock_calls[-1], mock.call.create_table('e3t1', mock.ANY) ) rev.module.downgrade_engine1() eq_( op_mock.mock_calls[-1], mock.call.drop_table('e1t1') ) rev.module.downgrade_engine2() eq_( op_mock.mock_calls[-1], mock.call.drop_table('e2t1') ) rev.module.downgrade_engine3() eq_( op_mock.mock_calls[-1], mock.call.drop_table('e3t1') )
def cli_db_revision(message, autogenerate, sql, head, splice, branch_label, version_path, rev_id): """ Create a new revision file. """ from modularapi.settings import get_setting alembic_cfg = AlembicConfig("alembic.ini") alembic_cfg.set_main_option("sqlalchemy.url", get_setting().PG_DNS) alembic_cfg.set_main_option("script_location", str(Path() / "db_migrations")) command.revision( config=alembic_cfg, message=message, autogenerate=autogenerate, sql=sql, head=head, splice=splice, branch_label=branch_label, version_path=version_path, rev_id=rev_id, )
def makemigrations(message): if message is None: click.echo( click.style( "Optinal: " "Use -m <msg>, --message=<msg> to give a message string to this migrate script.", fg='yellow')) message = datetime.now().strftime("%Y_%m_%d_%H_%M_%S") models = [m[:-3] for m in os.listdir(MODELS_DIR) if m.endswith(".py")] for model in models: print(f"Loading {model}... ", end="") print(f"\r\t\t\t", end="") try: importlib.import_module(f'{MODELS_DIR}.{model}') click.echo(click.style("loaded", fg='bright_green')) except Exception as err: click.echo(click.style("error", fg='bright_red')) click.echo(click.style(f"↳ {err}", fg='bright_red')) try: cfg = get_alembic_conf() alembic.revision(config=cfg, message=message, autogenerate=True, sql=False, head="head", splice=False, branch_label=None, version_path=None, rev_id=None) except CommandError as err: click.echo(click.style(str(err), fg='bright_red')) if str(err) == "Target database is not up to date.": click.echo( click.style("run \"python bot.py migrate\"", fg='yellow'))
def revision(config, message: Optional[str], autogenerate: bool, sql: bool, head: str, splice: bool, branch_label: Optional[str], version_path: Optional[str], rev_id: Optional[str]): """Create a new revision file.""" bot = Bot(config) directory = os.path.join('yui', 'models', 'migrations') c = Config(os.path.join(directory, 'alembic.ini')) c.set_main_option('script_location', directory) c.set_main_option('sqlalchemy.url', bot.config.DATABASE_URL) c.attributes['Base'] = bot.orm_base command.revision(c, message, autogenerate=autogenerate, sql=sql, head=head, splice=splice, branch_label=branch_label, version_path=version_path, rev_id=rev_id)
def check_no_pending_migrations(): class EmtpyException(Exception): pass class OkException(Exception): pass def raise_if_pending_migrations(migration_context, rev, generated_revisions): if generated_revisions[0].upgrade_ops.is_empty(): raise OkException() else: raise EmtpyException( f'There are changes in the models not reflected in the alembic' f' scripts: {generated_revisions[0].upgrade_ops.as_diffs()}') with contextlib.suppress(OkException): command.revision( alembic_cfg, autogenerate=True, process_revision_directives=raise_if_pending_migrations, )
def migrate(directory=None, message=None, sql=False, head='head', splice=False, branch_label=None, version_path=None, rev_id=None): """Alias for 'revision --autogenerate'""" config = _get_config(directory) if alembic_version >= (0, 7, 0): command.revision(config, message, autogenerate=True, sql=sql, head=head, splice=splice, branch_label=branch_label, version_path=version_path, rev_id=rev_id) else: command.revision(config, message, autogenerate=True, sql=sql)