def forward():
comment_author = peewee.CharField(max_length=60, default='')
comment_email = peewee.CharField(max_length=60, default='')
migrator = PostgresqlMigrator(models.DB)
migrate(
migrator.add_column('comment', 'comment_author', comment_author),
migrator.add_column('comment', 'comment_email', comment_email),
)
def forward():
models.DB.create_tables([models.Comment])
comment = peewee.ForeignKeyField(models.Comment,
null=True,
to_field=models.Comment.id)
migrator = PostgresqlMigrator(models.DB)
migrate(migrator.add_column('post', 'comment_id', comment), )
def forward():
models.DB.create_tables([models.Author])
author = peewee.ForeignKeyField(models.Author,
null=True,
to_field=models.Author.id)
migrator = PostgresqlMigrator(models.DB)
migrate(migrator.add_column('post', 'author_id', author), )
def migration_002():
"""Add path length property to instance, so we do not "need" to calculate it on the fly."""
migrator = PostgresqlMigrator(db)
with db.transaction():
migrate(
migrator.add_column(Instance._meta.db_table,
Instance.path_length.db_column,
Instance.path_length))
def migration_001():
"""Add time property to instance, so we do not "need" to calculate median in database."""
migrator = PostgresqlMigrator(db)
with db.transaction():
migrate(
migrator.add_column(Instance._meta.db_table,
Instance.median_time.db_column,
Instance.median_time))
def forward():
models.DB.create_tables([models.Comments])
comments = peewee.ForeignKeyField(
models.Comments, null=True, to_field=models.Comments.id)
migrator = PostgresqlMigrator(models.DB)
migrate(
migrator.add_column('blogpost', 'comments', comments),
)
def forward():
models.DB.create_tables([models.Author])
# models.DB.create_tables([models.Author, models.BlogPost, models.Comment]) #You can also create all tables at once through this method.
author = peewee.ForeignKeyField(models.Author,
null=True,
to_field=models.Author.id)
migrator = PostgresqlMigrator(models.DB)
migrate(migrator.add_column('blogpost', 'author_id', author), )
from playhouse.migrate import migrate, PostgresqlMigrator
from app.models import DATABASE
from app.notes.models import Note
Note.description.default = ''
migrator = PostgresqlMigrator(DATABASE)
migrate(
migrator.add_column('TBL_NOTE', Note.description.db_column,
Note.description))
with db.database.transaction():
Organization.create_table()
default_org = Organization.create(
name="Default",
slug='default',
settings={
Organization.SETTING_GOOGLE_APPS_DOMAINS:
list(GOOGLE_APPS_DOMAIN)
})
column = Group.org
column.default = default_org
migrate(
migrator.add_column('groups', 'org_id', column),
migrator.add_column('events', 'org_id', column),
migrator.add_column('data_sources', 'org_id', column),
migrator.add_column('users', 'org_id', column),
migrator.add_column('dashboards', 'org_id', column),
migrator.add_column('queries', 'org_id', column),
migrator.add_column('query_results', 'org_id', column),
)
# Change the uniqueness constraint on user email to be (org, email):
migrate(migrator.drop_index('users', 'users_email'),
migrator.add_index('users', ('org_id', 'email'), unique=True))
db.close_db(None)
from redash.models import db, Query
from playhouse.migrate import PostgresqlMigrator, migrate
if __name__ == '__main__':
migrator = PostgresqlMigrator(db.database)
with db.database.transaction():
migrate(
migrator.add_column('queries', 'options', Query.options),
)
from redash.models import db, Change, AccessPermission, Query, Dashboard
from playhouse.migrate import PostgresqlMigrator, migrate
if __name__ == '__main__':
if not Change.table_exists():
Change.create_table()
if not AccessPermission.table_exists():
AccessPermission.create_table()
migrator = PostgresqlMigrator(db.database)
try:
migrate(
migrator.add_column('queries', 'version', Query.version),
migrator.add_column('dashboards', 'version', Dashboard.version))
except Exception as ex:
print "Error while adding version column to queries/dashboards. Maybe it already exists?"
print ex
from playhouse.migrate import migrate, PostgresqlMigrator
from app.models import DATABASE
from app.qa.models import Question
migrator = PostgresqlMigrator(DATABASE)
migrate(
migrator.add_column('TBL_QUESTION', Question.datetime.db_column,
Question.datetime))
from playhouse.migrate import migrate, PostgresqlMigrator
from app.models import DATABASE
from app.notes.models import Note
migrator = PostgresqlMigrator(DATABASE)
migrate(migrator.add_column('TBL_NOTE', Note.datetime.db_column,
Note.datetime))
import peewee
from playhouse.migrate import PostgresqlMigrator, migrate
from redash.models import db
from redash import models
if __name__ == '__main__':
db.connect_db()
migrator = PostgresqlMigrator(db.database)
cursor = db.database.execute_sql(
"SELECT column_name FROM information_schema.columns WHERE table_name='alerts' and column_name='rearm';"
)
if cursor.rowcount > 0:
print "Column exists. Skipping."
exit()
with db.database.transaction():
migrate(migrator.add_column('alerts', 'rearm', models.Alert.rearm), )
db.close_db(None)
import peewee
from playhouse.migrate import PostgresqlMigrator, migrate
from redash.models import db
from redash import models
if __name__ == '__main__':
db.connect_db()
migrator = PostgresqlMigrator(db.database)
cursor = db.database.execute_sql("SELECT column_name FROM information_schema.columns WHERE table_name='alerts' and column_name='rearm';")
if cursor.rowcount > 0:
print "Column exists. Skipping."
exit()
with db.database.transaction():
migrate(
migrator.add_column('alerts', 'rearm', models.Alert.rearm),
)
db.close_db(None)
from peewee import ProgrammingError, BooleanField
from playhouse.migrate import migrate, PostgresqlMigrator
from application.models import database
from application.utils import print_tb
migrator = PostgresqlMigrator(database)
try:
sex = BooleanField(default=True)
migrate(migrator.add_column('bot_person', 'sex', sex))
except ProgrammingError as pe:
print_tb(pe)
database.rollback()
except Exception as e:
database.rollback()
from playhouse.migrate import PostgresqlMigrator, migrate
from redash.models import db
from redash import models
if __name__ == "__main__":
db.connect_db()
migrator = PostgresqlMigrator(db.database)
with db.database.transaction():
migrate(migrator.add_column("queries", "last_modified_by_id", models.Query.last_modified_by))
db.database.execute_sql("UPDATE queries SET last_modified_by_id = user_id;")
db.close_db(None)
from playhouse.migrate import PostgresqlMigrator, migrate
from redash.models import db
from redash import models
if __name__ == '__main__':
db.connect_db()
migrator = PostgresqlMigrator(db.database)
with db.database.transaction():
migrate(
migrator.add_column('queries', 'schedule', models.Query.schedule),
)
db.database.execute_sql("UPDATE queries SET schedule = ttl WHERE ttl > 0;")
migrate(
migrator.drop_column('queries', 'ttl')
)
db.close_db(None)
from peewee import PostgresqlDatabase
from playhouse.migrate import PostgresqlMigrator, migrate
from playhouse.postgres_ext import JSONField
db = PostgresqlDatabase('burnthrough',
user="******",
password="******",
host="127.0.0.1",
port=5432)
migrator = PostgresqlMigrator(db)
migrate(
migrator.add_column('usertasktree', 'expanded_nodes',
JSONField(default=[])), )
from playhouse.migrate import PostgresqlMigrator, migrate
from redash.models import db
from redash import models
if __name__ == '__main__':
db.connect_db()
migrator = PostgresqlMigrator(db.database)
with db.database.transaction():
migrate(
migrator.add_column('queries', 'last_modified_by_id', models.Query.last_modified_by)
)
db.database.execute_sql("UPDATE queries SET last_modified_by_id = user_id;")
db.close_db(None)
from redash.models import db, Query
from playhouse.migrate import PostgresqlMigrator, migrate
if __name__ == '__main__':
migrator = PostgresqlMigrator(db.database)
with db.database.transaction():
migrate(migrator.add_column('queries', 'options', Query.options), )
HIPCHAT_ROOM_ID = os.environ.get('REDASH_HIPCHAT_ROOM_ID', None)
WEBHOOK_ENDPOINT = os.environ.get('REDASH_WEBHOOK_ENDPOINT', None)
WEBHOOK_USERNAME = os.environ.get('REDASH_WEBHOOK_USERNAME', None)
WEBHOOK_PASSWORD = os.environ.get('REDASH_WEBHOOK_PASSWORD', None)
if __name__ == '__main__':
migrator = PostgresqlMigrator(db.database)
with db.database.transaction():
if not NotificationDestination.table_exists():
NotificationDestination.create_table()
# Update alert subscription fields
migrate(
migrator.add_column('alert_subscriptions', 'destination_id', AlertSubscription.destination)
)
try:
org = Organization.get_by_slug('default')
user = User.select().where(User.org==org, peewee.SQL("%s = ANY(groups)", org.admin_group.id)).get()
except Exception:
print("!!! Warning: failed finding default organization or admin user, won't migrate Webhook/HipChat alert subscriptions.")
exit()
if WEBHOOK_ENDPOINT:
# Have all existing alerts send to webhook if already configured
schema = get_configuration_schema_for_destination_type('webhook')
conf = {'url': WEBHOOK_ENDPOINT}
if WEBHOOK_USERNAME:
conf['username'] = WEBHOOK_USERNAME
from redash import settings
from redash.models import db, NotificationDestination, AlertSubscription, Alert, Organization, User
from redash.destinations import get_configuration_schema_for_destination_type
from redash.utils.configuration import ConfigurationContainer
from playhouse.migrate import PostgresqlMigrator, migrate
if __name__ == '__main__':
migrator = PostgresqlMigrator(db.database)
with db.database.transaction():
if not NotificationDestination.table_exists():
NotificationDestination.create_table()
# Update alert subscription fields
migrate(
migrator.add_column('alert_subscriptions', 'destination_id', AlertSubscription.destination)
)
try:
org = Organization.get_by_slug('default')
user = User.select().where(User.org==org, peewee.SQL("%s = ANY(groups)", org.admin_group.id)).get()
except Exception:
print "!!! Warning: failed finding default organization or admin user, won't migrate Webhook/HipChat alert subscriptions."
exit()
if settings.WEBHOOK_ENDPOINT:
# Have all existing alerts send to webhook if already configured
schema = get_configuration_schema_for_destination_type('webhook')
conf = {'url': settings.WEBHOOK_ENDPOINT}
if settings.WEBHOOK_USERNAME:
conf['username'] = settings.WEBHOOK_USERNAME
def forward():
category = peewee.CharField(max_length=20, default='')
migrator = PostgresqlMigrator(models.DB)
migrate(migrator.add_column('blogpost', 'category', category), )
from playhouse.migrate import PostgresqlMigrator, migrate
from redash.models import db
from redash import models
if __name__ == '__main__':
db.connect_db()
migrator = PostgresqlMigrator(db.database)
with db.database.transaction():
migrate(
migrator.add_column('queries', 'is_archived', models.Query.is_archived)
)
db.close_db(None)
from playhouse.migrate import PostgresqlMigrator, migrate
from redash.models import db
from redash import models
if __name__ == "__main__":
db.connect_db()
migrator = PostgresqlMigrator(db.database)
with db.database.transaction():
column = models.Group.countries
column.null = True
migrate(migrator.add_column("users", "countries", models.Group.countries))
# for group in models.Group.select():
# group.save()
migrate(migrator.drop_not_null("users", "countries"))
db.close_db(None)
from playhouse.migrate import migrate, PostgresqlMigrator
from app.models import DATABASE
from app.lesson.models import LessonStudent
migrator = PostgresqlMigrator(DATABASE)
LessonStudent.semester.default = 1
LessonStudent.year.default = 2015
migrate(
migrator.add_column('TBL_LESSON_STUDENT', LessonStudent.semester.db_column,
LessonStudent.semester),
migrator.add_column('TBL_LESSON_STUDENT', LessonStudent.year.db_column,
LessonStudent.year),
)
from playhouse.migrate import migrate, PostgresqlMigrator
from app.models import DATABASE
from app.qa.models import Question, Reply
migrator = PostgresqlMigrator(DATABASE)
migrate(
migrator.add_column('TBL_QUESTION', Question.votes.db_column, Question.votes),
migrator.add_column('TBL_REPLY', Reply.votes.db_column, Reply.votes),
)
class Migrate(object):
def __init__(self, rules, func):
self.rules = rules
self.func = func
self.actions = []
self.raw_actions = []
self.m = PostgresqlMigrator(database)
def run(self):
conn = database.obj.connection()
for rule in self.rules:
with conn.cursor() as cur:
if not rule(cur):
return
self.func(self)
self.apply()
def apply(self):
print('Applying {} actions'.format(len(self.actions)))
migrate(*self.actions)
print('Executing {} raw queries'.format(len(self.raw_actions)))
conn = database.obj.connection()
for query, args in self.raw_actions:
with conn.cursor() as cur:
cur.execute(query, args)
conn.commit()
def add_columns(self, table, *fields):
for field in fields:
self.actions.append(
self.m.add_column(table._meta.db_table, field.name, field))
def rename_column(self, table, field, new_name):
self.actions.append(
self.m.rename_column(table._meta.db_table, field.name, new_name))
def drop_not_nulls(self, table, *fields):
for field in fields:
self.actions.append(
self.m.drop_not_null(table._meta.db_table, field.name))
def add_not_nulls(self, table, *fields):
for field in fields:
self.actions.append(
self.m.add_not_null(table._meta.db_table, field.name))
def execute(self, query, params=None):
self.raw_actions.append((query, params or []))
def backfill_column(self,
table,
old_columns,
new_columns,
pkeys=None,
cast_funcs=None):
total = table.select().count()
if not pkeys:
pkeys = [table._meta.primary_key]
q = table.select(*(pkeys + old_columns)).tuples()
idx = 0
modified = 0
start = time.time()
with database.transaction() as txn:
for values in q:
idx += 1
if idx % 10000 == 0:
print('[%ss] Backfilling %s %s/%s (wrote %s)' %
(time.time() - start, str(table), idx, total,
modified))
if modified % 1000:
txn.commit()
obj = {
new_column.name:
cast_funcs[new_column](values[i + len(pkeys)])
if cast_funcs and new_column in cast_funcs else values[i] +
len(pkeys)
for i, new_column in enumerate(new_columns)
}
if not any(obj.values()):
continue
modified += 1
table.update(
**{
new_column.name: values[i + len(pkeys)]
for i, new_column in enumerate(new_columns)
}).where(
reduce(operator.and_,
[(iz == values[i])
for i, iz in enumerate(pkeys)])).execute()
txn.commit()
print('DONE, %s scanned %s written' % (idx, modified))
@staticmethod
def missing(table, field):
def rule(cursor):
cursor.execute(COLUMN_EXISTS_SQL, (table._meta.db_table, field))
if len(cursor.fetchall()) == 0:
return True
return False
return rule
@staticmethod
def nullable(table, field):
def rule(cursor):
cursor.execute(GET_NULLABLE_SQL, (table._meta.db_table, field))
return cursor.fetchone()[0] == 'YES'
return rule
@staticmethod
def non_nullable(table, field):
def rule(cursor):
cursor.execute(GET_NULLABLE_SQL, (table._meta.db_table, field))
return cursor.fetchone()[0] == 'NO'
return rule
@classmethod
def only_if(cls, check, table, *fields):
def deco(func):
rules = [check(table, i) for i in fields]
cls(rules, func).run()
return deco
@classmethod
def always(cls):
def deco(func):
cls([lambda c: True], func).run()
return deco
from playhouse.migrate import PostgresqlMigrator, migrate
from redash.models import db
from redash import models
if __name__ == "__main__":
db.connect_db()
migrator = PostgresqlMigrator(db.database)
with db.database.transaction():
migrate(migrator.add_column("alerts", "rearm", models.Alert.rearm))
db.close_db(None)
from playhouse.migrate import PostgresqlMigrator, migrate
from redash.models import db
from redash import models
if __name__ == '__main__':
db.connect_db()
migrator = PostgresqlMigrator(db.database)
with db.database.transaction():
column = models.User.api_key
column.null = True
migrate(
migrator.add_column('users', 'api_key', models.User.api_key),
)
for user in models.User.select(models.User.id, models.User.api_key):
user.save(only=user.dirty_fields)
migrate(
migrator.add_not_null('users', 'api_key')
)
db.close_db(None)
from playhouse.migrate import PostgresqlMigrator, migrate
from redash.models import db
from redash import models
if __name__ == '__main__':
db.connect_db()
migrator = PostgresqlMigrator(db.database)
with db.database.transaction():
migrate(
migrator.add_column('queries', 'schedule', models.Query.schedule),
)
db.database.execute_sql("UPDATE queries SET schedule = ttl WHERE ttl > 0;")
migrate(
migrator.drop_column('queries', 'ttl')
)
db.close_db(None)
from playhouse.migrate import PostgresqlMigrator, migrate
from redash.models import db
from redash import models
if __name__ == '__main__':
db.connect_db()
migrator = PostgresqlMigrator(db.database)
with db.database.transaction():
migrate(
migrator.add_column('queries', 'is_draft', models.Query.is_draft))
migrate(
migrator.add_column('dashboards', 'is_draft',
models.Query.is_draft))
db.database.execute_sql(
"UPDATE queries SET is_draft = (name = 'New Query')")
db.close_db(None)
from playhouse.migrate import PostgresqlMigrator, migrate
from redash.models import db
from redash import models
if __name__ == '__main__':
db.connect_db()
migrator = PostgresqlMigrator(db.database)
with db.database.transaction():
migrate(
migrator.add_column('queries', 'updated_at',
models.Query.updated_at),
migrator.add_column('dashboards', 'updated_at',
models.Dashboard.updated_at),
migrator.add_column('widgets', 'updated_at',
models.Widget.updated_at),
migrator.add_column('users', 'created_at', models.User.created_at),
migrator.add_column('users', 'updated_at', models.User.updated_at),
migrator.add_column('visualizations', 'created_at',
models.Visualization.created_at),
migrator.add_column('visualizations', 'updated_at',
models.Visualization.updated_at))
db.database.execute_sql("UPDATE queries SET updated_at = created_at;")
db.database.execute_sql(
"UPDATE dashboards SET updated_at = created_at;")
db.database.execute_sql("UPDATE widgets SET updated_at = created_at;")
db.close_db(None)
from playhouse.migrate import PostgresqlMigrator, migrate
from redash.models import db
from redash import models
if __name__ == '__main__':
db.connect_db()
migrator = PostgresqlMigrator(db.database)
with db.database.transaction():
migrate(
migrator.add_column('queries', 'updated_at', models.Query.updated_at),
migrator.add_column('dashboards', 'updated_at', models.Dashboard.updated_at),
migrator.add_column('widgets', 'updated_at', models.Widget.updated_at),
migrator.add_column('users', 'created_at', models.User.created_at),
migrator.add_column('users', 'updated_at', models.User.updated_at),
migrator.add_column('visualizations', 'created_at', models.Visualization.created_at),
migrator.add_column('visualizations', 'updated_at', models.Visualization.updated_at)
)
db.database.execute_sql("UPDATE queries SET updated_at = created_at;")
db.database.execute_sql("UPDATE dashboards SET updated_at = created_at;")
db.database.execute_sql("UPDATE widgets SET updated_at = created_at;")
db.close_db(None)
from playhouse.migrate import migrate, PostgresqlMigrator
from app.models import DATABASE
from app.notes.models import Note
Note.original_filename.default = ''
migrator = PostgresqlMigrator(DATABASE)
migrate(
migrator.add_column('TBL_NOTE', Note.original_filename.db_column,
Note.original_filename))
for note in Note.select():
note.original_filename = note.filename
note.save()
from __future__ import print_function
from redash.models import db, Change, AccessPermission, Query, Dashboard
from playhouse.migrate import PostgresqlMigrator, migrate
if __name__ == '__main__':
if not Change.table_exists():
Change.create_table()
if not AccessPermission.table_exists():
AccessPermission.create_table()
migrator = PostgresqlMigrator(db.database)
try:
migrate(
migrator.add_column('queries', 'version', Query.version),
migrator.add_column('dashboards', 'version', Dashboard.version)
)
except Exception as ex:
print("Error while adding version column to queries/dashboards. Maybe it already exists?")
print(ex)
from playhouse.migrate import PostgresqlMigrator, migrate
from redash.models import db
from redash import models
if __name__ == '__main__':
db.connect_db()
migrator = PostgresqlMigrator(db.database)
with db.database.transaction():
migrate(
migrator.add_column('queries', 'is_draft', models.Query.is_draft)
)
migrate(
migrator.add_column('dashboards', 'is_draft', models.Query.is_draft)
)
db.database.execute_sql("UPDATE queries SET is_draft = (name = 'New Query')")
db.close_db(None)
from playhouse.migrate import PostgresqlMigrator, migrate
from redash.models import db
from redash import models
if __name__ == '__main__':
db.connect_db()
migrator = PostgresqlMigrator(db.database)
with db.database.transaction():
column = models.User.api_key
column.null = True
migrate(migrator.add_column('users', 'api_key', models.User.api_key), )
for user in models.User.select(models.User.id, models.User.api_key):
user.save(only=user.dirty_fields)
migrate(migrator.add_not_null('users', 'api_key'))
db.close_db(None)
from collections import defaultdict
from redash.models import db, DataSourceGroup, DataSource, Group, Organization, User
from playhouse.migrate import PostgresqlMigrator, migrate
import peewee
if __name__ == '__main__':
migrator = PostgresqlMigrator(db.database)
with db.database.transaction():
# Add type to groups
migrate(migrator.add_column('groups', 'type', Group.type))
for name in ['default', 'admin']:
group = Group.get(Group.name == name)
group.type = Group.BUILTIN_GROUP
group.save()
# Create association table between data sources and groups
DataSourceGroup.create_table()
# add default to existing data source:
default_org = Organization.get_by_id(1)
default_group = Group.get(Group.name == "default")
for ds in DataSource.all(default_org):
DataSourceGroup.create(data_source=ds, group=default_group)
# change the groups list on a user object to be an ids list
migrate(migrator.rename_column('users', 'groups', 'old_groups'), )
migrate(migrator.add_column('users', 'groups', User.groups))
def upgrade_db_structure():
"""Upgrade the tables version by version"""
from playhouse.migrate import PostgresqlMigrator, migrate
migrator = PostgresqlMigrator(wapt_db)
logger.info('Current DB: %s version: %s' %
(wapt_db.connect_kwargs, get_db_version()))
# from 1.4.1 to 1.4.2
if get_db_version() < '1.4.2':
with wapt_db.atomic():
logger.info('Migrating from %s to %s' %
(get_db_version(), '1.4.2'))
migrate(
migrator.rename_column(Hosts._meta.name, 'host', 'host_info'),
migrator.rename_column(Hosts._meta.name, 'wapt',
'wapt_status'),
migrator.rename_column(Hosts._meta.name, 'update_status',
'last_update_status'),
migrator.rename_column(Hosts._meta.name, 'softwares',
'installed_softwares'),
migrator.rename_column(Hosts._meta.name, 'packages',
'installed_packages'),
)
HostGroups.create_table(fail_silently=True)
HostJsonRaw.create_table(fail_silently=True)
HostWsus.create_table(fail_silently=True)
(v, created) = ServerAttribs.get_or_create(key='db_version')
v.value = '1.4.2'
v.save()
next_version = '1.4.3'
if get_db_version() < next_version:
with wapt_db.atomic():
logger.info('Migrating from %s to %s' %
(get_db_version(), next_version))
if not [
c.name for c in wapt_db.get_columns('hosts')
if c.name == 'host_certificate'
]:
migrate(
migrator.add_column(Hosts._meta.name, 'host_certificate',
Hosts.host_certificate), )
(v, created) = ServerAttribs.get_or_create(key='db_version')
v.value = next_version
v.save()
next_version = '1.4.3.1'
if get_db_version() < next_version:
with wapt_db.atomic():
logger.info('Migrating from %s to %s' %
(get_db_version(), next_version))
columns = [c.name for c in wapt_db.get_columns('hosts')]
opes = []
if not 'last_logged_on_user' in columns:
opes.append(
migrator.add_column(Hosts._meta.name,
'last_logged_on_user',
Hosts.last_logged_on_user))
if 'installed_sofwares' in columns:
opes.append(
migrator.drop_column(Hosts._meta.name,
'installed_sofwares'))
if 'installed_sofwares' in columns:
opes.append(
migrator.drop_column(Hosts._meta.name,
'installed_packages'))
migrate(*opes)
(v, created) = ServerAttribs.get_or_create(key='db_version')
v.value = next_version
v.save()
next_version = '1.4.3.2'
if get_db_version() < next_version:
with wapt_db.atomic():
logger.info('Migrating from %s to %s' %
(get_db_version(), next_version))
wapt_db.execute_sql('''\
ALTER TABLE hostsoftwares
ALTER COLUMN publisher TYPE character varying(2000),
ALTER COLUMN version TYPE character varying(1000);''')
(v, created) = ServerAttribs.get_or_create(key='db_version')
v.value = next_version
v.save()
next_version = '1.5.0.4'
if get_db_version() < next_version:
with wapt_db.atomic():
logger.info('Migrating from %s to %s' %
(get_db_version(), next_version))
columns = [c.name for c in wapt_db.get_columns('hosts')]
opes = []
if not 'server_uuid' in columns:
opes.append(
migrator.add_column(Hosts._meta.name, 'server_uuid',
Hosts.server_uuid))
migrate(*opes)
(v, created) = ServerAttribs.get_or_create(key='db_version')
v.value = next_version
v.save()
next_version = '1.5.0.11'
if get_db_version() < next_version:
with wapt_db.atomic():
logger.info('Migrating from %s to %s' %
(get_db_version(), next_version))
HostGroups.create_table(fail_silently=True)
(v, created) = ServerAttribs.get_or_create(key='db_version')
v.value = next_version
v.save()
next_version = '1.5.1.1'
if get_db_version() < next_version:
with wapt_db.atomic():
logger.info('Migrating from %s to %s' %
(get_db_version(), next_version))
columns = [c.name for c in wapt_db.get_columns('hosts')]
opes = []
if not 'computer_ad_site' in columns:
opes.append(
migrator.add_column(Hosts._meta.name, 'computer_ad_site',
Hosts.computer_ad_site))
if not 'computer_ad_ou' in columns:
opes.append(
migrator.add_column(Hosts._meta.name, 'computer_ad_ou',
Hosts.computer_ad_ou))
if not 'computer_ad_groups' in columns:
opes.append(
migrator.add_column(Hosts._meta.name, 'computer_ad_groups',
Hosts.computer_ad_groups))
migrate(*opes)
(v, created) = ServerAttribs.get_or_create(key='db_version')
v.value = next_version
v.save()
next_version = '1.5.1.3'
if get_db_version() < next_version:
with wapt_db.atomic():
logger.info('Migrating from %s to %s' %
(get_db_version(), next_version))
columns = [c.name for c in wapt_db.get_columns('hosts')]
opes = []
if not 'registration_auth_user' in columns:
opes.append(
migrator.add_column(Hosts._meta.name,
'registration_auth_user',
Hosts.registration_auth_user))
migrate(*opes)
(v, created) = ServerAttribs.get_or_create(key='db_version')
v.value = next_version
v.save()
next_version = '1.5.1.14'
if get_db_version() < next_version:
with wapt_db.atomic():
logger.info('Migrating from %s to %s' %
(get_db_version(), next_version))
columns = [
c.name for c in wapt_db.get_columns('hostpackagesstatus')
]
opes = []
if not 'depends' in columns:
opes.append(
migrator.add_column(HostPackagesStatus._meta.name,
'depends', HostPackagesStatus.depends))
if not 'conflicts' in columns:
opes.append(
migrator.add_column(HostPackagesStatus._meta.name,
'conflicts',
HostPackagesStatus.conflicts))
migrate(*opes)
(v, created) = ServerAttribs.get_or_create(key='db_version')
v.value = next_version
v.save()
next_version = '1.5.1.17'
if get_db_version() < next_version:
with wapt_db.atomic():
logger.info('Migrating from %s to %s' %
(get_db_version(), next_version))
opes = []
##
migrate(*opes)
WsusScan2History.create_table(fail_silently=True)
(v, created) = ServerAttribs.get_or_create(key='db_version')
v.value = next_version
v.save()
from playhouse.migrate import PostgresqlMigrator, migrate
from redash.models import db
from redash import models
if __name__ == '__main__':
db.connect_db()
migrator = PostgresqlMigrator(db.database)
with db.database.transaction():
migrate(
migrator.add_column('dashboards', 'groups', models.Dashboard.groups)
)
db.close_db(None)
if __name__ == '__main__':
migrator = PostgresqlMigrator(db.database)
with db.database.transaction():
Organization.create_table()
default_org = Organization.create(name="Default", slug='default', settings={
Organization.SETTING_GOOGLE_APPS_DOMAINS: list(settings.GOOGLE_APPS_DOMAIN)
})
column = Group.org
column.default = default_org
migrate(
migrator.add_column('groups', 'org_id', column),
migrator.add_column('events', 'org_id', column),
migrator.add_column('data_sources', 'org_id', column),
migrator.add_column('users', 'org_id', column),
migrator.add_column('dashboards', 'org_id', column),
migrator.add_column('queries', 'org_id', column),
migrator.add_column('query_results', 'org_id', column),
)
# Change the uniqueness constraint on user email to be (org, email):
migrate(
migrator.drop_index('users', 'users_email'),
migrator.add_index('users', ('org_id', 'email'), unique=True)
)
db.close_db(None)
from playhouse.migrate import PostgresqlMigrator, migrate
from redash.models import db
from redash import models
if __name__ == '__main__':
db.connect_db()
migrator = PostgresqlMigrator(db.database)
with db.database.transaction():
column = models.User.parent_user_id
column.null = True
migrate(migrator.add_column('users', 'parent_user_id', models.User.parent_user_id))
# for group in models.Group.select():
# group.save()
migrate(migrator.drop_not_null('users', 'parent_user_id'))
db.close_db(None)
from playhouse.migrate import migrate, PostgresqlMigrator
from app.models import DATABASE
from app.qa.models import Reply
migrator = PostgresqlMigrator(DATABASE)
Reply.content.default = ''
migrate(
migrator.drop_column('TBL_REPLY', Reply.content.db_column),
migrator.add_column('TBL_REPLY', Reply.content.db_column, Reply.content))
from collections import defaultdict
from redash.models import db, DataSourceGroup, DataSource, Group, Organization, User
from playhouse.migrate import PostgresqlMigrator, migrate
import peewee
if __name__ == '__main__':
migrator = PostgresqlMigrator(db.database)
with db.database.transaction():
# Add type to groups
migrate(
migrator.add_column('groups', 'type', Group.type)
)
for name in ['default', 'admin']:
group = Group.get(Group.name==name)
group.type = Group.BUILTIN_GROUP
group.save()
# Create association table between data sources and groups
DataSourceGroup.create_table()
# add default to existing data source:
default_org = Organization.get_by_id(1)
default_group = Group.get(Group.name=="default")
for ds in DataSource.all(default_org):
DataSourceGroup.create(data_source=ds, group=default_group)
# change the groups list on a user object to be an ids list
migrate(
migrator.rename_column('users', 'groups', 'old_groups'),