def migration_v10(db, migrator: SchemaMigrator): with db.atomic(): migrate( migrator.add_column("jamentry", "title", TextField(null=True, default=None)), migrator.add_column("jamentry", "url", CharField(null=True)), )
def _rename_columns(): column_rename = { 'contributors': { 'person_id': 'user_id' }, 'institutionuser': { 'person_id': 'user_id' }, 'instrumentuser': { 'custodian_id': 'user_id' }, 'projectuser': { 'person_id': 'user_id' }, 'transactionuser': { 'authorized_person_id': 'user_id' } } migrator = SchemaMigrator(DB) for table_name, column_tre in column_rename.items(): for old_name, new_name in column_tre.items(): migrate(migrator.rename_column(table_name, old_name, new_name)) old_fkey_name = '_'.join([table_name, old_name, 'fkey']) new_fkey_name = '_'.join([table_name, new_name, 'fkey']) DB.execute_sql('alter table {} rename constraint {} TO {}'.format( table_name, old_fkey_name, new_fkey_name)) old_index_name = '_'.join([table_name, old_name]) new_index_name = '_'.join([table_name, new_name]) DB.execute_sql('alter index {} rename to {}'.format( old_index_name, new_index_name))
def migration_v6(db, migrator: SchemaMigrator): with db.atomic(): migrate( migrator.drop_column("jam", "short_description"), migrator.add_column("jamcriteria", "order", IntegerField(default=0)), )
def upgrade(migrator: SchemaMigrator): expanded_score_field = FloatField(null=True) migrate( migrator.drop_not_null(Karma._meta.db_table, 'score'), migrator.add_column(Karma._meta.db_table, 'expanded_score', expanded_score_field), )
def update_schema(): """Update schema from 2.0 to 2.1.""" DB.execute_sql( 'alter table projects rename constraint proposals_pkey to projects_pkey' ) rename_indexes = { 'atoolproject_proposal_id': 'atoolproject_project_id', 'citationproject_proposal_id': 'citationproject_project_id', 'projectgroup_proposal_id': 'projectgroup_project_id', 'projectinstrument_proposal_id': 'projectinstrument_project_id', 'projectparticipant_proposal_id': 'projectparticipant_project_id', 'proposals_accepted_date': 'projects_accepted_date', 'proposals_actual_end_date': 'projects_actual_end_date', 'proposals_actual_start_date': 'projects_actual_start_date', 'proposals_closed_date': 'projects_closed_date', 'proposals_created': 'projects_created', 'proposals_deleted': 'projects_deleted', 'proposals_short_name': 'projects_short_name', 'proposals_submitted_date': 'projects_submitted_date', 'proposals_suspense_date': 'projects_suspense_date', 'proposals_title': 'projects_title', 'proposals_updated': 'projects_updated', 'transsap_proposal_id': 'transsap_project_id', 'transsip_proposal_id': 'transsip_project_id' } for old_index, new_index in rename_indexes.items(): DB.execute_sql('alter index {} rename to {}'.format( old_index, new_index)) migrator = SchemaMigrator(DB) for table_name in ['transsip', 'transsap']: for col_name in ['created', 'deleted', 'updated']: migrate(migrator.add_index(table_name, (col_name, ), False))
def update_0_0_to_1_0(cls): """Update by creating the table.""" if not IngestState.table_exists(): IngestState.create_table() col_names = [col_md.name for col_md in DB.get_columns('ingeststate')] if 'complete' in col_names: migrator = SchemaMigrator(DB) migrate(migrator.drop_column('ingeststate', 'complete'))
def update_0_1_to_1_0(cls): """Update by adding the boolean column.""" migrator = SchemaMigrator(DB) migrate( migrator.add_column( 'cart', 'bundle', BooleanField(default=False, null=True) ) )
def upgrade(migrator: SchemaMigrator): total_playtime = IntegerField(default=0, null=False) total_donations = IntegerField(default=0, null=False) migrate( migrator.add_column(Player._meta.db_table, 'total_playtime', total_playtime), migrator.add_column(Player._meta.db_table, 'total_donations', total_donations), )
def _rename_column(): table_name = 'usergroup' old_name = 'person_id' new_name = 'user_id' migrator = SchemaMigrator(DB) migrate(migrator.rename_column(table_name, old_name, new_name)) old_fkey_name = '_'.join([table_name, old_name, 'fkey']) new_fkey_name = '_'.join([table_name, new_name, 'fkey']) DB.execute_sql('alter table {} rename constraint {} TO {}'.format( table_name, old_fkey_name, new_fkey_name)) old_index_name = '_'.join([table_name, old_name]) new_index_name = '_'.join([table_name, new_name]) DB.execute_sql('alter index {} rename to {}'.format( old_index_name, new_index_name))
def update_schema(): """Update schema from 3.0 to 4.0.""" migrator = SchemaMigrator(DB) for table_name in ['keys', 'values', 'groups']: migrate( migrator.add_column(table_name, 'display_name', CharField(default='', index=True)), migrator.add_column(table_name, 'description', TextField(default=''))) new_rel_list = [{ 'name': 'upload_required', 'display_name': 'Required for Upload', 'description': 'This relationship means that the objects are required for upload to be asserted.' }, { 'name': 'search_required', 'display_name': 'Required for Search', 'description': 'This relationship means that the objects are required for search to be asserted.' }, { 'name': 'co_principal_investigator', 'display_name': 'Co-Principal Investigator', 'description': 'subject is the co-principal investigator of the object' }] for new_rel in new_rel_list: Relationships.get_or_create(**new_rel) rel_obj = Relationships.get(name='upload_required') migrate( migrator.add_column( 'instrumentkeyvalue', 'relationship_id', ForeignKeyField(Relationships, field=Relationships.uuid, default=rel_obj.uuid))) DB.execute_sql( 'alter table instrumentkeyvalue drop constraint instrumentkeyvalue_pkey' ) DB.execute_sql(''' alter table instrumentkeyvalue add constraint instrumentkeyvalue_pkey primary key (instrument_id, key_id, value_id, relationship_id) ''')
def upgrade(migrator: SchemaMigrator): try: migrate( migrator.drop_index(MapFolder._meta.db_table, 'mapfolder_name'), ) except Exception as e: print(str(e)) print('Migration failed but silencing error!')
def __init__(self, url, bare_fields=False): if isinstance(url, Database): self._url = None self._database = url self._database_path = self._database.database else: self._url = url parse_result = urlparse(url) self._database_path = parse_result.path[1:] # Connect to the database. self._database = connect(url) self._database.connect() # Introspect the database and generate models. self._introspector = Introspector.from_database(self._database) self._models = self._introspector.generate_models( skip_invalid=True, literal_column_names=True, bare_fields=bare_fields) self._migrator = SchemaMigrator.from_database(self._database) class BaseModel(Model): class Meta: database = self._database self._base_model = BaseModel self._export_formats = self.get_export_formats() self._import_formats = self.get_import_formats()
def migrate_schema(db): print("Starting migration") from src.model.models import DatabaseInfo if isinstance(db, Proxy): db = db.obj migrator = SchemaMigrator.from_database(db) if migrator is None: raise Exception("Migrator is broken") info = DatabaseInfo.get_or_none(id=0) if info is None: info = DatabaseInfo.create(id=0, version=0) print("Current database version is %d" % info.version) for i in range(info.version, len(migrations)): print(f"Applying migration v{i+1}") migrations[i](db, migrator) info.version = i + 1 info.save()
def migration_v3(db, migrator: SchemaMigrator): import magic from src.model.models import Content with db.atomic(): migrate( migrator.add_column("content", "mime", CharField(default="")), migrator.add_column("content", "size", BigIntegerField(default=0)), ) query = Content.select() for c in query: c.mime = magic.from_file(c.path, mime=True) c.size = os.stat(c.path).st_size c.save()
def __init__(self, url, include_views=False, **kwargs): if isinstance(url, Database): self._url = None self._database = url self._database_path = self._database.database else: self._url = url parse_result = urlparse(url) self._database_path = parse_result.path[1:] # Connect to the database. self._database = connect(url) # Open a connection if one does not already exist. self._database.connect(reuse_if_open=True) # Introspect the database and generate models. self._introspector = Introspector.from_database(self._database) self._include_views = include_views self._models = self._introspector.generate_models( skip_invalid=True, literal_column_names=True, include_views=self._include_views, **kwargs) self._migrator = SchemaMigrator.from_database(self._database) class BaseModel(Model): class Meta: database = self._database self._base_model = BaseModel self._export_formats = self.get_export_formats() self._import_formats = self.get_import_formats()
def migration_v1(db, migrator: SchemaMigrator): from src.model.models import Post with db.atomic(): migrate( migrator.add_column("post", "has_cut", BooleanField(default=False)), migrator.add_column("post", "cut_name", CharField(default=None, null=True)), ) query = Post.select() for p in query: p.has_cut = "<cut>" in p.text p.save()
def up(self, migrator: SchemaMigrator): Person._meta.database = migrator.database Person.create_table() return [ migrator.add_column('sample_person_table', 'test1', CharField(default='sample_test2_value')), migrator.add_column('sample_person_table', 'test2', CharField(default='sample_test2_value')) ]
def _rename_tables(): table_rename = { 'institutionperson': 'institutionuser', 'instrumentcustodian': 'instrumentuser', 'projectparticipant': 'projectuser', 'transactionrelease': 'transactionuser' } migrator = SchemaMigrator(DB) for old_table, new_table in table_rename.items(): migrate(migrator.rename_table(old_table, new_table)) for index_meta in DB.get_indexes(new_table): new_index_name = '{}{}'.format(new_table, index_meta.name[len(old_table):]) DB.execute_sql('alter index {} rename to {}'.format(index_meta.name, new_index_name)) for fkey_meta in DB.get_foreign_keys(new_table): old_name = '_'.join([old_table, fkey_meta.column, 'fkey']) new_name = '_'.join([new_table, fkey_meta.column, 'fkey']) DB.execute_sql('alter table {} rename constraint {} TO {}'.format(new_table, old_name, new_name))
def __init__(self, database): if isinstance(database, pw.Proxy): database = database.obj self.database = database self.orm = dict() self.ops = list() self.migrator = SchemaMigrator.from_database(self.database)
def main(): for cls in models.Category, models.Feed, models.Entry: try: cls.create_table() except peewee.OperationalError as ex: print ex migrator = SchemaMigrator(models.DATABASE) try: try: migrate(migrator.drop_index('entry_feed_id_published_at')) except: pass migrate(migrator.add_index('entry', ('feed_id', 'published_at'), False)) except peewee.OperationalError as ex: print ex
def migration_v13(db, migrator: SchemaMigrator): with db.atomic(): migrate( migrator.add_column("comment", "object_type", CharField(null=True)), migrator.add_column("comment", "object_id", IntegerField(default=0)), ) from src.model.models import Comment for c in Comment.select(): c.object_type = "post" c.object_id = c.post.id c.save() migrate( # migrator.drop_foreign_key_constraint("comment", "post"), migrator.drop_column("comment", "post_id"), )
def test_fk_migration(self): migrator = SchemaMigrator.from_database(self.database) migrate( migrator.drop_column(FKMB._meta.table_name, FKMB.fkma.column_name)) migrate( migrator.add_column(FKMB._meta.table_name, FKMB.fkma.column_name, FKMB.fkma)) fa = FKMA.create(name='fa') FKMB.create(name='fb', fkma=fa) obj = FKMB.select().first() self.assertEqual(obj.name, 'fb')
def migration_v9(db, migrator: SchemaMigrator): from src.model.models import Jam with db.atomic(): migrate( migrator.add_column( "jamentry", "jam_id", ForeignKeyField(Jam, Jam.id, default=None, null=True, index=False), ), )
def migration_v4(db, migrator: SchemaMigrator): from src.model.models import Token with db.atomic(): migrate( migrator.add_column("token", "token_type", CharField(default="")), ) query = Token.select() for t in query: if t.is_refresh_token: t.token_type = "refresh" else: t.token_type = "access" t.save()
def __init__(self, url): self._url = url parse_result = urlparse(url) self._database_path = parse_result.path[1:] # Connect to the database. self._database = connect(url) self._database.connect() # Introspect the database and generate models. self._introspector = Introspector.from_database(self._database) self._models = self._introspector.generate_models() self._migrator = SchemaMigrator.from_database(self._database) class BaseModel(Model): class Meta: database = self._database self._base_model = BaseModel self._export_formats = self.get_export_formats()
def __init__(self, url): self._url = url parse_result = urlparse(url) self._database_path = parse_result.path[1:] # Connect to the database. self._database = connect(url) self._database.connect() # Introspect the database and generate models. self._introspector = Introspector.from_database(self._database) self._models = self._introspector.generate_models(skip_invalid=True) self._migrator = SchemaMigrator.from_database(self._database) class BaseModel(Model): class Meta: database = self._database self._base_model = BaseModel self._export_formats = self.get_export_formats() self._import_formats = self.get_import_formats()
def update_0_1_to_1_0(cls): """Update from 0.1 to 1.0.""" migrator = SchemaMigrator(DB) TransSIP.create_table() TransSAP.create_table() class OldTrans(Model): """This is the old transactions.""" submitter = ForeignKeyField(Users, backref='transactions') instrument = ForeignKeyField(Instruments, backref='transactions') proposal = ForeignKeyField(Proposals, backref='transactions') created = DateTimeField() updated = DateTimeField() deleted = DateTimeField(null=True) class Meta(object): """This is the meta class for OldTrans.""" database = DB table_name = 'transactions' migrate( migrator.add_column('transactions', 'description', TextField(null=True))) for old_trans in OldTrans.select(): transsip = TransSIP() for attr in [ 'submitter', 'instrument', 'proposal', 'created', 'updated', 'deleted' ]: setattr(transsip, attr, getattr(old_trans, attr)) setattr(transsip, 'id', Transactions.get(Transactions.id == old_trans.id)) transsip.save(force_insert=True) migrate(migrator.drop_column('transactions', 'submitter_id'), migrator.drop_column('transactions', 'instrument_id'), migrator.drop_column('transactions', 'proposal_id'))
def update_schema(): """Update from 0.1 to 1.0.""" migrator = SchemaMigrator(DB) OldTransSIP.create_table() OldTransSAP.create_table() migrate( migrator.add_column('transactions', 'description', TextField(null=True))) for old_trans in OldTrans.select(): transsip = OldTransSIP() for attr in [ 'submitter', 'instrument', 'proposal', 'created', 'updated', 'deleted' ]: setattr(transsip, attr, getattr(old_trans, attr)) setattr(transsip, 'id', Transactions.get(Transactions.id == old_trans.id)) transsip.save(force_insert=True) migrate(migrator.drop_column('transactions', 'submitter_id'), migrator.drop_column('transactions', 'instrument_id'), migrator.drop_column('transactions', 'proposal_id'))
def commands(migrator: SchemaMigrator): migrate(migrator.add_column("ingredient", "calories", peewee.FloatField(default=0)))
def __init__(self, database): self.database = database self.migrator = SchemaMigrator.from_database(self.database) self.models = []
def upgrade(migrator: SchemaMigrator): migrate( migrator.add_column(TestModel._meta.db_table, 'sample', sample_field))
def __init__(self, db: Database, migration_path: str = 'migrations'): self.db = db self.migrator = SchemaMigrator.from_database(self.db) MigrationModel._meta.database = db __import__(migration_path, locals=locals(), globals=globals())
def update_1_0_to_2_0(cls): """Update by adding the auth column.""" migrator = SchemaMigrator(DB) migrate(migrator.add_column('eventmatch', 'auth', TextField(null=True)))
def migrate(db): migrator = SchemaMigrator.from_database(db) from database import model_factory models = model_factory(db) migrate_001(migrator, models)
def __init__(self, db): self.db = db self.migrator = SchemaMigrator.from_database(self.db)