def _migrate(self, i):
"""
Run migrations.
Args:
i: Migration ID
Returns:
False: when migration ID is not found
"""
migrator = SqliteMigrator(self.db)
if i >= 0:
# Migration 0: Add media file ID and editable message ID
# 2019JAN08
migrate(
migrator.add_column("msglog", "file_id", self.MsgLog.file_id),
migrator.add_column("msglog", "media_type", self.MsgLog.media_type),
migrator.add_column("msglog", "mime", self.MsgLog.mime),
migrator.add_column("msglog", "master_msg_id_alt", self.MsgLog.master_msg_id_alt)
)
# if i == 0:
# # Migration 0: Added Time column in MsgLog table.
# # 2016JUN15
# migrate(migrator.add_column("msglog", "time", DateTimeField(default=datetime.datetime.now, null=True)))
# elif i == 1:
# # Migration 1:
# # Add table: SlaveChatInfo
# # 2017FEB25
# SlaveChatInfo.create_table()
# migrate(migrator.add_column("msglog", "slave_message_id", CharField(default="__none__")))
#
# else:
return False
def db_upgrade(old_version):
migrator = SqliteMigrator(_db)
if old_version < 2:
User_login.create_table()
migrate(
migrator.add_column('clan_member', 'remaining_status',
TextField(null=True)),
migrator.add_column('clan_challenge', 'message',
TextField(null=True)),
migrator.add_column('clan_group', 'boss_lock_type',
IntegerField(default=0)),
migrator.drop_column('user', 'last_save_slot'),
)
if old_version < 3:
migrate(
migrator.drop_column('user', 'auth_cookie'),
migrator.drop_column('user', 'auth_cookie_expire_time'),
)
if old_version < 4:
migrate(
migrator.add_column('user', 'deleted',
BooleanField(default=False)), )
if old_version < 5:
migrate(
migrator.add_column('user', 'must_change_password',
BooleanField(default=True)), )
DB_schema.replace(key='version', value=str(_version)).execute()
def migrate_1_1(db):
logger.warning('Migrating the database from version 1.0 to 1.1')
from playhouse.migrate import migrate, SqliteMigrator
migrator = SqliteMigrator(db)
extra_info = peewee.TextField(null=True)
migrate(migrator.add_column('Desc', 'extra_info', extra_info),
migrator.add_column('Experiment', 'extra_info', extra_info))
return '1.1'
def __update_db_1(db):
migrator = SqliteMigrator(db)
version = IntegerField(default=1)
crc32 = BooleanField(default=False)
migrate(
migrator.add_column('settings', 'version', version),
migrator.add_column('track', 'crc32', crc32),
)
def upgrade():
settings = db.Settings.get()
version = settings.info['version']
migrator = SqliteMigrator(db.database)
if version < '0.2':
migrate(
migrator.add_column('deck', 'info',
sqlite_ext.JSONField(default=dict)),
migrator.add_column('media', 'info',
sqlite_ext.JSONField(default=dict)),
migrator.add_column('model', 'info',
sqlite_ext.JSONField(default=dict)),
migrator.add_column('template', 'info',
sqlite_ext.JSONField(default=dict)),
migrator.add_column('note', 'info',
sqlite_ext.JSONField(default=dict)),
migrator.add_column('card', 'info',
sqlite_ext.JSONField(default=dict)),
migrator.add_column('card', 'last_review', pv.TimestampField()),
)
settings.info['version'] = '0.2'
settings.save()
if version < '0.2.1':
migrate(
migrator.drop_column('card', 'last_review'),
migrator.add_column('card', 'last_review',
pv.DateTimeField(default=datetime.now)),
migrator.drop_column('note', 'modified'),
migrator.add_column('note', 'modified',
pv.DateTimeField(default=datetime.now)))
settings.info['version'] = '0.2.1'
settings.save()
def init_db(con):
db.initialize(con)
db.connect()
db.create_tables([
RepoModel, RepoPassword, BackupProfileModel, SourceDirModel,
ArchiveModel, WifiSettingModel, EventLogModel, SchemaVersion
])
if BackupProfileModel.select().count() == 0:
default_profile = BackupProfileModel(name='Default Profile')
default_profile.save()
# Delete old log entries after 3 months.
three_months_ago = datetime.now() - timedelta(days=180)
EventLogModel.delete().where(EventLogModel.start_time < three_months_ago)
# Migrations
# See http://docs.peewee-orm.com/en/latest/peewee/playhouse.html#schema-migrations
current_schema, created = SchemaVersion.get_or_create(
id=1, defaults={'version': SCHEMA_VERSION})
current_schema.save()
if created or current_schema.version == SCHEMA_VERSION:
return
else:
migrator = SqliteMigrator(con)
if current_schema.version < 4: # version 3 to 4
_apply_schema_update(
current_schema, 4,
migrator.add_column(ArchiveModel._meta.table_name, 'duration',
pw.FloatField(null=True)),
migrator.add_column(ArchiveModel._meta.table_name, 'size',
pw.IntegerField(null=True)))
if current_schema.version < 5:
_apply_schema_update(
current_schema,
5,
migrator.drop_not_null(WifiSettingModel._meta.table_name,
'last_connected'),
)
if current_schema.version < 6:
_apply_schema_update(
current_schema, 6,
migrator.add_column(EventLogModel._meta.table_name, 'repo_url',
pw.CharField(null=True)))
if current_schema.version < 7:
_apply_schema_update(
current_schema, 7,
migrator.rename_column(SourceDirModel._meta.table_name,
'config_id', 'profile_id'),
migrator.drop_column(EventLogModel._meta.table_name, 'profile_id'),
migrator.add_column(EventLogModel._meta.table_name, 'profile',
pw.CharField(null=True)))
def migrate_v1():
ddbb = get_db()
migrator = SqliteMigrator(ddbb)
fecha_entrega_prevista = DateTimeField(formats='%d-%m-%Y %H:%M:%S', null=True)
horas_trabajo_diario = IntegerField(default=8,
db_column='horas_trabajo_diario',
constraints=[Check('horas_trabajo_diario <= 24')])
with ddbb.transaction():
migrate(
migrator.add_column('programacion', 'fecha_entrega_prevista', fecha_entrega_prevista),
migrator.add_column('maquina', 'horas_trabajo_diario', horas_trabajo_diario),
)
actulizado = True
return actulizado
def Migrate(self):
migrator = SqliteMigrator(self._db)
migrate(
migrator.drop_not_null('Contract', 'Account_id'),
migrator.add_column('Address', 'IsWatchOnly',
BooleanField(default=False)),
)
def __update_db_2(db):
migrator = SqliteMigrator(db)
playback_speed = FloatField(default=1.0)
migrate(migrator.add_column('book', 'playback_speed', playback_speed), )
Settings.update(version=2).execute()
def __update_db_4(db):
migrator = SqliteMigrator(db)
last_played = IntegerField(default=0)
migrate(migrator.add_column('book', 'last_played', last_played), )
Settings.update(version=4).execute()
def __update_db_6(db):
migrator = SqliteMigrator(db)
db.create_tables([OfflineCache])
external = BooleanField(default=False)
offline = BooleanField(default=False)
downloaded = BooleanField(default=False)
migrate(migrator.add_column('storage', 'external', external),
migrator.add_column('book', 'offline', offline),
migrator.add_column('book', 'downloaded', downloaded))
Settings.update(version=6).execute()
import shutil
shutil.rmtree(get_cache_dir())
def make_migrate_operations(self, db: _DatabaseSub) -> T.List[Operation]:
migrator = SqliteMigrator(T.cast(pw.SqliteDatabase, db))
ops = [
migrator.add_column("ldaset", "metrics_id",
models.LDASet._meta.columns["metrics_id"])
]
return ops
def update_tables():
migrator = SqliteMigrator(BaseModel._meta.database)
mesh_columns = [
e.name for e in BaseModel._meta.database.get_columns('meshes')
]
if 'switch_time' not in mesh_columns:
migrate(migrator.add_column('meshes', 'switch_time',
Mesh.switch_time), )
def KfpMigrate(database: SqliteDatabase):
tables = database.get_tables()
migrator = SqliteMigrator(database)
if "rpgcharacter" in tables:
columns = database.get_columns("rpgcharacter")
if not KfpMigrator.hasColumn("retired", columns):
retiredField = BooleanField(default=False)
migrate(
migrator.add_column("rpgcharacter", "retired", retiredField)
)
if not KfpMigrator.hasColumn("last_attack", columns):
lastAttackField = DateTimeField(default=datetime.now() + timedelta(days=-1))
migrate(
migrator.add_column("rpgcharacter", "last_attack", lastAttackField)
)
if "member" in tables:
columns = database.get_columns("member")
if not KfpMigrator.hasColumn("token", columns):
tokenField = BigIntegerField(default=100)
migrate(
migrator.add_column("member", 'token', tokenField)
)
if "channel" in tables:
columns = database.get_columns("channel")
if not KfpMigrator.hasColumn("channel_id", columns):
guildIdField = IntegerField(default=-1)
migrate(
migrator.add_column('channel', 'channel_guild_id', guildIdField),
migrator.rename_column('channel', 'channel_discord_id', 'channel_id'),
)
if "item" in tables:
columns = database.get_columns("item")
if KfpMigrator.hasColumn("hidden", columns):
migrate(
migrator.drop_column('item', 'hidden'),
)
if KfpMigrator.hasColumn("buff_type", columns):
migrate(
migrator.drop_column('item', 'buff_type'),
)
if KfpMigrator.hasColumn("buff_value", columns):
migrate(
migrator.drop_column('item', 'buff_value'),
)
if not KfpMigrator.hasColumn("type", columns):
typeField = CharField(default=ItemType.NONE)
migrate(
migrator.add_column('item', 'type', typeField),
)
if not KfpMigrator.hasColumn("buff", columns):
buff = BuffField(default=Buff(BuffType.NONE, 0, -1))
migrate(
migrator.add_column('item', 'buff', buff),
)
if not KfpMigrator.hasColumn("description", columns):
description = CharField(default="")
migrate(
migrator.add_column('item', 'description', description),
)
return True
def _migrate(i: int):
"""
Run migrations.
Args:
i: Migration ID
"""
migrator = SqliteMigrator(database)
if i <= 0:
# Migration 0: Add media file ID and editable message ID
# 2019JAN08
migrate(
migrator.add_column("msglog", "file_id", MsgLog.file_id),
migrator.add_column("msglog", "media_type", MsgLog.media_type),
migrator.add_column("msglog", "mime", MsgLog.mime),
migrator.add_column("msglog", "master_msg_id_alt",
MsgLog.master_msg_id_alt))
if i <= 1:
# Migration 1: Add pickle objects to MsgLog and SlaveChatInfo
# 2019JUL24
migrate(
migrator.add_column("msglog", "pickle", MsgLog.pickle),
migrator.add_column("slavechatinfo", "pickle",
SlaveChatInfo.pickle))
if i <= 2:
# Migration 2: Add column for group ID to slave chat info table
# 2019NOV18
migrate(
migrator.add_column("slavechatinfo", "slave_chat_group_id",
SlaveChatInfo.slave_chat_group_id))
def m_role_column():
"add the role column to player table"
from playhouse.migrate import migrate, SqliteMigrator
from peewee import CharField
from wwbot.db import db
db.connect()
field = CharField(default="")
migrator = SqliteMigrator(db)
migrate(migrator.add_column('player', 'role', field))
def update_db_2():
"""
Update database to v2.
"""
migrator = SqliteMigrator(db)
playback_speed = FloatField(default=1.0)
migrate(migrator.add_column('book', 'playback_speed', playback_speed), )
Settings.update(version=2).execute()
def update_db_4():
"""
Update database to v4.
"""
migrator = SqliteMigrator(db)
last_played = IntegerField(default=0)
migrate(migrator.add_column('book', 'last_played', last_played), )
Settings.update(version=4).execute()
def init_db() -> None:
with db:
db.create_tables([Token, Order])
columns = db.get_columns('token')
column_names = [c.name for c in columns]
migrator = SqliteMigrator(db)
with db.atomic():
if 'effective_buy_price' not in column_names:
migrate(
migrator.add_column('token', 'effective_buy_price',
Token.effective_buy_price))
def migrate_db():
db = get_db()
if isinstance(db, SqliteDatabase):
from timekeeper.models import User
migrator = SqliteMigrator(db)
try:
with db.transaction():
migrate(migrator.add_column('user', 'name', User.name))
except OperationalError as e:
message, *_ = e.args
if 'duplicate column name: name' not in message:
raise
def apply_v2():
db = SqliteDatabase(r"data\results.db")
migrator = SqliteMigrator(db)
points1 = CharField(max_length=100, null=True)
points2 = CharField(max_length=100, null=True)
migrate(
migrator.add_column("shapedistance", "points1", points1),
migrator.add_column("shapedistance", "points2", points2),
migrator.drop_column("shapedistance", "bitmap"),
)
def update_db_6():
"""
"""
migrator = SqliteMigrator(db)
last_played = BooleanField(default=False)
migrate(
migrator.add_column('storage', 'external', last_played),
)
Settings.update(version=6).execute()
def add_column(slef, table, field):
'''
动态添加字段
https://stackoverflow.com/questions/35012012/peewee-adding-columns-on-demand
Args:
slef ([type]): [description]
table ([type]): [description]
field ([type]): [description]
'''
from playhouse.migrate import SqliteMigrator, migrate
migrator = SqliteMigrator(_connect)
migrate(migrator.add_column(table, field.name, field), )
def apply():
database = SqliteDatabase(settings.DATABASE)
migrator = SqliteMigrator(database)
with database.transaction():
database.execute_sql('CREATE TABLE user (pk INTEGER PRIMARY KEY)')
database.execute_sql('CREATE TABLE snippet (pk INTEGER PRIMARY KEY)')
for field in (
User.created_at,
User.updated_at,
User.name,
User.passhash,
Snippet.created_at,
Snippet.updated_at,
Snippet.syntax,
Snippet.raw,
Snippet.html,
):
field.null = True
migrate(
# user table
migrator.add_column('user', 'created_at', User.created_at),
migrator.add_column('user', 'updated_at', User.updated_at),
migrator.add_column('user', 'name', User.name),
migrator.add_column('user', 'passhash', User.passhash),
migrator.add_index('user', ('name', ), True),
migrator.add_index('user', ('updated_at', ), False),
# snippet table
migrator.add_column('snippet', 'created_at', Snippet.created_at),
migrator.add_column('snippet', 'updated_at', Snippet.updated_at),
migrator.add_column('snippet', 'author_id', Snippet.author),
migrator.add_column('snippet', 'name', Snippet.name),
migrator.add_column('snippet', 'syntax', Snippet.syntax),
migrator.add_column('snippet', 'raw', Snippet.raw),
migrator.add_column('snippet', 'html', Snippet.html),
migrator.add_index('snippet', ('updated_at', ), False),
)
class TestMigrations(unittest.TestCase):
def setUp(self):
Food.create_table()
self.migrator = SqliteMigrator(database)
def tearDown(self):
Food.drop_table()
def test_add_column(self):
Food.another_column = CharField(null=True)
migrate(self.migrator.add_column('food', 'another_column', Food.another_column))
# TODO: How to test if another_column now actually exists in both the `food` table as the `foodversioned` table?
def test_drop_column(self):
del Food.is_tasty
migrate(self.migrator.drop_column('food', 'is_tasty'))
def run_migration():
recipes_db = SqliteDatabase(os.path.join(SCRIPT_DIR, '../recipes.db'))
migrator = SqliteMigrator(recipes_db)
new_picture_field = TextField(null=True)
updated_pictures = [(recipe_id, update_picture(picture)) for (
recipe_id,
picture) in recipes_db.execute_sql('SELECT id, picture FROM recipe')]
migrate(
migrator.drop_column('recipe', 'picture'),
migrator.add_column('recipe', 'picture', new_picture_field),
)
for (recipe_id, picture) in updated_pictures:
if picture:
recipes_db.execute_sql('UPDATE recipe SET picture=? WHERE id=?',
(picture, recipe_id))
def _init_db_tables(self, database, additional_tables=None):
database.create_tables([cache.Config, pim.Content, cache.User, cache.JournalEntity,
cache.EntryEntity, cache.UserInfo], safe=True)
if additional_tables:
database.create_tables(additional_tables, safe=True)
db_version = cache.Config.get_or_none()
if db_version is None:
from playhouse.migrate import SqliteMigrator, migrate
# Essentially version 0 so do first migration.
migrator = SqliteMigrator(database)
try:
migrate(
migrator.add_column('journalentity', 'read_only', cache.JournalEntity.read_only),
)
except peewee.OperationalError:
# A hack because we don't have a db config yet.
pass
cache.Config.insert(db_version=1).execute()
def bits():
""" bits, badges, colors, yolo """
migrator = SqliteMigrator(db)
badges = CharField(null=True, default=None)
color = CharField(default="#FFF")
bits = IntegerField(default=0)
sub = BooleanField(default=False)
turbo = BooleanField(default=False)
mod = BooleanField(default=False)
migrate(
migrator.add_column('messages', 'bits', bits),
migrator.add_column('messages', 'badges', badges),
migrator.add_column('messages', 'color', color),
migrator.add_column('messages', 'sub', sub),
migrator.add_column('messages', 'turbo', turbo),
migrator.add_column('messages', 'mod', mod),
)
import os
from decouple import config
from playhouse.migrate import SqliteMigrator, IntegerField, migrate
from playhouse.sqlite_ext import SqliteExtDatabase
from model.revision import Revision
db_path = config('DATABASE_URI',
default=os.path.expanduser('~/botlistbot.sqlite3'))
db = SqliteExtDatabase(db_path)
migrator = SqliteMigrator(db)
revision = IntegerField(default=100)
with db.transaction():
migrate(migrator.add_column('bot', 'revision', revision), )
Revision.create_table(fail_silently=True)
Revision.insert({'nr': 101}).execute()
if self.last_tweet_id == 0:
return None
return Tweet.get(Tweet.tw_id == self.last_tweet_id)
class Tweet(Model):
tw_id = BigIntegerField(unique=True)
known_at = DateTimeField(default=datetime.datetime.now)
text = TextField()
created_at = DateTimeField()
twitter_user = ForeignKeyField(TwitterUser, related_name='tweets')
photo_url = TextField(default='')
@property
def screen_name(self):
return self.twitter_user.screen_name
@property
def name(self):
return self.twitter_user.name
# Migrate photo_url
try:
db = SqliteDatabase('peewee.db')
migrator = SqliteMigrator(db)
migrate(migrator.add_column('tweet', 'photo_url', Tweet.photo_url))
except OperationalError:
pass
def init_db(con=None):
if con is not None:
os.umask(0o0077)
db.initialize(con)
db.connect()
db.create_tables([
RepoModel, RepoPassword, BackupProfileModel, SourceFileModel,
SettingsModel, ArchiveModel, WifiSettingModel, EventLogModel,
SchemaVersion
])
if BackupProfileModel.select().count() == 0:
default_profile = BackupProfileModel(name='Default')
default_profile.save()
# Delete old log entries after 3 months.
three_months_ago = datetime.now() - timedelta(days=180)
EventLogModel.delete().where(EventLogModel.start_time < three_months_ago)
# Migrations
# See http://docs.peewee-orm.com/en/latest/peewee/playhouse.html#schema-migrations
current_schema, created = SchemaVersion.get_or_create(
id=1, defaults={'version': SCHEMA_VERSION})
current_schema.save()
if created or current_schema.version == SCHEMA_VERSION:
pass
else:
migrator = SqliteMigrator(con)
if current_schema.version < 4: # version 3 to 4
_apply_schema_update(
current_schema, 4,
migrator.add_column(ArchiveModel._meta.table_name, 'duration',
pw.FloatField(null=True)),
migrator.add_column(ArchiveModel._meta.table_name, 'size',
pw.IntegerField(null=True)))
if current_schema.version < 5:
_apply_schema_update(
current_schema,
5,
migrator.drop_not_null(WifiSettingModel._meta.table_name,
'last_connected'),
)
if current_schema.version < 6:
_apply_schema_update(
current_schema, 6,
migrator.add_column(EventLogModel._meta.table_name, 'repo_url',
pw.CharField(null=True)))
if current_schema.version < 7:
_apply_schema_update(
current_schema, 7,
migrator.rename_column(SourceFileModel._meta.table_name,
'config_id', 'profile_id'),
migrator.drop_column(EventLogModel._meta.table_name, 'profile_id'),
migrator.add_column(EventLogModel._meta.table_name, 'profile',
pw.CharField(null=True)))
if current_schema.version < 8:
_apply_schema_update(
current_schema, 8,
migrator.add_column(BackupProfileModel._meta.table_name,
'prune_keep_within', pw.CharField(null=True)))
if current_schema.version < 9:
_apply_schema_update(
current_schema,
9,
migrator.add_column(
BackupProfileModel._meta.table_name, 'new_archive_name',
pw.CharField(
default="{hostname}-{profile_slug}-{now:%Y-%m-%dT%H:%M:%S}"
)),
migrator.add_column(
BackupProfileModel._meta.table_name, 'prune_prefix',
pw.CharField(default="{hostname}-{profile_slug}-")),
)
if current_schema.version < 10:
_apply_schema_update(
current_schema,
10,
migrator.add_column(BackupProfileModel._meta.table_name,
'pre_backup_cmd', pw.CharField(default='')),
migrator.add_column(BackupProfileModel._meta.table_name,
'post_backup_cmd', pw.CharField(default='')),
)
if current_schema.version < 11:
_apply_schema_update(current_schema, 11)
for profile in BackupProfileModel:
if profile.compression == 'zstd':
profile.compression = 'zstd,3'
if profile.compression == 'lzma,6':
profile.compression = 'auto,lzma,6'
profile.save()
if current_schema.version < 12:
_apply_schema_update(
current_schema, 12,
migrator.add_column(RepoModel._meta.table_name,
'extra_borg_arguments',
pw.CharField(default='')))
if current_schema.version < 13:
# Migrate ArchiveModel data to new table to remove unique constraint from snapshot_id column.
tables = db.get_tables()
if ArchiveModel.select().count() == 0 and 'snapshotmodel' in tables:
cursor = db.execute_sql('select * from snapshotmodel;')
fields = [
ArchiveModel.id, ArchiveModel.snapshot_id, ArchiveModel.name,
ArchiveModel.repo, ArchiveModel.time, ArchiveModel.duration,
ArchiveModel.size
]
data = [row for row in cursor.fetchall()]
with db.atomic():
size = 1000
for i in range(0, len(data), size):
ArchiveModel.insert_many(data[i:i + size],
fields=fields).execute()
_apply_schema_update(current_schema, 13)
if current_schema.version < 14:
_apply_schema_update(
current_schema, 14,
migrator.add_column(SettingsModel._meta.table_name, 'str_value',
pw.CharField(default='')))
if current_schema.version < 15:
_apply_schema_update(
current_schema, 15,
migrator.add_column(BackupProfileModel._meta.table_name,
'dont_run_on_metered_networks',
pw.BooleanField(default=True)))
if current_schema.version < 16:
_apply_schema_update(
current_schema, 16,
migrator.add_column(SourceFileModel._meta.table_name, 'dir_size',
pw.BigIntegerField(default=-1)),
migrator.add_column(SourceFileModel._meta.table_name,
'dir_files_count',
pw.BigIntegerField(default=-1)),
migrator.add_column(SourceFileModel._meta.table_name, 'path_isdir',
pw.BooleanField(default=False)))
# Create missing settings and update labels. Leave setting values untouched.
for setting in get_misc_settings():
s, created = SettingsModel.get_or_create(key=setting['key'],
defaults=setting)
s.label = setting['label']
s.save()
# Delete old log entries after 3 months.
three_months_ago = datetime.now() - rd(months=3)
EventLogModel.delete().where(EventLogModel.start_time < three_months_ago)
def db_upgrade(old_version):
migrator = SqliteMigrator(_db)
if old_version < 2:
User_login.create_table()
migrate(
migrator.add_column('clan_member', 'remaining_status',
TextField(null=True)),
migrator.add_column('clan_challenge', 'message',
TextField(null=True)),
migrator.add_column('clan_group', 'boss_lock_type',
IntegerField(default=0)),
migrator.drop_column('user', 'last_save_slot'),
)
if old_version < 3:
migrate(
migrator.drop_column('user', 'auth_cookie'),
migrator.drop_column('user', 'auth_cookie_expire_time'),
)
if old_version < 4:
migrate(
migrator.add_column('user', 'deleted',
BooleanField(default=False)), )
if old_version < 5:
migrate(
migrator.add_column('user', 'must_change_password',
BooleanField(default=True)), )
if old_version < 6:
User.update({
User.authority_group: 1
}).where(User.authority_group == 2).execute()
if old_version < 7:
migrate(
migrator.drop_column('clan_challenge', 'comment'),
migrator.add_column('clan_challenge', 'behalf',
IntegerField(null=True)),
migrator.drop_column('clan_subscribe', 'comment'),
migrator.add_column('clan_subscribe', 'message',
TextField(null=True)),
migrator.add_column('clan_group', 'apikey',
CharField(max_length=16, default=rand_string)),
)
if old_version < 8:
migrate(
migrator.add_column('clan_group', 'deleted',
BooleanField(default=False)),
migrator.add_column('clan_group', 'battle_id',
IntegerField(default=0)),
migrator.add_column('clan_challenge', 'bid',
IntegerField(default=0)),
migrator.add_index('clan_challenge', ('bid', 'gid'), False))
DB_schema.replace(key='version', value=str(_version)).execute()
import argparse
from playhouse.migrate import SqliteMigrator, SqliteDatabase, CharField, migrate
parser = argparse.ArgumentParser(description='Migration: add ip_address field to ConnectionInfo.')
parser.add_argument("dbfile")
args = parser.parse_args()
my_db = SqliteDatabase(args.dbfile)
migrator = SqliteMigrator(my_db)
ipfield = CharField(default='')
with my_db.transaction():
migrate(
migrator.add_column('ConnectionInfo', 'ip_address', ipfield),
)
def screen_name(self):
return self.twitter_user.screen_name
@property
def name(self):
return self.twitter_user.name
# Create tables
for t in (TwitterUser, TelegramChat, Tweet, Subscription):
t.create_table(fail_silently=True)
# Migrate new fields. TODO: think of some better migration mechanism
db = SqliteDatabase('peewee.db', timeout=10)
migrator = SqliteMigrator(db)
operations = [
migrator.add_column('tweet', 'photo_url', Tweet.photo_url),
migrator.add_column('twitteruser', 'last_fetched', TwitterUser.last_fetched),
migrator.add_column('telegramchat', 'twitter_request_token', TelegramChat.twitter_request_token),
migrator.add_column('telegramchat', 'twitter_token', TelegramChat.twitter_token),
migrator.add_column('telegramchat', 'twitter_secret', TelegramChat.twitter_secret),
migrator.add_column('telegramchat', 'timezone_name', TelegramChat.timezone_name),
migrator.add_column('telegramchat', 'delete_soon', TelegramChat.delete_soon),
]
for op in operations:
try:
migrate(op)
except OperationalError:
pass
def Migrate(self):
migrator = SqliteMigrator(self._db)
migrate(
migrator.drop_not_null('Contract', 'Account_id'),
migrator.add_column('Address', 'IsWatchOnly', BooleanField(default=False)),
)
list_migrate = [
('License', 'code', CharField(default="")),
('Organization', 'devise', CharField(default="xof")),
('Organization', 'theme', CharField(default="Theme systeme")),
('Organization', 'is_login', BooleanField(default=True)),
('License', 'update_date', DateTimeField(default=NOW))]
try:
from migrations import make_migrate
list_migrate += make_migrate()
except Exception as e:
print(e)
for x, y, z in list_migrate:
try:
migrate(migrator.add_column(x, y, z))
print(x, " : ", y)
except Exception as e:
print(e)
# raise e
class BaseModel(peewee.Model):
class Meta:
database = dbh
@classmethod
def all(cls):
return list(cls.select())
from playhouse.migrate import SqliteMigrator, migrate
import podcli
migrator = SqliteMigrator(podcli.db)
migrate(
migrator.add_column('episodetable', 'summary',
podcli.EpisodeTable.summary))
class Tweet(Model):
tw_id = BigIntegerField(unique=True)
known_at = DateTimeField(default=datetime.datetime.now)
text = TextField()
created_at = DateTimeField()
twitter_user = ForeignKeyField(TwitterUser, related_name="tweets")
photo_url = TextField(default="")
@property
def screen_name(self):
return self.twitter_user.screen_name
@property
def name(self):
return self.twitter_user.name
# Migrate new fields. TODO: think of some better migration mechanism
db = SqliteDatabase("peewee.db")
migrator = SqliteMigrator(db)
operations = [
migrator.add_column("tweet", "photo_url", Tweet.photo_url),
migrator.add_column("twitteruser", "last_fetched", TwitterUser.last_fetched),
]
for op in operations:
try:
migrate(op)
except OperationalError:
pass
