opensource/galaxy
3
0
Fork 0
mirror of https://github.com/galaxyproject/galaxy.git synced 2026-09-24 16:30:27 +08:00
Code Issues Packages Projects Releases Wiki Activity

Another round of migration refactoring

Browse Source 
Allow `table` to be a string in `drop_table()`.

Sync definition of `form_definition` and `form_definition_current` tables
between migration 8 and `mapping.py` .

Drop unnecessary logging configurations.
This commit is contained in:
Nicola Soranzo
2019-08-18 11:17:35 +01:00
parent d5633f6285
commit 4ece752ebe
73 changed files with 1136 additions and 1548 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/galaxy/model/mapping.py
+1 -2
View File
@@ -1161,8 +1161,7 @@ model.FormDefinition.table = Table(
Column("update_time", DateTime, default=now, onupdate=now),
Column("name", TrimmedString(255), nullable=False),
Column("desc", TEXT),
Column("form_definition_current_id", Integer,
ForeignKey("form_definition_current.id", name='for_def_form_def_current_id_fk', use_alter=True), index=True),
Column("form_definition_current_id", Integer, ForeignKey("form_definition_current.id", use_alter=True), index=True, nullable=False),
Column("fields", JSONType()),
Column("type", TrimmedString(255), index=True),
Column("layout", JSONType()))
lib/galaxy/model/migrate/versions/0001_initial_tables.py
+21 -3
View File
@@ -1,13 +1,30 @@
from __future__ import print_function
import datetime
import logging
from sqlalchemy import Boolean, Column, DateTime, ForeignKey, Integer, MetaData, Numeric, String, Table, TEXT
from sqlalchemy import (
Boolean,
Column,
DateTime,
ForeignKey,
Integer,
MetaData,
Numeric,
String,
Table,
TEXT
)
# Need our custom types, but don't import anything else from model
from galaxy.model.custom_types import JSONType, MetadataType, TrimmedString
from galaxy.model.custom_types import (
JSONType,
MetadataType,
TrimmedString
)
now = datetime.datetime.utcnow
log = logging.getLogger(__name__)
now = datetime.datetime.utcnow
metadata = MetaData()
# Tables as of changeset 1464:c7acaa1bb88f
@@ -197,5 +214,6 @@ StoredWorkflowMenuEntry_table = Table("stored_workflow_menu_entry", metadata,
def upgrade(migrate_engine):
print(__doc__)
metadata.bind = migrate_engine
metadata.create_all()
lib/galaxy/model/migrate/versions/0002_metadata_file_table.py
+18 -3
View File
@@ -1,14 +1,28 @@
"""
"""
from __future__ import print_function
import datetime
import logging
from sqlalchemy import Boolean, Column, DateTime, ForeignKey, Integer, MetaData, Table, TEXT
from sqlalchemy import (
Boolean,
Column,
DateTime,
ForeignKey,
Integer,
MetaData,
Table,
TEXT
)
from galaxy.model.migrate.versions.util import create_table, drop_table
from galaxy.model.migrate.versions.util import (
create_table,
drop_table
)
now = datetime.datetime.utcnow
log = logging.getLogger(__name__)
now = datetime.datetime.utcnow
metadata = MetaData()
# New table in changeset 1568:0b022adfdc34
@@ -23,6 +37,7 @@ MetadataFile_table = Table("metadata_file", metadata,
def upgrade(migrate_engine):
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
lib/galaxy/model/migrate/versions/0003_security_and_libraries.py
+114 -305
View File
@@ -1,32 +1,42 @@
"""
"""
from __future__ import print_function
import datetime
import logging
import sys
from migrate import ForeignKeyConstraint
from sqlalchemy import Boolean, Column, DateTime, ForeignKey, Index, Integer, MetaData, String, Table, TEXT
from sqlalchemy.exc import NoSuchTableError
from sqlalchemy import (
Boolean,
Column,
DateTime,
ForeignKey,
Index,
Integer,
MetaData,
String,
Table,
TEXT
)
from galaxy.model.custom_types import JSONType, MetadataType, TrimmedString
from galaxy.model.custom_types import (
JSONType,
MetadataType,
TrimmedString
)
from galaxy.model.migrate.versions.util import (
add_column,
add_index,
drop_column,
drop_index,
drop_table,
engine_false,
localtimestamp,
nextval
)
now = datetime.datetime.utcnow
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
now = datetime.datetime.utcnow
metadata = MetaData()
# New tables as of changeset 2341:5498ac35eedd
@@ -314,108 +324,57 @@ Index("ix_jeom_library_dataset_dataset_association_id", JobExternalOutputMetadat
def upgrade(migrate_engine):
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
# Add 2 new columns to the galaxy_user table
try:
User_table = Table("galaxy_user", metadata, autoload=True)
except NoSuchTableError:
User_table = None
log.debug("Failed loading table galaxy_user")
if User_table is not None:
col = Column('deleted', Boolean, index=True, default=False)
add_column(col, User_table, index_name='ix_galaxy_user_deleted')
col = Column('purged', Boolean, index=True, default=False)
add_column(col, User_table, index_name='ix_galaxy_user_purged')
User_table = Table("galaxy_user", metadata, autoload=True)
col = Column('deleted', Boolean, index=True, default=False)
add_column(col, User_table, index_name='ix_galaxy_user_deleted')
col = Column('purged', Boolean, index=True, default=False)
add_column(col, User_table, index_name='ix_galaxy_user_purged')
# Add 1 new column to the history_dataset_association table
try:
HistoryDatasetAssociation_table = Table("history_dataset_association", metadata, autoload=True)
except NoSuchTableError:
HistoryDatasetAssociation_table = None
log.debug("Failed loading table history_dataset_association")
if HistoryDatasetAssociation_table is not None:
try:
col = Column('copied_from_library_dataset_dataset_association_id', Integer, nullable=True)
col.create(HistoryDatasetAssociation_table)
assert col is HistoryDatasetAssociation_table.c.copied_from_library_dataset_dataset_association_id
except Exception:
log.exception("Adding column 'copied_from_library_dataset_dataset_association_id' to history_dataset_association table failed.")
HistoryDatasetAssociation_table = Table("history_dataset_association", metadata, autoload=True)
col = Column('copied_from_library_dataset_dataset_association_id', Integer, nullable=True)
add_column(col, HistoryDatasetAssociation_table, metadata)
# Add 1 new column to the metadata_file table
try:
MetadataFile_table = Table("metadata_file", metadata, autoload=True)
except NoSuchTableError:
MetadataFile_table = None
log.debug("Failed loading table metadata_file")
if MetadataFile_table is not None:
try:
col = Column('lda_id', Integer, index=True, nullable=True)
col.create(MetadataFile_table, index_name='ix_metadata_file_lda_id')
assert col is MetadataFile_table.c.lda_id
except Exception:
log.exception("Adding column 'lda_id' to metadata_file table failed.")
MetadataFile_table = Table("metadata_file", metadata, autoload=True)
col = Column('lda_id', Integer, index=True, nullable=True)
add_column(col, MetadataFile_table, metadata, index_name='ix_metadata_file_lda_id')
# Add 1 new column to the stored_workflow table - changeset 2328
try:
StoredWorkflow_table = Table("stored_workflow", metadata,
Column("latest_workflow_id", Integer,
ForeignKey("workflow.id", use_alter=True, name='stored_workflow_latest_workflow_id_fk'), index=True),
autoload=True, extend_existing=True)
except NoSuchTableError:
StoredWorkflow_table = None
log.debug("Failed loading table stored_workflow")
if StoredWorkflow_table is not None:
try:
col = Column('importable', Boolean, default=False)
col.create(StoredWorkflow_table)
assert col is StoredWorkflow_table.c.importable
except Exception:
log.exception("Adding column 'importable' to stored_workflow table failed.")
StoredWorkflow_table = Table("stored_workflow", metadata,
Column("latest_workflow_id", Integer,
ForeignKey("workflow.id", use_alter=True, name='stored_workflow_latest_workflow_id_fk'), index=True),
autoload=True, extend_existing=True)
col = Column('importable', Boolean, default=False)
add_column(col, StoredWorkflow_table, metadata)
# Create an index on the Job.state column - changeset 2192
add_index('ix_job_state', 'job', 'state', metadata)
# Add all of the new tables above
metadata.create_all()
# Add 1 foreign key constraint to the history_dataset_association table
LibraryDatasetDatasetAssociation_table = Table("library_dataset_dataset_association", metadata, autoload=True)
try:
HistoryDatasetAssociation_table = Table("history_dataset_association", metadata, autoload=True)
except NoSuchTableError:
HistoryDatasetAssociation_table = None
log.debug("Failed loading table history_dataset_association")
try:
LibraryDatasetDatasetAssociation_table = Table("library_dataset_dataset_association", metadata, autoload=True)
except NoSuchTableError:
LibraryDatasetDatasetAssociation_table = None
log.debug("Failed loading table library_dataset_dataset_association")
if HistoryDatasetAssociation_table is not None and LibraryDatasetDatasetAssociation_table is not None:
cons = ForeignKeyConstraint([HistoryDatasetAssociation_table.c.copied_from_library_dataset_dataset_association_id],
[LibraryDatasetDatasetAssociation_table.c.id],
name='history_dataset_association_copied_from_library_dataset_da_fkey')
# Create the constraint
cons.create()
except Exception:
log.exception("Adding foreign key constraint 'history_dataset_association_copied_from_library_dataset_da_fkey' to table 'history_dataset_association' failed.")
# Add 1 foreign key constraint to the metadata_file table
LibraryDatasetDatasetAssociation_table = Table("library_dataset_dataset_association", metadata, autoload=True)
if migrate_engine.name != 'sqlite':
# Sqlite can't alter table add foreign key.
try:
cons = ForeignKeyConstraint([HistoryDatasetAssociation_table.c.copied_from_library_dataset_dataset_association_id],
cons = ForeignKeyConstraint([MetadataFile_table.c.lda_id],
[LibraryDatasetDatasetAssociation_table.c.id],
name='history_dataset_association_copied_from_library_dataset_da_fkey')
name='metadata_file_lda_id_fkey')
# Create the constraint
cons.create()
except Exception:
log.exception("Adding foreign key constraint 'history_dataset_association_copied_from_library_dataset_da_fkey' to table 'history_dataset_association' failed.")
# Add 1 foreign key constraint to the metadata_file table
try:
MetadataFile_table = Table("metadata_file", metadata, autoload=True)
except NoSuchTableError:
MetadataFile_table = None
log.debug("Failed loading table metadata_file")
try:
LibraryDatasetDatasetAssociation_table = Table("library_dataset_dataset_association", metadata, autoload=True)
except NoSuchTableError:
LibraryDatasetDatasetAssociation_table = None
log.debug("Failed loading table library_dataset_dataset_association")
if migrate_engine.name != 'sqlite':
# Sqlite can't alter table add foreign key.
if MetadataFile_table is not None and LibraryDatasetDatasetAssociation_table is not None:
try:
cons = ForeignKeyConstraint([MetadataFile_table.c.lda_id],
[LibraryDatasetDatasetAssociation_table.c.id],
name='metadata_file_lda_id_fkey')
# Create the constraint
cons.create()
except Exception:
log.exception("Adding foreign key constraint 'metadata_file_lda_id_fkey' to table 'metadata_file' failed.")
log.exception("Adding foreign key constraint 'metadata_file_lda_id_fkey' to table 'metadata_file' failed.")
# Make sure we have at least 1 user
cmd = "SELECT * FROM galaxy_user;"
users = migrate_engine.execute(cmd).fetchall()
@@ -505,222 +464,72 @@ def downgrade(migrate_engine):
# NOTE: all new data added in the upgrade method is eliminated here via table drops
# Drop 1 foreign key constraint from the metadata_file table
MetadataFile_table = Table("metadata_file", metadata, autoload=True)
LibraryDatasetDatasetAssociation_table = Table("library_dataset_dataset_association", metadata, autoload=True)
try:
MetadataFile_table = Table("metadata_file", metadata, autoload=True)
except NoSuchTableError:
MetadataFile_table = None
log.debug("Failed loading table metadata_file")
try:
LibraryDatasetDatasetAssociation_table = Table("library_dataset_dataset_association", metadata, autoload=True)
except NoSuchTableError:
LibraryDatasetDatasetAssociation_table = None
log.debug("Failed loading table library_dataset_dataset_association")
if MetadataFile_table is not None and LibraryDatasetDatasetAssociation_table is not None:
try:
cons = ForeignKeyConstraint([MetadataFile_table.c.lda_id],
[LibraryDatasetDatasetAssociation_table.c.id],
name='metadata_file_lda_id_fkey')
# Drop the constraint
cons.drop()
except Exception:
log.exception("Dropping foreign key constraint 'metadata_file_lda_id_fkey' from table 'metadata_file' failed.")
cons = ForeignKeyConstraint([MetadataFile_table.c.lda_id],
[LibraryDatasetDatasetAssociation_table.c.id],
name='metadata_file_lda_id_fkey')
# Drop the constraint
cons.drop()
except Exception:
log.exception("Dropping foreign key constraint 'metadata_file_lda_id_fkey' from table 'metadata_file' failed.")
# Drop 1 foreign key constraint from the history_dataset_association table
HistoryDatasetAssociation_table = Table("history_dataset_association", metadata, autoload=True)
LibraryDatasetDatasetAssociation_table = Table("library_dataset_dataset_association", metadata, autoload=True)
try:
HistoryDatasetAssociation_table = Table("history_dataset_association", metadata, autoload=True)
except NoSuchTableError:
HistoryDatasetAssociation_table = None
log.debug("Failed loading table history_dataset_association")
try:
LibraryDatasetDatasetAssociation_table = Table("library_dataset_dataset_association", metadata, autoload=True)
except NoSuchTableError:
LibraryDatasetDatasetAssociation_table = None
log.debug("Failed loading table library_dataset_dataset_association")
if HistoryDatasetAssociation_table is not None and LibraryDatasetDatasetAssociation_table is not None:
try:
cons = ForeignKeyConstraint([HistoryDatasetAssociation_table.c.copied_from_library_dataset_dataset_association_id],
[LibraryDatasetDatasetAssociation_table.c.id],
name='history_dataset_association_copied_from_library_dataset_da_fkey')
# Drop the constraint
cons.drop()
except Exception:
log.exception("Dropping foreign key constraint 'history_dataset_association_copied_from_library_dataset_da_fkey' from table 'history_dataset_association' failed.")
cons = ForeignKeyConstraint([HistoryDatasetAssociation_table.c.copied_from_library_dataset_dataset_association_id],
[LibraryDatasetDatasetAssociation_table.c.id],
name='history_dataset_association_copied_from_library_dataset_da_fkey')
# Drop the constraint
cons.drop()
except Exception:
log.exception("Dropping foreign key constraint 'history_dataset_association_copied_from_library_dataset_da_fkey' from table 'history_dataset_association' failed.")
# Drop all of the new tables above
try:
UserGroupAssociation_table.drop()
except Exception:
log.exception("Dropping user_group_association table failed.")
try:
UserRoleAssociation_table.drop()
except Exception:
log.exception("Dropping user_role_association table failed.")
try:
GroupRoleAssociation_table.drop()
except Exception:
log.exception("Dropping group_role_association table failed.")
try:
Group_table.drop()
except Exception:
log.exception("Dropping galaxy_group table failed.")
try:
DatasetPermissions_table.drop()
except Exception:
log.exception("Dropping dataset_permissions table failed.")
try:
LibraryPermissions_table.drop()
except Exception:
log.exception("Dropping library_permissions table failed.")
try:
LibraryFolderPermissions_table.drop()
except Exception:
log.exception("Dropping library_folder_permissions table failed.")
try:
LibraryDatasetPermissions_table.drop()
except Exception:
log.exception("Dropping library_dataset_permissions table failed.")
try:
LibraryDatasetDatasetAssociationPermissions_table.drop()
except Exception:
log.exception("Dropping library_dataset_dataset_association_permissions table failed.")
try:
LibraryItemInfoPermissions_table.drop()
except Exception:
log.exception("Dropping library_item_info_permissions table failed.")
try:
LibraryItemInfoTemplatePermissions_table.drop()
except Exception:
log.exception("Dropping library_item_info_template_permissions table failed.")
try:
DefaultUserPermissions_table.drop()
except Exception:
log.exception("Dropping default_user_permissions table failed.")
try:
DefaultHistoryPermissions_table.drop()
except Exception:
log.exception("Dropping default_history_permissions table failed.")
try:
Role_table.drop()
except Exception:
log.exception("Dropping role table failed.")
try:
LibraryDatasetDatasetInfoAssociation_table.drop()
except Exception:
log.exception("Dropping library_dataset_dataset_info_association table failed.")
try:
LibraryDataset_table.drop()
except Exception:
log.exception("Dropping library_dataset table failed.")
try:
LibraryDatasetDatasetAssociation_table.drop()
except Exception:
log.exception("Dropping library_dataset_dataset_association table failed.")
try:
LibraryDatasetDatasetInfoTemplateAssociation_table.drop()
except Exception:
log.exception("Dropping library_dataset_dataset_info_template_association table failed.")
try:
JobExternalOutputMetadata_table.drop()
except Exception:
log.exception("Dropping job_external_output_metadata table failed.")
try:
Library_table.drop()
except Exception:
log.exception("Dropping library table failed.")
try:
LibraryFolder_table.drop()
except Exception:
log.exception("Dropping library_folder table failed.")
try:
LibraryItemInfoTemplateElement_table.drop()
except Exception:
log.exception("Dropping library_item_info_template_element table failed.")
try:
LibraryInfoTemplateAssociation_table.drop()
except Exception:
log.exception("Dropping library_info_template_association table failed.")
try:
LibraryFolderInfoTemplateAssociation_table.drop()
except Exception:
log.exception("Dropping library_folder_info_template_association table failed.")
try:
LibraryDatasetInfoTemplateAssociation_table.drop()
except Exception:
log.exception("Dropping library_dataset_info_template_association table failed.")
try:
LibraryInfoAssociation_table.drop()
except Exception:
log.exception("Dropping library_info_association table failed.")
try:
LibraryFolderInfoAssociation_table.drop()
except Exception:
log.exception("Dropping library_folder_info_association table failed.")
try:
LibraryDatasetInfoAssociation_table.drop()
except Exception:
log.exception("Dropping library_dataset_info_association table failed.")
try:
LibraryItemInfoElement_table.drop()
except Exception:
log.exception("Dropping library_item_info_element table failed.")
try:
LibraryItemInfo_table.drop()
except Exception:
log.exception("Dropping library_item_info table failed.")
try:
LibraryItemInfoTemplate_table.drop()
except Exception:
log.exception("Dropping library_item_info_template table failed.")
TABLES = [
UserGroupAssociation_table,
UserRoleAssociation_table,
GroupRoleAssociation_table,
Group_table,
DatasetPermissions_table,
LibraryPermissions_table,
LibraryFolderPermissions_table,
LibraryDatasetPermissions_table,
LibraryDatasetDatasetAssociationPermissions_table,
LibraryItemInfoPermissions_table,
LibraryItemInfoTemplatePermissions_table,
DefaultUserPermissions_table,
DefaultHistoryPermissions_table,
Role_table,
LibraryDatasetDatasetInfoAssociation_table,
LibraryDataset_table,
LibraryDatasetDatasetAssociation_table,
LibraryDatasetDatasetInfoTemplateAssociation_table,
JobExternalOutputMetadata_table,
Library_table,
LibraryFolder_table,
LibraryItemInfoTemplateElement_table,
LibraryInfoTemplateAssociation_table,
LibraryFolderInfoTemplateAssociation_table,
LibraryDatasetInfoTemplateAssociation_table,
LibraryInfoAssociation_table,
LibraryFolderInfoAssociation_table,
LibraryDatasetInfoAssociation_table,
LibraryItemInfoElement_table,
LibraryItemInfo_table,
LibraryItemInfoTemplate_table,
]
for table in TABLES:
drop_table(table)
# Drop the index on the Job.state column - changeset 2192
drop_index('ix_job_state', 'job', 'state', metadata)
# Drop 1 column from the stored_workflow table - changeset 2328
try:
StoredWorkflow_table = Table("stored_workflow", metadata, autoload=True)
except NoSuchTableError:
StoredWorkflow_table = None
log.debug("Failed loading table stored_workflow")
if StoredWorkflow_table is not None:
try:
col = StoredWorkflow_table.c.importable
col.drop()
except Exception:
log.exception("Dropping column 'importable' from stored_workflow table failed.")
drop_column('importable', 'stored_workflow', metadata)
# Drop 1 column from the metadata_file table
try:
MetadataFile_table = Table("metadata_file", metadata, autoload=True)
except NoSuchTableError:
MetadataFile_table = None
log.debug("Failed loading table metadata_file")
if MetadataFile_table is not None:
try:
col = MetadataFile_table.c.lda_id
col.drop()
except Exception:
log.exception("Dropping column 'lda_id' from metadata_file table failed.")
drop_column('lda_id', 'metadata_file', metadata)
# Drop 1 column from the history_dataset_association table
try:
HistoryDatasetAssociation_table = Table("history_dataset_association", metadata, autoload=True)
except NoSuchTableError:
HistoryDatasetAssociation_table = None
log.debug("Failed loading table history_dataset_association")
if HistoryDatasetAssociation_table is not None:
try:
col = HistoryDatasetAssociation_table.c.copied_from_library_dataset_dataset_association_id
col.drop()
except Exception:
log.exception("Dropping column 'copied_from_library_dataset_dataset_association_id' from history_dataset_association table failed.")
drop_column('copied_from_library_dataset_dataset_association_id', HistoryDatasetAssociation_table)
# Drop 2 columns from the galaxy_user table
try:
User_table = Table("galaxy_user", metadata, autoload=True)
except NoSuchTableError:
User_table = None
log.debug("Failed loading table galaxy_user")
if User_table is not None:
try:
col = User_table.c.deleted
col.drop()
except Exception:
log.exception("Dropping column 'deleted' from galaxy_user table failed.")
try:
col = User_table.c.purged
col.drop()
except Exception:
log.exception("Dropping column 'purged' from galaxy_user table failed.")
User_table = Table("galaxy_user", metadata, autoload=True)
drop_column('deleted', User_table)
drop_column('purged', User_table)
lib/galaxy/model/migrate/versions/0004_indexes_and_defaults.py
+5 -8
View File
@@ -1,7 +1,8 @@
"""
"""
from __future__ import print_function
import logging
import sys
from sqlalchemy import (
MetaData,
@@ -14,21 +15,17 @@ from galaxy.model.migrate.versions.util import (
)
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
metadata = MetaData()
def upgrade(migrate_engine):
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
User_table = Table("galaxy_user", metadata, autoload=True)
# The next add_index() calls are not needed any more after commit
# 7ee93c0995123b0f357abd649326295dfa06766c , but harmless
add_index('ix_galaxy_user_deleted', User_table, 'deleted')
add_index('ix_galaxy_user_purged', User_table, 'purged')
# Set the default data in the galaxy_user table, but only for null values
lib/galaxy/model/migrate/versions/0005_cleanup_datasets_fix.py
+31 -6
View File
@@ -1,18 +1,42 @@
from __future__ import print_function
import datetime
import errno
import logging
import os
import time
from sqlalchemy import and_, Boolean, Column, DateTime, false, ForeignKey, Integer, MetaData, not_, Numeric, Table, TEXT, true
from sqlalchemy.orm import backref, mapper, relation, scoped_session, sessionmaker
from sqlalchemy import (
and_,
Boolean,
Column,
DateTime,
false,
ForeignKey,
Integer,
MetaData,
not_,
Numeric,
Table,
TEXT,
true
)
from sqlalchemy.orm import (
backref,
mapper,
relation,
scoped_session,
sessionmaker
)
from galaxy.model.custom_types import MetadataType, TrimmedString
from galaxy.model.custom_types import (
MetadataType,
TrimmedString
)
from galaxy.model.metadata import MetadataCollection
from galaxy.util.bunch import Bunch
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
now = datetime.datetime.utcnow
metadata = MetaData()
context = scoped_session(sessionmaker(autoflush=False, autocommit=True))
@@ -690,7 +714,9 @@ def __guess_dataset_by_filename(filename):
def upgrade(migrate_engine):
print(__doc__)
metadata.bind = migrate_engine
log.debug("Fixing a discrepancy concerning deleted shared history items.")
affected_items = 0
start_time = time.time()
@@ -734,5 +760,4 @@ def upgrade(migrate_engine):
def downgrade(migrate_engine):
metadata.bind = migrate_engine
log.debug("Downgrade is not possible.")
pass
lib/galaxy/model/migrate/versions/0006_change_qual_datatype.py
-8
View File
@@ -5,18 +5,10 @@ column, specifically 'qual' is changed to be 'qual454'.
from __future__ import print_function
import logging
import sys
from sqlalchemy import MetaData
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
metadata = MetaData()
lib/galaxy/model/migrate/versions/0007_sharing_histories.py
+23 -48
View File
@@ -6,19 +6,24 @@ histories in the same way that workflows are shared.
from __future__ import print_function
import logging
import sys
from sqlalchemy import Boolean, Column, ForeignKey, Integer, MetaData, Table
from sqlalchemy.exc import NoSuchTableError
from sqlalchemy import (
Boolean,
Column,
ForeignKey,
Integer,
MetaData,
Table
)
from galaxy.model.migrate.versions.util import (
add_column,
create_table,
drop_column,
drop_table
)
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
metadata = MetaData()
HistoryUserShareAssociation_table = Table("history_user_share_association", metadata,
@@ -28,48 +33,18 @@ HistoryUserShareAssociation_table = Table("history_user_share_association", meta
def upgrade(migrate_engine):
metadata.bind = migrate_engine
print(__doc__)
# Load existing tables
metadata.bind = migrate_engine
metadata.reflect()
# Create the history_user_share_association table
try:
HistoryUserShareAssociation_table.create()
except Exception:
log.exception("Creating history_user_share_association table failed.")
# Add 1 column to the history table
try:
History_table = Table("history", metadata, autoload=True)
except NoSuchTableError:
History_table = None
log.debug("Failed loading table history")
if History_table is not None:
try:
col = Column('importable', Boolean, index=True, default=False)
col.create(History_table, index_name='ix_history_importable')
assert col is History_table.c.importable
except Exception:
log.exception("Adding column 'importable' to history table failed.")
create_table(HistoryUserShareAssociation_table)
col = Column('importable', Boolean, index=True, default=False)
add_column(col, 'history', metadata, index_name='ix_history_importable')
def downgrade(migrate_engine):
metadata.bind = migrate_engine
# Load existing tables
metadata.reflect()
# Drop 1 column from the history table
try:
History_table = Table("history", metadata, autoload=True)
except NoSuchTableError:
History_table = None
log.debug("Failed loading table history")
if History_table is not None:
try:
col = History_table.c.importable
col.drop()
except Exception:
log.exception("Dropping column 'importable' from history table failed.")
# Drop the history_user_share_association table
try:
HistoryUserShareAssociation_table.drop()
except Exception:
log.exception("Dropping history_user_share_association table failed.")
drop_column('importable', 'history', metadata)
drop_table(HistoryUserShareAssociation_table)
lib/galaxy/model/migrate/versions/0008_galaxy_forms.py
+42 -95
View File
@@ -13,40 +13,47 @@ from __future__ import print_function
import datetime
import logging
import sys
from migrate import ForeignKeyConstraint
from sqlalchemy import Boolean, Column, DateTime, ForeignKey, Integer, MetaData, Table, TEXT
from sqlalchemy import (
Boolean,
Column,
DateTime,
ForeignKey,
Integer,
MetaData,
Table,
TEXT
)
# Need our custom types, but don't import anything else from model
from galaxy.model.custom_types import JSONType, TrimmedString
from galaxy.model.custom_types import (
JSONType,
TrimmedString
)
from galaxy.model.migrate.versions.util import (
create_table,
drop_table
)
now = datetime.datetime.utcnow
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
now = datetime.datetime.utcnow
metadata = MetaData()
FormDefinitionCurrent_table = Table('form_definition_current', metadata,
Column("id", Integer, primary_key=True),
Column("create_time", DateTime, default=now),
Column("update_time", DateTime, default=now, onupdate=now),
Column("latest_form_id", Integer, index=True),
Column("deleted", Boolean, index=True, default=False))
FormDefinition_table = Table('form_definition', metadata,
Column("id", Integer, primary_key=True),
Column("create_time", DateTime, default=now),
Column("update_time", DateTime, default=now, onupdate=now),
Column("name", TrimmedString(255), nullable=False),
Column("desc", TEXT),
Column("form_definition_current_id", Integer, ForeignKey("form_definition_current.id"), index=True, nullable=False),
Column("form_definition_current_id", Integer, ForeignKey("form_definition_current.id", use_alter=True), index=True, nullable=False),
Column("fields", JSONType()))
FormDefinitionCurrent_table = Table('form_definition_current', metadata,
Column("id", Integer, primary_key=True),
Column("create_time", DateTime, default=now),
Column("update_time", DateTime, default=now, onupdate=now),
Column("latest_form_id", Integer, ForeignKey("form_definition.id"), index=True),
Column("deleted", Boolean, index=True, default=False))
FormValues_table = Table('form_values', metadata,
Column("id", Integer, primary_key=True),
Column("create_time", DateTime, default=now),
@@ -101,90 +108,30 @@ SampleEvent_table = Table('sample_event', metadata,
Column("sample_state_id", Integer, ForeignKey("sample_state.id"), index=True),
Column("comment", TEXT))
TABLES = [
FormDefinition_table,
FormDefinitionCurrent_table,
FormValues_table,
RequestType_table,
Request_table,
Sample_table,
SampleState_table,
SampleEvent_table
]
def upgrade(migrate_engine):
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
# Add all of the new tables above
try:
FormDefinitionCurrent_table.create()
except Exception:
log.exception("Creating form_definition_current table failed.")
try:
FormDefinition_table.create()
except Exception:
log.exception("Creating form_definition table failed.")
# Add 1 foreign key constraint to the form_definition_current table
if FormDefinitionCurrent_table is not None and FormDefinition_table is not None:
try:
cons = ForeignKeyConstraint([FormDefinitionCurrent_table.c.latest_form_id],
[FormDefinition_table.c.id],
name='form_definition_current_latest_form_id_fk')
# Create the constraint
cons.create()
except Exception:
log.exception("Adding foreign key constraint 'form_definition_current_latest_form_id_fk' to table 'form_definition_current' failed.")
try:
FormValues_table.create()
except Exception:
log.exception("Creating form_values table failed.")
try:
RequestType_table.create()
except Exception:
log.exception("Creating request_type table failed.")
try:
Request_table.create()
except Exception:
log.exception("Creating request table failed.")
try:
Sample_table.create()
except Exception:
log.exception("Creating sample table failed.")
try:
SampleState_table.create()
except Exception:
log.exception("Creating sample_state table failed.")
try:
SampleEvent_table.create()
except Exception:
log.exception("Creating sample_event table failed.")
for table in TABLES:
create_table(table)
def downgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
try:
FormDefinition_table.drop()
except Exception:
log.exception("Dropping form_definition table failed.")
try:
FormDefinitionCurrent_table.drop()
except Exception:
log.exception("Dropping form_definition_current table failed.")
try:
FormValues_table.drop()
except Exception:
log.exception("Dropping form_values table failed.")
try:
Request_table.drop()
except Exception:
log.exception("Dropping request table failed.")
try:
RequestType_table.drop()
except Exception:
log.exception("Dropping request_type table failed.")
try:
Sample_table.drop()
except Exception:
log.exception("Dropping sample table failed.")
try:
SampleState_table.drop()
except Exception:
log.exception("Dropping sample_state table failed.")
try:
SampleEvent_table.drop()
except Exception:
log.exception("Dropping sample_event table failed.")
for table in reversed(TABLES):
drop_table(table)
lib/galaxy/model/migrate/versions/0009_request_table.py
+9 -10
View File
@@ -6,21 +6,20 @@ This migration script adds a new column to 2 tables:
from __future__ import print_function
import logging
import sys
from sqlalchemy import Boolean, Column, MetaData
from sqlalchemy import (
Boolean,
Column,
MetaData
)
from galaxy.model.custom_types import TrimmedString
from galaxy.model.migrate.versions.util import add_column, drop_column
from galaxy.model.migrate.versions.util import (
add_column,
drop_column
)
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
metadata = MetaData()
lib/galaxy/model/migrate/versions/0010_hda_display_at_authz_table.py
+10 -12
View File
@@ -12,21 +12,20 @@ from __future__ import print_function
import datetime
import logging
import sys
from sqlalchemy import Column, DateTime, ForeignKey, Integer, MetaData, Table
from sqlalchemy import (
Column,
DateTime,
ForeignKey,
Integer,
MetaData,
Table
)
# Need our custom types, but don't import anything else from model
from galaxy.model.custom_types import TrimmedString
now = datetime.datetime.utcnow
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
now = datetime.datetime.utcnow
metadata = MetaData()
HistoryDatasetAssociationDisplayAtAuthorization_table = Table("history_dataset_association_display_at_authorization", metadata,
@@ -39,9 +38,8 @@ HistoryDatasetAssociationDisplayAtAuthorization_table = Table("history_dataset_a
def upgrade(migrate_engine):
metadata.bind = migrate_engine
print(__doc__)
# Load existing tables
metadata.bind = migrate_engine
metadata.reflect()
try:
HistoryDatasetAssociationDisplayAtAuthorization_table.create()
lib/galaxy/model/migrate/versions/0011_v0010_mysql_index_fix.py
+2 -9
View File
@@ -1,6 +1,6 @@
"""
This script fixes a problem introduced in the previous migration script
0010_hda_display_at_atuhz_table.py . MySQL has a name length limit and
0010_hda_display_at_authz_table.py . MySQL has a name length limit and
thus the index "ix_hdadaa_history_dataset_association_id" has to be
manually created.
"""
@@ -8,7 +8,6 @@ from __future__ import print_function
import datetime
import logging
import sys
from sqlalchemy import MetaData
@@ -17,14 +16,8 @@ from galaxy.model.migrate.versions.util import (
drop_index,
)
now = datetime.datetime.utcnow
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
now = datetime.datetime.utcnow
metadata = MetaData()
lib/galaxy/model/migrate/versions/0012_user_address.py
+25 -38
View File
@@ -8,21 +8,27 @@ from __future__ import print_function
import datetime
import logging
import sys
from sqlalchemy import Boolean, Column, DateTime, ForeignKey, Integer, MetaData, Table, TEXT
from sqlalchemy.exc import NoSuchTableError
from sqlalchemy import (
Boolean,
Column,
DateTime,
ForeignKey,
Integer,
MetaData,
Table,
TEXT
)
from galaxy.model.custom_types import TrimmedString
from galaxy.model.migrate.versions.util import (
add_column,
create_table,
drop_column
)
now = datetime.datetime.utcnow
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
now = datetime.datetime.utcnow
metadata = MetaData()
UserAddress_table = Table("user_address", metadata,
@@ -49,38 +55,19 @@ def upgrade(migrate_engine):
metadata.reflect()
# Add all of the new tables above
try:
UserAddress_table.create()
except Exception:
log.exception("Creating user_address table failed.")
create_table(UserAddress_table)
# Add 1 column to the request_type table
try:
RequestType_table = Table("request_type", metadata, autoload=True)
except NoSuchTableError:
RequestType_table = None
log.debug("Failed loading table request_type")
if RequestType_table is not None:
try:
col = Column("deleted", Boolean, index=True, default=False)
col.create(RequestType_table, index_name='ix_request_type_deleted')
assert col is RequestType_table.c.deleted
except Exception:
log.exception("Adding column 'deleted' to request_type table failed.")
col = Column("deleted", Boolean, index=True, default=False)
add_column(col, 'request_type', metadata, index_name='ix_request_type_deleted')
# Delete the submitted column
# This fails for sqlite, so skip the drop -- no conflicts in the future
try:
Request_table = Table("request", metadata, autoload=True)
except NoSuchTableError:
Request_table = None
log.debug("Failed loading table request")
if Request_table is not None:
# SQLAlchemy Migrate has a bug when dropping a boolean column in SQLite
if migrate_engine.name != 'sqlite':
Request_table.c.submitted.drop()
col = Column("state", TrimmedString(255), index=True)
col.create(Request_table, index_name='ix_request_state')
assert col is Request_table.c.state
Request_table = Table("request", metadata, autoload=True)
# SQLAlchemy Migrate has a bug when dropping a boolean column in SQLite
if migrate_engine.name != 'sqlite':
drop_column('submitted', Request_table)
col = Column("state", TrimmedString(255), index=True)
add_column(col, Request_table, index_name='ix_request_state')
def downgrade(migrate_engine):
lib/galaxy/model/migrate/versions/0013_change_lib_item_templates_to_forms.py
+43 -163
View File
@@ -18,20 +18,41 @@ with a shortened name.
from __future__ import print_function
import logging
import sys
from sqlalchemy import Column, ForeignKey, Index, Integer, MetaData, Table
from sqlalchemy.exc import NoSuchTableError
from sqlalchemy import (
Column,
ForeignKey,
Index,
Integer,
MetaData,
Table
)
from galaxy.model.migrate.versions.util import (
create_table,
drop_table
)
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
metadata = MetaData()
OLD_TABLE_NAMES = [
'library_item_info_permissions',
'library_item_info_template_permissions',
'library_item_info_element',
'library_item_info_template_element',
'library_info_template_association',
'library_folder_info_template_association',
'library_dataset_info_template_association',
'library_dataset_dataset_info_template_association',
'library_info_association',
'library_folder_info_association',
'library_dataset_info_association',
'library_dataset_dataset_info_association',
'library_item_info',
'library_item_info_template',
]
LibraryInfoAssociation_table = Table('library_info_association', metadata,
Column("id", Integer, primary_key=True),
Column("library_id", Integer, ForeignKey("library.id"), index=True),
@@ -50,167 +71,27 @@ LibraryDatasetDatasetInfoAssociation_table = Table('library_dataset_dataset_info
Column("form_definition_id", Integer, ForeignKey("form_definition.id"), index=True),
Column("form_values_id", Integer, ForeignKey("form_values.id"), index=True))
NEW_TABLES = [
LibraryInfoAssociation_table,
LibraryFolderInfoAssociation_table,
LibraryDatasetDatasetInfoAssociation_table
]
def upgrade(migrate_engine):
print(__doc__)
metadata.bind = migrate_engine
# Load existing tables
metadata.reflect()
# Drop all of the original library_item_info tables
# NOTE: all existing library item into template data is eliminated here via table drops
try:
LibraryItemInfoPermissions_table = Table("library_item_info_permissions", metadata, autoload=True)
except NoSuchTableError:
LibraryItemInfoPermissions_table = None
log.debug("Failed loading table library_item_info_permissions")
try:
LibraryItemInfoPermissions_table.drop()
except Exception:
log.exception("Dropping library_item_info_permissions table failed.")
try:
LibraryItemInfoTemplatePermissions_table = Table("library_item_info_template_permissions", metadata, autoload=True)
except NoSuchTableError:
LibraryItemInfoTemplatePermissions_table = None
log.debug("Failed loading table library_item_info_template_permissions")
try:
LibraryItemInfoTemplatePermissions_table.drop()
except Exception:
log.exception("Dropping library_item_info_template_permissions table failed.")
try:
LibraryItemInfoElement_table = Table("library_item_info_element", metadata, autoload=True)
except NoSuchTableError:
LibraryItemInfoElement_table = None
log.debug("Failed loading table library_item_info_element")
try:
LibraryItemInfoElement_table.drop()
except Exception:
log.exception("Dropping library_item_info_element table failed.")
try:
LibraryItemInfoTemplateElement_table = Table("library_item_info_template_element", metadata, autoload=True)
except NoSuchTableError:
LibraryItemInfoTemplateElement_table = None
log.debug("Failed loading table library_item_info_template_element")
try:
LibraryItemInfoTemplateElement_table.drop()
except Exception:
log.exception("Dropping library_item_info_template_element table failed.")
try:
LibraryInfoTemplateAssociation_table = Table("library_info_template_association", metadata, autoload=True)
except NoSuchTableError:
LibraryInfoTemplateAssociation_table = None
log.debug("Failed loading table library_info_template_association")
try:
LibraryInfoTemplateAssociation_table.drop()
except Exception:
log.exception("Dropping library_info_template_association table failed.")
try:
LibraryFolderInfoTemplateAssociation_table = Table("library_folder_info_template_association", metadata, autoload=True)
except NoSuchTableError:
LibraryFolderInfoTemplateAssociation_table = None
log.debug("Failed loading table library_folder_info_template_association")
try:
LibraryFolderInfoTemplateAssociation_table.drop()
except Exception:
log.exception("Dropping library_folder_info_template_association table failed.")
try:
LibraryDatasetInfoTemplateAssociation_table = Table("library_dataset_info_template_association", metadata, autoload=True)
except NoSuchTableError:
LibraryDatasetInfoTemplateAssociation_table = None
log.debug("Failed loading table library_dataset_info_template_association")
try:
LibraryDatasetInfoTemplateAssociation_table.drop()
except Exception:
log.exception("Dropping library_dataset_info_template_association table failed.")
try:
LibraryDatasetDatasetInfoTemplateAssociation_table = Table("library_dataset_dataset_info_template_association", metadata, autoload=True)
except NoSuchTableError:
LibraryDatasetDatasetInfoTemplateAssociation_table = None
log.debug("Failed loading table library_dataset_dataset_info_template_association")
try:
LibraryDatasetDatasetInfoTemplateAssociation_table.drop()
except Exception:
log.exception("Dropping library_dataset_dataset_info_template_association table failed.")
try:
LibraryInfoAssociation_table = Table("library_info_association", metadata, autoload=True)
except NoSuchTableError:
LibraryInfoAssociation_table = None
log.debug("Failed loading table library_info_association")
try:
LibraryInfoAssociation_table.drop()
except Exception:
log.exception("Dropping library_info_association table failed.")
try:
LibraryFolderInfoAssociation_table = Table("library_folder_info_association", metadata, autoload=True)
except NoSuchTableError:
LibraryFolderInfoAssociation_table = None
log.debug("Failed loading table library_folder_info_association")
try:
LibraryFolderInfoAssociation_table.drop()
except Exception:
log.exception("Dropping library_folder_info_association table failed.")
try:
LibraryDatasetInfoAssociation_table = Table("library_dataset_info_association", metadata, autoload=True)
except NoSuchTableError:
LibraryDatasetInfoAssociation_table = None
log.debug("Failed loading table library_dataset_info_association")
try:
LibraryDatasetInfoAssociation_table.drop()
except Exception:
log.exception("Dropping library_dataset_info_association table failed.")
try:
LibraryDatasetDatasetInfoAssociation_table = Table("library_dataset_dataset_info_association", metadata, autoload=True)
except NoSuchTableError:
LibraryDatasetDatasetInfoAssociation_table = None
log.debug("Failed loading table library_dataset_dataset_info_association")
try:
LibraryDatasetDatasetInfoAssociation_table.drop()
except Exception:
log.exception("Dropping library_dataset_dataset_info_association table failed.")
try:
LibraryItemInfo_table = Table("library_item_info", metadata, autoload=True)
except NoSuchTableError:
LibraryItemInfo_table = None
log.debug("Failed loading table library_item_info")
try:
LibraryItemInfo_table.drop()
except Exception:
log.exception("Dropping library_item_info table failed.")
try:
LibraryItemInfoTemplate_table = Table("library_item_info_template", metadata, autoload=True)
except NoSuchTableError:
LibraryItemInfoTemplate_table = None
log.debug("Failed loading table library_item_info_template")
try:
LibraryItemInfoTemplate_table.drop()
except Exception:
log.exception("Dropping library_item_info_template table failed.")
for table_name in OLD_TABLE_NAMES:
drop_table(table_name, metadata)
# Create all new tables above
try:
LibraryInfoAssociation_table.create()
except Exception:
log.exception("Creating library_info_association table failed.")
try:
LibraryFolderInfoAssociation_table.create()
except Exception:
log.exception("Creating library_folder_info_association table failed.")
try:
LibraryDatasetDatasetInfoAssociation_table.create()
except Exception:
log.exception("Creating library_dataset_dataset_info_association table failed.")
for table in NEW_TABLES:
create_table(table)
# Fix index on LibraryDatasetDatasetInfoAssociation_table for mysql
if migrate_engine.name == 'mysql':
# Load existing tables
@@ -223,5 +104,4 @@ def upgrade(migrate_engine):
def downgrade(migrate_engine):
metadata.bind = migrate_engine
log.debug("Downgrade is not possible.")
pass
lib/galaxy/model/migrate/versions/0017_library_item_indexes.py
+5 -8
View File
@@ -5,17 +5,14 @@ library_dataset.name, library_dataset_dataset_association.name.
from __future__ import print_function
import logging
import sys
from sqlalchemy import Index, MetaData, Table
from sqlalchemy import (
Index,
MetaData,
Table
)
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
metadata = MetaData()
lib/galaxy/model/migrate/versions/0019_request_library_folder.py
+32 -57
View File
@@ -6,79 +6,54 @@ to the form_definition table.
from __future__ import print_function
import logging
import sys
from migrate import ForeignKeyConstraint
from sqlalchemy import Column, Integer, MetaData, Table
from sqlalchemy.exc import NoSuchTableError
from sqlalchemy import (
Column,
Integer,
MetaData,
Table
)
# Need our custom types, but don't import anything else from model
from galaxy.model.custom_types import JSONType, TrimmedString
from galaxy.model.custom_types import (
JSONType,
TrimmedString
)
from galaxy.model.migrate.versions.util import (
add_column,
)
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
metadata = MetaData()
def upgrade(migrate_engine):
metadata.bind = migrate_engine
print(__doc__)
# Load existing tables
metadata.bind = migrate_engine
metadata.reflect()
# Create the folder_id column
try:
Request_table = Table("request", metadata, autoload=True)
except NoSuchTableError:
Request_table = None
log.debug("Failed loading table request")
if Request_table is not None:
Request_table = Table("request", metadata, autoload=True)
col = Column("folder_id", Integer, index=True)
add_column(col, Request_table, index_name='ix_request_folder_id')
LibraryFolder_table = Table("library_folder", metadata, autoload=True)
# Add 1 foreign key constraint to the library_folder table
if migrate_engine.name != 'sqlite':
try:
col = Column("folder_id", Integer, index=True)
col.create(Request_table, index_name='ix_request_folder_id')
assert col is Request_table.c.folder_id
cons = ForeignKeyConstraint([Request_table.c.folder_id],
[LibraryFolder_table.c.id],
name='request_folder_id_fk')
# Create the constraint
cons.create()
except Exception:
log.exception("Adding column 'folder_id' to request table failed.")
try:
LibraryFolder_table = Table("library_folder", metadata, autoload=True)
except NoSuchTableError:
LibraryFolder_table = None
log.debug("Failed loading table library_folder")
# Add 1 foreign key constraint to the library_folder table
if migrate_engine.name != 'sqlite' and Request_table is not None and LibraryFolder_table is not None:
try:
cons = ForeignKeyConstraint([Request_table.c.folder_id],
[LibraryFolder_table.c.id],
name='request_folder_id_fk')
# Create the constraint
cons.create()
except Exception:
log.exception("Adding foreign key constraint 'request_folder_id_fk' to table 'library_folder' failed.")
log.exception("Adding foreign key constraint 'request_folder_id_fk' to table 'library_folder' failed.")
# Create the type column in form_definition
try:
FormDefinition_table = Table("form_definition", metadata, autoload=True)
except NoSuchTableError:
FormDefinition_table = None
log.debug("Failed loading table form_definition")
if FormDefinition_table is not None:
try:
col = Column("type", TrimmedString(255), index=True)
col.create(FormDefinition_table, index_name='ix_form_definition_type')
assert col is FormDefinition_table.c.type
except Exception:
log.exception("Adding column 'type' to form_definition table failed.")
try:
col = Column("layout", JSONType())
col.create(FormDefinition_table)
assert col is FormDefinition_table.c.layout
except Exception:
log.exception("Adding column 'layout' to form_definition table failed.")
FormDefinition_table = Table("form_definition", metadata, autoload=True)
col = Column("type", TrimmedString(255), index=True)
add_column(col, FormDefinition_table, index_name='ix_form_definition_type')
col = Column("layout", JSONType())
add_column(col, FormDefinition_table)
def downgrade(migrate_engine):
metadata.bind = migrate_engine
pass
lib/galaxy/model/migrate/versions/0020_library_upload_job.py
-8
View File
@@ -8,7 +8,6 @@ column.
from __future__ import print_function
import logging
import sys
from sqlalchemy import (
Column,
@@ -29,13 +28,6 @@ from galaxy.model.migrate.versions.util import (
)
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
metadata = MetaData()
JobToOutputLibraryDataset_table = Table("job_to_output_library_dataset", metadata,
lib/galaxy/model/migrate/versions/0024_page_slug_unique_constraint.py
+12 -7
View File
@@ -6,7 +6,15 @@ from __future__ import print_function
import logging
from sqlalchemy import Index, MetaData, Table
from sqlalchemy import (
MetaData,
Table
)
from galaxy.model.migrate.versions.util import (
add_index,
drop_index
)
log = logging.getLogger(__name__)
metadata = MetaData()
@@ -20,16 +28,13 @@ def upgrade(migrate_engine):
Page_table = Table("page", metadata, autoload=True)
try:
# Sqlite doesn't support .alter, so we need to drop an recreate
i = Index("ix_page_slug", Page_table.c.slug)
i.drop()
drop_index("ix_page_slug", Page_table, 'slug')
i = Index("ix_page_slug", Page_table.c.slug, unique=False)
i.create()
add_index("ix_page_slug", Page_table, 'slug', unique=False)
except Exception:
# Mysql doesn't have a named index, but alter should work
Page_table.c.slug.alter(unique=False)
def downgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
pass
lib/galaxy/model/migrate/versions/0025_user_info.py
+4 -9
View File
@@ -4,7 +4,6 @@ This script adds a foreign key to the form_values table in the galaxy_user table
from __future__ import print_function
import logging
import sys
from sqlalchemy import (
Column,
@@ -13,16 +12,12 @@ from sqlalchemy import (
MetaData
)
from galaxy.model.migrate.versions.util import add_column, drop_column
from galaxy.model.migrate.versions.util import (
add_column,
drop_column
)
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
metadata = MetaData()
lib/galaxy/model/migrate/versions/0027_request_events.py
+18 -27
View File
@@ -6,22 +6,27 @@ from __future__ import print_function
import datetime
import logging
import sys
from sqlalchemy import Column, DateTime, ForeignKey, Integer, MetaData, Table, TEXT
from sqlalchemy.exc import NoSuchTableError
from sqlalchemy import (
Column,
DateTime,
ForeignKey,
Integer,
MetaData,
Table,
TEXT
)
from galaxy.model.custom_types import TrimmedString
from galaxy.model.migrate.versions.util import localtimestamp, nextval
from galaxy.model.migrate.versions.util import (
create_table,
drop_column,
localtimestamp,
nextval
)
now = datetime.datetime.utcnow
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
now = datetime.datetime.utcnow
metadata = MetaData()
RequestEvent_table = Table('request_event', metadata,
@@ -38,13 +43,8 @@ def upgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
# Add new request_event table
try:
RequestEvent_table.create()
except Exception:
log.exception("Creating request_event table failed.")
create_table(RequestEvent_table)
# move the current state of all existing requests to the request_event table
cmd = \
"INSERT INTO request_event " + \
"SELECT %s AS id," + \
@@ -59,16 +59,7 @@ def upgrade(migrate_engine):
if migrate_engine.name != 'sqlite':
# Delete the state column
try:
Request_table = Table("request", metadata, autoload=True)
except NoSuchTableError:
Request_table = None
log.debug("Failed loading table request")
if Request_table is not None:
try:
Request_table.c.state.drop()
except Exception:
log.exception("Deleting column 'state' to request table failed.")
drop_column('state', 'request', metadata)
def downgrade(migrate_engine):
lib/galaxy/model/migrate/versions/0028_external_metadata_file_override.py
+17 -19
View File
@@ -6,35 +6,33 @@ set up with read-only access to database/files
from __future__ import print_function
import logging
import sys
from sqlalchemy import Column, MetaData, String, Table
from sqlalchemy import (
Column,
MetaData,
String,
)
from galaxy.model.migrate.versions.util import (
add_column,
drop_column
)
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
metadata = MetaData()
def upgrade(migrate_engine):
metadata.bind = migrate_engine
print(__doc__)
# Load existing tables
metadata.bind = migrate_engine
metadata.reflect()
try:
job_external_output_metadata = Table("job_external_output_metadata", metadata, autoload=True)
col = Column("filename_override_metadata", String(255))
col.create(job_external_output_metadata)
assert col is job_external_output_metadata.c.filename_override_metadata
except Exception:
log.exception("Adding column 'filename_override_metadata' to job_external_output_metadata table failed.")
col = Column("filename_override_metadata", String(255))
add_column(col, 'job_external_output_metadata', metadata)
def downgrade(migrate_engine):
metadata.bind = migrate_engine
pass
metadata.reflect()
drop_column('filename_override_metadata', 'job_external_output_metadata', metadata)
lib/galaxy/model/migrate/versions/0037_samples_library.py
+1 -9
View File
@@ -8,7 +8,6 @@ from __future__ import print_function
import datetime
import logging
import sys
from sqlalchemy import (
Column,
@@ -26,15 +25,8 @@ from galaxy.model.migrate.versions.util import (
drop_column
)
now = datetime.datetime.utcnow
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
now = datetime.datetime.utcnow
metadata = MetaData()
lib/galaxy/model/migrate/versions/0039_add_synopsis_column_to_library_table.py
+7 -2
View File
@@ -5,15 +5,20 @@ from __future__ import print_function
import logging
from sqlalchemy import Column, MetaData, Table, TEXT
from sqlalchemy import (
Column,
MetaData,
Table,
TEXT
)
log = logging.getLogger(__name__)
metadata = MetaData()
def upgrade(migrate_engine):
metadata.bind = migrate_engine
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
try:
Library_table = Table("library", metadata, autoload=True)
lib/galaxy/model/migrate/versions/0041_workflow_invocation.py
+12 -3
View File
@@ -6,11 +6,20 @@ from __future__ import print_function
import datetime
import logging
from sqlalchemy import Column, DateTime, ForeignKey, Integer, MetaData, Table
from sqlalchemy import (
Column,
DateTime,
ForeignKey,
Integer,
MetaData,
Table
)
from galaxy.model.migrate.versions.util import create_table, drop_table
from galaxy.model.migrate.versions.util import (
create_table,
drop_table
)
logging.basicConfig(level=logging.DEBUG)
log = logging.getLogger(__name__)
now = datetime.datetime.utcnow
metadata = MetaData()
lib/galaxy/model/migrate/versions/0042_workflow_invocation_fix.py
+18 -15
View File
@@ -6,9 +6,20 @@ from __future__ import print_function
import datetime
import logging
from sqlalchemy import Column, DateTime, ForeignKey, Integer, MetaData, Table
from sqlalchemy import (
Column,
DateTime,
ForeignKey,
Integer,
MetaData,
Table
)
from galaxy.model.migrate.versions.util import (
create_table,
drop_table
)
logging.basicConfig(level=logging.DEBUG)
log = logging.getLogger(__name__)
now = datetime.datetime.utcnow
metadata = MetaData()
@@ -21,14 +32,11 @@ def upgrade(migrate_engine):
# 1) Drop
for table_name in ["workflow_invocation_step", "workflow_invocation"]:
try:
t = Table(table_name, metadata, autoload=True)
t.drop()
metadata.remove(t)
except Exception:
log.exception("Failed to drop table '%s', ignoring (might result in wrong schema)" % table_name)
t = Table(table_name, metadata, autoload=True)
drop_table(t)
metadata.remove(t)
# 2) Readd
# 2) Re-add
WorkflowInvocation_table = Table("workflow_invocation", metadata,
Column("id", Integer, primary_key=True),
Column("create_time", DateTime, default=now),
@@ -44,13 +52,8 @@ def upgrade(migrate_engine):
Column("job_id", Integer, ForeignKey("job.id"), index=True, nullable=True))
for table in [WorkflowInvocation_table, WorkflowInvocationStep_table]:
try:
table.create()
except Exception:
log.exception("Failed to create table '%s', ignoring (might result in wrong schema)" % table.name)
create_table(table)
def downgrade(migrate_engine):
metadata.bind = migrate_engine
# No downgrade
pass
lib/galaxy/model/migrate/versions/0046_post_job_actions.py
+15 -18
View File
@@ -5,12 +5,21 @@ from __future__ import print_function
import logging
from sqlalchemy import Column, ForeignKey, Integer, MetaData, String, Table
from sqlalchemy import (
Column,
ForeignKey,
Integer,
MetaData,
String,
Table
)
# Need our custom types, but don't import anything else from model
from galaxy.model.custom_types import JSONType
from galaxy.model.migrate.versions.util import (
create_table,
drop_table
)
logging.basicConfig(level=logging.DEBUG)
log = logging.getLogger(__name__)
metadata = MetaData()
@@ -21,27 +30,15 @@ PostJobAction_table = Table("post_job_action", metadata,
Column("output_name", String(255), nullable=True),
Column("action_arguments", JSONType, nullable=True))
# PostJobActionAssociation_table = Table("post_job_action_association", metadata,
# Column("id", Integer, primary_key=True),
# Column("post_job_action_id", Integer, ForeignKey("post_job_action.id"), index=True, nullable=False),
# Column("job_id", Integer, ForeignKey("job.id"), index=True, nullable=False))
tables = [PostJobAction_table] # , PostJobActionAssociation_table]
def upgrade(migrate_engine):
metadata.bind = migrate_engine
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
for table in tables:
try:
table.create()
except Exception:
log.exception("Failed to create table '%s', ignoring (might result in wrong schema)" % table.name)
create_table(PostJobAction_table)
def downgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
for table in tables:
table.drop()
drop_table(PostJobAction_table)
lib/galaxy/model/migrate/versions/0047_job_table_user_id_column.py
+36 -41
View File
@@ -4,21 +4,21 @@ Add a user_id column to the job table.
from __future__ import print_function
import logging
import sys
from sqlalchemy import Column, ForeignKey, Integer, MetaData, Table
from sqlalchemy.exc import NoSuchTableError
from sqlalchemy import (
Column,
ForeignKey,
Integer,
MetaData,
Table
)
from galaxy.model.migrate.versions.util import add_column, drop_column
from galaxy.model.migrate.versions.util import (
add_column,
drop_column
)
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
metadata = MetaData()
@@ -27,37 +27,32 @@ def upgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
Job_table = Table("job", metadata, autoload=True)
# SQLAlchemy Migrate has a bug when adding a column with both a ForeignKey and a index in SQLite
if migrate_engine.name != 'sqlite':
col = Column("user_id", Integer, ForeignKey("galaxy_user.id"), index=True, nullable=True)
else:
col = Column("user_id", Integer, nullable=True)
add_column(col, Job_table, index_name='ix_job_user_id')
try:
Job_table = Table("job", metadata, autoload=True)
except NoSuchTableError:
Job_table = None
log.debug("Failed loading table job")
if Job_table is not None:
# SQLAlchemy Migrate has a bug when adding a column with both a ForeignKey and a index in SQLite
if migrate_engine.name != 'sqlite':
col = Column("user_id", Integer, ForeignKey("galaxy_user.id"), index=True, nullable=True)
else:
col = Column("user_id", Integer, nullable=True)
add_column(col, Job_table, index_name='ix_job_user_id')
try:
cmd = "SELECT job.id AS galaxy_job_id, " \
+ "galaxy_session.user_id AS galaxy_user_id " \
+ "FROM job " \
+ "JOIN galaxy_session ON job.session_id = galaxy_session.id;"
job_users = migrate_engine.execute(cmd).fetchall()
print("Updating user_id column in job table for ", len(job_users), " rows...")
print("")
update_count = 0
for row in job_users:
if row.galaxy_user_id:
cmd = "UPDATE job SET user_id = %d WHERE id = %d" % (int(row.galaxy_user_id), int(row.galaxy_job_id))
update_count += 1
migrate_engine.execute(cmd)
print("Updated the user_id column for ", update_count, " rows in the job table. ")
print(len(job_users) - update_count, " rows have no user_id since the value was NULL in the galaxy_session table.")
print("")
except Exception:
log.exception("Updating job.user_id column failed.")
cmd = "SELECT job.id AS galaxy_job_id, " \
+ "galaxy_session.user_id AS galaxy_user_id " \
+ "FROM job " \
+ "JOIN galaxy_session ON job.session_id = galaxy_session.id;"
job_users = migrate_engine.execute(cmd).fetchall()
print("Updating user_id column in job table for ", len(job_users), " rows...")
print("")
update_count = 0
for row in job_users:
if row.galaxy_user_id:
cmd = "UPDATE job SET user_id = %d WHERE id = %d" % (int(row.galaxy_user_id), int(row.galaxy_job_id))
update_count += 1
migrate_engine.execute(cmd)
print("Updated column 'user_id' for ", update_count, " rows of table 'job'.")
print(len(job_users) - update_count, " rows have no user_id since the value was NULL in the galaxy_session table.")
print("")
except Exception:
log.exception("Updating column 'user_id' of table 'job' failed.")
def downgrade(migrate_engine):
lib/galaxy/model/migrate/versions/0048_dataset_instance_state_column.py
+13 -36
View File
@@ -4,21 +4,19 @@ Add a state column to the history_dataset_association and library_dataset_datase
from __future__ import print_function
import logging
import sys
from sqlalchemy import Column, MetaData, Table
from sqlalchemy.exc import NoSuchTableError
from sqlalchemy import (
Column,
MetaData,
)
from galaxy.model.custom_types import TrimmedString
from galaxy.model.migrate.versions.util import (
add_column,
drop_column
)
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
metadata = MetaData()
DATASET_INSTANCE_TABLE_NAMES = ['history_dataset_association', 'library_dataset_dataset_association']
@@ -29,36 +27,15 @@ def upgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
dataset_instance_tables = []
for table_name in DATASET_INSTANCE_TABLE_NAMES:
try:
dataset_instance_tables.append((table_name, Table(table_name, metadata, autoload=True)))
except NoSuchTableError:
log.debug("Failed loading table %s" % table_name)
if dataset_instance_tables:
for table_name, dataset_instance_table in dataset_instance_tables:
index_name = "ix_%s_state" % table_name
try:
col = Column("state", TrimmedString(64), index=True, nullable=True)
col.create(dataset_instance_table, index_name=index_name)
assert col is dataset_instance_table.c.state
except Exception:
log.exception("Adding column 'state' to %s table failed.", table_name)
col = Column("state", TrimmedString(64), index=True, nullable=True)
index_name = "ix_%s_state" % table_name
add_column(col, table_name, metadata, index_name=index_name)
def downgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
dataset_instance_tables = []
for table_name in DATASET_INSTANCE_TABLE_NAMES:
try:
dataset_instance_tables.append((table_name, Table(table_name, metadata, autoload=True)))
except NoSuchTableError:
log.debug("Failed loading table %s" % table_name)
if dataset_instance_tables:
for table_name, dataset_instance_table in dataset_instance_tables:
try:
col = dataset_instance_table.c.state
col.drop()
except Exception:
log.exception("Dropping column 'state' from %s table failed.", table_name)
drop_column('state', table_name, metadata)
lib/galaxy/model/migrate/versions/0052_sample_dataset_table.py
-1
View File
@@ -75,5 +75,4 @@ def upgrade(migrate_engine):
def downgrade(migrate_engine):
metadata.bind = migrate_engine
pass
lib/galaxy/model/migrate/versions/0056_workflow_outputs.py
+16 -13
View File
@@ -5,11 +5,21 @@ from __future__ import print_function
import logging
from sqlalchemy import Column, ForeignKey, Integer, MetaData, String, Table
from sqlalchemy import (
Column,
ForeignKey,
Integer,
MetaData,
String,
Table
)
from galaxy.model.migrate.versions.util import (
create_table,
drop_table
)
logging.basicConfig(level=logging.DEBUG)
log = logging.getLogger(__name__)
metadata = MetaData()
WorkflowOutput_table = Table("workflow_output", metadata,
@@ -17,22 +27,15 @@ WorkflowOutput_table = Table("workflow_output", metadata,
Column("workflow_step_id", Integer, ForeignKey("workflow_step.id"), index=True, nullable=False),
Column("output_name", String(255), nullable=True))
tables = [WorkflowOutput_table]
def upgrade(migrate_engine):
metadata.bind = migrate_engine
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
for table in tables:
try:
table.create()
except Exception:
log.warning("Failed to create table '%s', ignoring (might result in wrong schema)" % table.name)
create_table(WorkflowOutput_table)
def downgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
for table in tables:
table.drop()
drop_table(WorkflowOutput_table)
lib/galaxy/model/migrate/versions/0059_sample_dataset_file_path.py
-1
View File
@@ -49,5 +49,4 @@ def upgrade(migrate_engine):
def downgrade(migrate_engine):
metadata.bind = migrate_engine
pass
lib/galaxy/model/migrate/versions/0061_tasks.py
+21 -12
View File
@@ -6,11 +6,25 @@ from __future__ import print_function
import datetime
import logging
from sqlalchemy import Column, DateTime, ForeignKey, Integer, MetaData, String, Table, TEXT
from sqlalchemy import (
Column,
DateTime,
ForeignKey,
Integer,
MetaData,
String,
Table,
TEXT
)
from galaxy.model.migrate.versions.util import (
create_table,
drop_table
)
log = logging.getLogger(__name__)
metadata = MetaData()
now = datetime.datetime.utcnow
metadata = MetaData()
Task_table = Table("task", metadata,
Column("id", Integer, primary_key=True),
@@ -29,22 +43,17 @@ Task_table = Table("task", metadata,
Column("task_runner_name", String(255)),
Column("task_runner_external_id", String(255)))
tables = [Task_table]
def upgrade(migrate_engine):
metadata.bind = migrate_engine
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
for table in tables:
try:
table.create()
except Exception:
log.warning("Failed to create table '%s', ignoring (might result in wrong schema)" % table.name)
create_table(Task_table)
def downgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
for table in tables:
table.drop()
drop_table(Task_table)
lib/galaxy/model/migrate/versions/0065_add_name_to_form_fields_and_values.py
+16 -26
View File
@@ -6,41 +6,36 @@ table, the 'content' column is now a JSON dict instead of a list.
from __future__ import print_function
import logging
import sys
from json import dumps, loads
from json import (
dumps,
loads
)
from sqlalchemy import MetaData, Table
from sqlalchemy import (
MetaData,
Table
)
from galaxy.model.custom_types import _sniffnfix_pg9_hex
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
metadata = MetaData()
def upgrade(migrate_engine):
metadata.bind = migrate_engine
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
try:
Table("form_definition", metadata, autoload=True)
except Exception:
log.exception("Loading 'form_definition' table failed.")
try:
Table("form_values", metadata, autoload=True)
except Exception:
log.exception("Loading 'form_values' table failed.")
Table("form_definition", metadata, autoload=True)
Table("form_values", metadata, autoload=True)
def get_value(lst, index):
try:
return str(lst[index]).replace("'", "''")
except IndexError:
return ''
# Go through the entire table and add a 'name' attribute for each field
# in the list of fields for each form definition
cmd = "SELECT f.id, f.fields FROM form_definition AS f"
@@ -89,14 +84,9 @@ def upgrade(migrate_engine):
def downgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
try:
Table("form_definition", metadata, autoload=True)
except Exception:
log.exception("Loading 'form_definition' table failed.")
try:
Table("form_values", metadata, autoload=True)
except Exception:
log.exception("Loading 'form_values' table failed.")
Table("form_definition", metadata, autoload=True)
Table("form_values", metadata, autoload=True)
# remove the name attribute in the content column JSON dict in the form_values table
# and restore it to a list of values
cmd = "SELECT form_values.id, form_values.content, form_definition.fields" \
lib/galaxy/model/migrate/versions/0067_populate_sequencer_table.py
+60 -93
View File
@@ -9,11 +9,22 @@ from __future__ import print_function
import logging
from json import dumps, loads
from sqlalchemy import Column, ForeignKey, Integer, MetaData, Table
from sqlalchemy.exc import NoSuchTableError
from sqlalchemy import (
Column,
ForeignKey,
Integer,
MetaData,
Table
)
from galaxy.model.custom_types import JSONType
from galaxy.model.migrate.versions.util import localtimestamp, nextval
from galaxy.model.migrate.versions.util import (
add_column,
drop_column,
engine_false,
localtimestamp,
nextval
)
log = logging.getLogger(__name__)
metadata = MetaData()
@@ -28,17 +39,6 @@ def get_latest_id(migrate_engine, table):
raise Exception('Unable to get the latest id in the %s table.' % table)
def boolean(migrate_engine, value):
if migrate_engine.name in ['mysql', 'postgres', 'postgresql']:
return value
elif migrate_engine.name == 'sqlite':
if value in ['True', 'true']:
return 1
return 0
else:
raise Exception('Unable to convert data for unknown database type: %s' % migrate_engine.name)
def create_sequencer_form_definition(migrate_engine):
'''
Create a new form_definition containing 5 fields (host, username, password,
@@ -46,12 +46,12 @@ def create_sequencer_form_definition(migrate_engine):
dict in the request_type table
'''
# create new form_definition_current in the db
cmd = "INSERT INTO form_definition_current VALUES ( %s, %s, %s, %s, %s )"
cmd = cmd % (nextval(migrate_engine, 'form_definition_current'),
localtimestamp(migrate_engine),
localtimestamp(migrate_engine),
'NULL',
boolean(migrate_engine, 'false'))
cmd = "INSERT INTO form_definition_current VALUES ( %s, %s, %s, %s, %s )" % (
nextval(migrate_engine, 'form_definition_current'),
localtimestamp(migrate_engine),
localtimestamp(migrate_engine),
'NULL',
engine_false(migrate_engine))
migrate_engine.execute(cmd)
# get this form_definition_current id
form_definition_current_id = get_latest_id(migrate_engine, 'form_definition_current')
@@ -149,17 +149,17 @@ def add_sequencer(migrate_engine, sequencer_index, sequencer_form_definition_id,
desc = ''
version = ''
sequencer_type_id = 'simple_unknown_sequencer'
cmd = "INSERT INTO sequencer VALUES ( %s, %s, %s, '%s', '%s', '%s', '%s', %s, %s, %s )"
cmd = cmd % (nextval(migrate_engine, 'sequencer'),
localtimestamp(migrate_engine),
localtimestamp(migrate_engine),
name,
desc,
sequencer_type_id,
version,
sequencer_form_definition_id,
sequencer_form_values_id,
boolean(migrate_engine, 'false'))
cmd = "INSERT INTO sequencer VALUES ( %s, %s, %s, '%s', '%s', '%s', '%s', %s, %s, %s )" % (
nextval(migrate_engine, 'sequencer'),
localtimestamp(migrate_engine),
localtimestamp(migrate_engine),
name,
desc,
sequencer_type_id,
version,
sequencer_form_definition_id,
sequencer_form_values_id,
engine_false(migrate_engine))
migrate_engine.execute(cmd)
return get_latest_id(migrate_engine, 'sequencer')
@@ -175,28 +175,10 @@ def upgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
try:
RequestType_table = Table("request_type", metadata, autoload=True)
except NoSuchTableError:
RequestType_table = None
log.debug("Failed loading table 'request_type'")
if RequestType_table is None:
return
# load the sequencer table
try:
Sequencer_table = Table("sequencer", metadata, autoload=True)
except NoSuchTableError:
Sequencer_table = None
log.debug("Failed loading table 'sequencer'")
if Sequencer_table is None:
return
RequestType_table = Table("request_type", metadata, autoload=True)
# create foreign key field to the sequencer table in the request_type table
try:
col = Column("sequencer_id", Integer, ForeignKey("sequencer.id"), nullable=True)
col.create(RequestType_table)
assert col is RequestType_table.c.sequencer_id
except Exception:
log.exception("Creating column 'sequencer_id' in the 'request_type' table failed.")
col = Column("sequencer_id", Integer, ForeignKey("sequencer.id"), nullable=True)
add_column(col, RequestType_table)
# copy the sequencer information contained in the 'datatx_info' column
# of the request_type table to the form values referenced in the sequencer table
cmd = "SELECT id, name, datatx_info FROM request_type ORDER BY id ASC"
@@ -231,50 +213,35 @@ def upgrade(migrate_engine):
sequencer_index = sequencer_index + 1
# Finally delete the 'datatx_info' column from the request_type table
try:
RequestType_table.c.datatx_info.drop()
except Exception:
log.exception("Deleting column 'datatx_info' in the 'request_type' table failed.")
drop_column('datatx_info', RequestType_table)
def downgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
try:
RequestType_table = Table("request_type", metadata, autoload=True)
except NoSuchTableError:
RequestType_table = None
log.debug("Failed loading table 'request_type'")
if RequestType_table is not None:
# create the 'datatx_info' column
try:
col = Column("datatx_info", JSONType())
col.create(RequestType_table)
assert col is RequestType_table.c.datatx_info
except Exception:
log.exception("Creating column 'datatx_info' in the 'request_type' table failed.")
# restore the datatx_info column data in the request_type table with data from
# the sequencer and the form_values table
cmd = "SELECT request_type.id, form_values.content "\
+ " FROM request_type, sequencer, form_values "\
+ " WHERE request_type.sequencer_id=sequencer.id AND sequencer.form_values_id=form_values.id "\
+ " ORDER BY request_type.id ASC"
result = migrate_engine.execute(cmd)
for row in result:
request_type_id = row[0]
seq_values = loads(str(row[1]))
# create the datatx_info json dict
datatx_info = dumps(dict(host=seq_values.get('field_0', ''),
username=seq_values.get('field_1', ''),
password=seq_values.get('field_2', ''),
data_dir=seq_values.get('field_3', ''),
rename_dataset=seq_values.get('field_4', '')))
# update the column
cmd = "UPDATE request_type SET datatx_info='%s' WHERE id=%i" % (datatx_info, request_type_id)
migrate_engine.execute(cmd)
# delete foreign key field to the sequencer table in the request_type table
try:
RequestType_table.c.sequencer_id.drop()
except Exception:
log.exception("Deleting column 'sequencer_id' in the 'request_type' table failed.")
RequestType_table = Table("request_type", metadata, autoload=True)
# create the 'datatx_info' column
col = Column("datatx_info", JSONType())
add_column(col, RequestType_table)
# restore the datatx_info column data in the request_type table with data from
# the sequencer and the form_values table
cmd = "SELECT request_type.id, form_values.content "\
+ " FROM request_type, sequencer, form_values "\
+ " WHERE request_type.sequencer_id=sequencer.id AND sequencer.form_values_id=form_values.id "\
+ " ORDER BY request_type.id ASC"
result = migrate_engine.execute(cmd)
for row in result:
request_type_id = row[0]
seq_values = loads(str(row[1]))
# create the datatx_info json dict
datatx_info = dumps(dict(host=seq_values.get('field_0', ''),
username=seq_values.get('field_1', ''),
password=seq_values.get('field_2', ''),
data_dir=seq_values.get('field_3', ''),
rename_dataset=seq_values.get('field_4', '')))
# update the column
cmd = "UPDATE request_type SET datatx_info='%s' WHERE id=%i" % (datatx_info, request_type_id)
migrate_engine.execute(cmd)
# delete foreign key field to the sequencer table in the request_type table
drop_column('sequencer_id', RequestType_table)
lib/galaxy/model/migrate/versions/0076_fix_form_values_data_corruption.py
-1
View File
@@ -86,5 +86,4 @@ def upgrade(migrate_engine):
def downgrade(migrate_engine):
metadata.bind = migrate_engine
pass
lib/galaxy/model/migrate/versions/0082_add_tool_shed_repository_table.py
+18 -19
View File
@@ -5,22 +5,25 @@ from __future__ import print_function
import datetime
import logging
import sys
from sqlalchemy import Boolean, Column, DateTime, Integer, MetaData, Table, TEXT
from sqlalchemy import (
Boolean,
Column,
DateTime,
Integer,
MetaData,
Table,
TEXT
)
# Need our custom types, but don't import anything else from model
from galaxy.model.custom_types import TrimmedString
from galaxy.model.migrate.versions.util import (
create_table,
drop_table
)
now = datetime.datetime.utcnow
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
now = datetime.datetime.utcnow
metadata = MetaData()
# New table to store information about cloned tool shed repositories.
@@ -40,16 +43,12 @@ def upgrade(migrate_engine):
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
try:
ToolShedRepository_table.create()
except Exception:
log.exception("Creating tool_shed_repository table failed.")
create_table(ToolShedRepository_table)
def downgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
try:
ToolShedRepository_table.drop()
except Exception:
log.exception("Dropping tool_shed_repository table failed.")
drop_table(ToolShedRepository_table)
lib/galaxy/model/migrate/versions/0086_add_tool_shed_repository_table_columns.py
+11 -10
View File
@@ -4,21 +4,22 @@ Migration script to add the metadata, update_available and includes_datatypes co
from __future__ import print_function
import logging
import sys
from sqlalchemy import Boolean, Column, MetaData, Table
from sqlalchemy import (
Boolean,
Column,
MetaData,
Table
)
from galaxy.model.custom_types import JSONType
from galaxy.model.migrate.versions.util import add_column, drop_column, engine_false
from galaxy.model.migrate.versions.util import (
add_column,
drop_column,
engine_false
)
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
metadata = MetaData()
lib/galaxy/model/migrate/versions/0087_tool_id_guid_map_table.py
+19 -20
View File
@@ -5,22 +5,25 @@ from __future__ import print_function
import datetime
import logging
import sys
from sqlalchemy import Column, DateTime, Integer, MetaData, String, Table, TEXT
from sqlalchemy import (
Column,
DateTime,
Integer,
MetaData,
String,
Table,
TEXT
)
# Need our custom types, but don't import anything else from model
from galaxy.model.custom_types import TrimmedString
from galaxy.model.migrate.versions.util import (
create_table,
drop_table
)
now = datetime.datetime.utcnow
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
now = datetime.datetime.utcnow
metadata = MetaData()
ToolIdGuidMap_table = Table("tool_id_guid_map", metadata,
@@ -36,19 +39,15 @@ ToolIdGuidMap_table = Table("tool_id_guid_map", metadata,
def upgrade(migrate_engine):
metadata.bind = migrate_engine
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
try:
ToolIdGuidMap_table.create()
except Exception:
log.exception("Creating tool_id_guid_map table failed.")
create_table(ToolIdGuidMap_table)
def downgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
try:
ToolIdGuidMap_table.drop()
except Exception:
log.exception("Dropping tool_id_guid_map table failed.")
drop_table(ToolIdGuidMap_table)
lib/galaxy/model/migrate/versions/0088_add_installed_changeset_revison_column.py
+14 -23
View File
@@ -4,35 +4,29 @@ Migration script to add the installed_changeset_revision column to the tool_shed
from __future__ import print_function
import logging
import sys
from sqlalchemy import Column, MetaData, Table
from sqlalchemy import (
Column,
MetaData
)
# Need our custom types, but don't import anything else from model
from galaxy.model.custom_types import TrimmedString
from galaxy.model.migrate.versions.util import (
add_column,
drop_column
)
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
metadata = MetaData()
def upgrade(migrate_engine):
metadata.bind = migrate_engine
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
ToolShedRepository_table = Table("tool_shed_repository", metadata, autoload=True)
col = Column("installed_changeset_revision", TrimmedString(255))
try:
col.create(ToolShedRepository_table)
assert col is ToolShedRepository_table.c.installed_changeset_revision
except Exception:
log.exception("Adding installed_changeset_revision column to the tool_shed_repository table failed.")
add_column(col, 'tool_shed_repository', metadata)
# Update each row by setting the value of installed_changeset_revison to be the value of changeset_revision.
# This will be problematic if the value of changeset_revision was updated to something other than the value
# that it was when the repository was installed (because the install path determined in real time will attempt to
@@ -50,14 +44,11 @@ def upgrade(migrate_engine):
+ "WHERE changeset_revision = '%s';" % row.changeset_revision
migrate_engine.execute(cmd)
update_count += 1
print("Updated the installed_changeset_revision column for ", update_count, " rows in the tool_shed_repository table. ")
print("Updated the installed_changeset_revision column for ", update_count, " rows in the tool_shed_repository table.")
def downgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
ToolShedRepository_table = Table("tool_shed_repository", metadata, autoload=True)
try:
ToolShedRepository_table.c.installed_changeset_revision.drop()
except Exception:
log.exception("Dropping column installed_changeset_revision from the tool_shed_repository table failed.")
drop_column('installed_changeset_revision', 'tool_shed_repository', metadata)
lib/galaxy/model/migrate/versions/0090_add_tool_shed_repository_table_columns.py
+15 -16
View File
@@ -4,20 +4,21 @@ Migration script to add the uninstalled and dist_to_shed columns to the tool_she
from __future__ import print_function
import logging
import sys
from sqlalchemy import Boolean, Column, MetaData, Table
from sqlalchemy import (
Boolean,
Column,
MetaData,
Table
)
from galaxy.model.migrate.versions.util import drop_column, engine_false
from galaxy.model.migrate.versions.util import (
add_column,
drop_column,
engine_false
)
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
metadata = MetaData()
@@ -28,19 +29,17 @@ def upgrade(migrate_engine):
ToolShedRepository_table = Table("tool_shed_repository", metadata, autoload=True)
c = Column("uninstalled", Boolean, default=False)
add_column(c, ToolShedRepository_table, metadata)
try:
c.create(ToolShedRepository_table)
assert c is ToolShedRepository_table.c.uninstalled
migrate_engine.execute("UPDATE tool_shed_repository SET uninstalled=%s" % engine_false(migrate_engine))
except Exception:
log.exception("Adding uninstalled column to the tool_shed_repository table failed.")
log.exception("Updating column 'uninstalled' of table 'tool_shed_repository' failed.")
c = Column("dist_to_shed", Boolean, default=False)
add_column(c, ToolShedRepository_table, metadata)
try:
c.create(ToolShedRepository_table)
assert c is ToolShedRepository_table.c.dist_to_shed
migrate_engine.execute("UPDATE tool_shed_repository SET dist_to_shed=%s" % engine_false(migrate_engine))
except Exception:
log.exception("Adding dist_to_shed column to the tool_shed_repository table failed.")
log.exception("Updating column 'dist_to_shed' of table 'tool_shed_repository' failed.")
def downgrade(migrate_engine):
lib/galaxy/model/migrate/versions/0091_add_tool_version_tables.py
+19 -12
View File
@@ -5,23 +5,30 @@ from __future__ import print_function
import datetime
import logging
import sys
from json import loads
from sqlalchemy import Column, DateTime, ForeignKey, Integer, MetaData, String, Table, TEXT
from sqlalchemy import (
Column,
DateTime,
ForeignKey,
Integer,
MetaData,
String,
Table,
TEXT
)
from galaxy.model.custom_types import _sniffnfix_pg9_hex, TrimmedString
from galaxy.model.migrate.versions.util import localtimestamp, nextval
from galaxy.model.custom_types import (
_sniffnfix_pg9_hex,
TrimmedString
)
from galaxy.model.migrate.versions.util import (
localtimestamp,
nextval
)
now = datetime.datetime.utcnow
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
now = datetime.datetime.utcnow
metadata = MetaData()
lib/galaxy/model/migrate/versions/0092_add_migrate_tools_table.py
+17 -19
View File
@@ -4,21 +4,22 @@ Migration script to create the migrate_tools table.
from __future__ import print_function
import logging
import sys
from sqlalchemy import Column, Integer, MetaData, Table, TEXT
from sqlalchemy import (
Column,
Integer,
MetaData,
Table,
TEXT
)
# Need our custom types, but don't import anything else from model
from galaxy.model.custom_types import TrimmedString
from galaxy.model.migrate.versions.util import (
create_table,
drop_table
)
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
metadata = MetaData()
MigrateTools_table = Table("migrate_tools", metadata,
@@ -28,23 +29,20 @@ MigrateTools_table = Table("migrate_tools", metadata,
def upgrade(migrate_engine):
metadata.bind = migrate_engine
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
# Create the table.
create_table(MigrateTools_table)
try:
MigrateTools_table.create()
cmd = "INSERT INTO migrate_tools VALUES ('GalaxyTools', 'lib/galaxy/tool_shed/migrate', %d)" % 1
migrate_engine.execute(cmd)
except Exception:
log.exception("Creating migrate_tools table failed.")
log.exception("Inserting into table 'migrate_tools' failed.")
def downgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
try:
MigrateTools_table.drop()
except Exception:
log.exception("Dropping migrate_tools table failed.")
drop_table(MigrateTools_table)
lib/galaxy/model/migrate/versions/0097_add_ctx_rev_column.py
+13 -22
View File
@@ -4,42 +4,33 @@ Migration script to add the ctx_rev column to the tool_shed_repository table.
from __future__ import print_function
import logging
import sys
from sqlalchemy import Column, MetaData, Table
from sqlalchemy import (
Column,
MetaData
)
# Need our custom types, but don't import anything else from model
from galaxy.model.custom_types import TrimmedString
from galaxy.model.migrate.versions.util import (
add_column,
drop_column
)
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
metadata = MetaData()
def upgrade(migrate_engine):
metadata.bind = migrate_engine
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
ToolShedRepository_table = Table("tool_shed_repository", metadata, autoload=True)
col = Column("ctx_rev", TrimmedString(10))
try:
col.create(ToolShedRepository_table)
assert col is ToolShedRepository_table.c.ctx_rev
except Exception:
log.exception("Adding ctx_rev column to the tool_shed_repository table failed.")
add_column(col, 'tool_shed_repository', metadata)
def downgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
ToolShedRepository_table = Table("tool_shed_repository", metadata, autoload=True)
try:
ToolShedRepository_table.c.ctx_rev.drop()
except Exception:
log.exception("Dropping column ctx_rev from the tool_shed_repository table failed.")
drop_column('ctx_rev', 'tool_shed_repository', metadata)
lib/galaxy/model/migrate/versions/0098_genome_index_tool_data_table.py
+14 -12
View File
@@ -5,24 +5,26 @@ from __future__ import print_function
import datetime
import logging
import sys
from sqlalchemy import Column, DateTime, ForeignKey, Integer, MetaData, String, Table
from sqlalchemy import (
Column,
DateTime,
ForeignKey,
Integer,
MetaData,
String,
Table
)
from galaxy.model.migrate.versions.util import create_table, drop_table
from galaxy.model.migrate.versions.util import (
create_table,
drop_table
)
now = datetime.datetime.utcnow
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
now = datetime.datetime.utcnow
metadata = MetaData()
# New table in changeset TODO:TODO
GenomeIndexToolData_table = Table("genome_index_tool_data", metadata,
Column("id", Integer, primary_key=True),
Column("job_id", Integer, ForeignKey("job.id"), index=True),
lib/galaxy/model/migrate/versions/0099_add_tool_dependency_table.py
+19 -19
View File
@@ -5,21 +5,25 @@ from __future__ import print_function
import datetime
import logging
import sys
from sqlalchemy import Boolean, Column, DateTime, ForeignKey, Integer, MetaData, Table
from sqlalchemy import (
Boolean,
Column,
DateTime,
ForeignKey,
Integer,
MetaData,
Table
)
from galaxy.model.custom_types import TrimmedString
from galaxy.model.migrate.versions.util import (
create_table,
drop_table
)
now = datetime.datetime.utcnow
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
now = datetime.datetime.utcnow
metadata = MetaData()
# New table to store information about cloned tool shed repositories.
@@ -36,19 +40,15 @@ ToolDependency_table = Table("tool_dependency", metadata,
def upgrade(migrate_engine):
metadata.bind = migrate_engine
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
try:
ToolDependency_table.create()
except Exception:
log.exception("Creating tool_dependency table failed.")
create_table(ToolDependency_table)
def downgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
try:
ToolDependency_table.drop()
except Exception:
log.exception("Dropping tool_dependency table failed.")
drop_table(ToolDependency_table)
lib/galaxy/model/migrate/versions/0100_alter_tool_dependency_table_version_column.py
+6 -10
View File
@@ -4,24 +4,21 @@ Migration script to alter the type of the tool_dependency.version column from Tr
from __future__ import print_function
import logging
import sys
from sqlalchemy import MetaData, Table
from sqlalchemy import (
MetaData,
Table
)
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
metadata = MetaData()
def upgrade(migrate_engine):
metadata.bind = migrate_engine
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
Table("tool_dependency", metadata, autoload=True)
# Change the tool_dependency table's version column from TrimmedString to Text.
if migrate_engine.name in ['postgres', 'postgresql']:
@@ -46,6 +43,5 @@ def upgrade(migrate_engine):
def downgrade(migrate_engine):
metadata.bind = migrate_engine
# Not necessary to change column type Text to TrimmedString(40).
pass
lib/galaxy/model/migrate/versions/0101_drop_installed_changeset_revision_column.py
-8
View File
@@ -4,7 +4,6 @@ Migration script to drop the installed_changeset_revision column from the tool_d
from __future__ import print_function
import logging
import sys
from sqlalchemy import (
Column,
@@ -18,13 +17,6 @@ from galaxy.model.migrate.versions.util import (
)
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
metadata = MetaData()
lib/galaxy/model/migrate/versions/0102_add_tool_dependency_status_columns.py
+11 -10
View File
@@ -4,21 +4,22 @@ Migration script to add status and error_message columns to the tool_dependency
from __future__ import print_function
import logging
import sys
from sqlalchemy import Boolean, Column, MetaData, Table, TEXT
from sqlalchemy import (
Boolean,
Column,
MetaData,
Table,
TEXT
)
from galaxy.model.custom_types import TrimmedString
from galaxy.model.migrate.versions.util import add_column, drop_column
from galaxy.model.migrate.versions.util import (
add_column,
drop_column
)
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
metadata = MetaData()
lib/galaxy/model/migrate/versions/0104_update_genome_downloader_job_parameters.py
+17 -12
View File
@@ -1,26 +1,30 @@
"""
Migration script to update the deferred job parameters for liftover transfer jobs.
"""
from __future__ import print_function
import datetime
import logging
import sys
from sqlalchemy import Column, DateTime, Integer, MetaData, String, Table
from sqlalchemy.orm import mapper, scoped_session, sessionmaker
from sqlalchemy import (
Column,
DateTime,
Integer,
MetaData,
String,
Table
)
from sqlalchemy.orm import (
mapper,
scoped_session,
sessionmaker
)
# Need our custom types, but don't import anything else from model
from galaxy.model.custom_types import JSONType
from galaxy.util.bunch import Bunch
now = datetime.datetime.utcnow
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
now = datetime.datetime.utcnow
metadata = MetaData()
context = scoped_session(sessionmaker(autoflush=False, autocommit=True))
@@ -51,6 +55,7 @@ mapper(DeferredJob, DeferredJob.table, properties={})
def upgrade(migrate_engine):
print(__doc__)
metadata.bind = migrate_engine
liftoverjobs = dict()
lib/galaxy/model/migrate/versions/0105_add_cleanup_event_table.py
+10 -11
View File
@@ -5,21 +5,20 @@ from __future__ import print_function
import datetime
import logging
import sys
from sqlalchemy import Column, DateTime, ForeignKey, Integer, MetaData, Table
from sqlalchemy import (
Column,
DateTime,
ForeignKey,
Integer,
MetaData,
Table
)
from galaxy.model.custom_types import TrimmedString
now = datetime.datetime.utcnow
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
now = datetime.datetime.utcnow
metadata = MetaData()
# New table to log cleanup events
@@ -84,8 +83,8 @@ CleanupEventImplicitlyConvertedDatasetAssociationAssociation_table = Table("clea
def upgrade(migrate_engine):
metadata.bind = migrate_engine
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
try:
CleanupEvent_table.create()
lib/galaxy/model/migrate/versions/0106_add_missing_indexes.py
-1
View File
@@ -13,7 +13,6 @@ from galaxy.model.migrate.versions.util import (
)
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
metadata = MetaData()
indexes = (
lib/galaxy/model/migrate/versions/0109_add_repository_dependency_tables.py
+20 -26
View File
@@ -5,19 +5,23 @@ from __future__ import print_function
import datetime
import logging
import sys
from sqlalchemy import Column, DateTime, ForeignKey, Integer, MetaData, Table
from sqlalchemy import (
Column,
DateTime,
ForeignKey,
Integer,
MetaData,
Table
)
from galaxy.model.migrate.versions.util import (
create_table,
drop_table
)
now = datetime.datetime.utcnow
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
now = datetime.datetime.utcnow
metadata = MetaData()
RepositoryDependency_table = Table("repository_dependency", metadata,
@@ -38,24 +42,14 @@ def upgrade(migrate_engine):
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
try:
RepositoryDependency_table.create()
except Exception:
log.exception("Creating repository_dependency table failed.")
try:
RepositoryRepositoryDependencyAssociation_table.create()
except Exception:
log.exception("Creating repository_repository_dependency_association table failed.")
create_table(RepositoryDependency_table)
create_table(RepositoryRepositoryDependencyAssociation_table)
def downgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
try:
RepositoryRepositoryDependencyAssociation_table.drop()
except Exception:
log.exception("Dropping repository_repository_dependency_association table failed.")
try:
RepositoryDependency_table.drop()
except Exception:
log.exception("Dropping repository_dependency table failed.")
drop_table(RepositoryRepositoryDependencyAssociation_table)
drop_table(RepositoryDependency_table)
lib/galaxy/model/migrate/versions/0112_add_data_manager_history_association_and_data_manager_job_association_tables.py
+12 -3
View File
@@ -6,11 +6,18 @@ from __future__ import print_function
import datetime
import logging
from sqlalchemy import Column, DateTime, ForeignKey, Integer, MetaData, Table, TEXT
from sqlalchemy import (
Column,
DateTime,
ForeignKey,
Integer,
MetaData,
Table,
TEXT
)
now = datetime.datetime.utcnow
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
now = datetime.datetime.utcnow
metadata = MetaData()
DataManagerHistoryAssociation_table = Table("data_manager_history_association", metadata,
@@ -32,6 +39,7 @@ def upgrade(migrate_engine):
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
try:
DataManagerHistoryAssociation_table.create()
log.debug("Created data_manager_history_association table")
@@ -47,6 +55,7 @@ def upgrade(migrate_engine):
def downgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
try:
DataManagerHistoryAssociation_table.drop()
log.debug("Dropped data_manager_history_association table")
lib/galaxy/model/migrate/versions/0113_update_migrate_tools_table.py
-7
View File
@@ -4,15 +4,8 @@ Migration script to update the migrate_tools.repository_path column to point to
from __future__ import print_function
import logging
import sys
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
def upgrade(migrate_engine):
lib/galaxy/model/migrate/versions/0114_update_migrate_tools_table_again.py
-7
View File
@@ -4,15 +4,8 @@ Migration script to update the migrate_tools.repository_path column to point to
from __future__ import print_function
import logging
import sys
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
def upgrade(migrate_engine):
lib/galaxy/model/migrate/versions/0116_drop_update_available_col_add_tool_shed_status_col.py
+27 -37
View File
@@ -4,22 +4,22 @@ Migration script to drop the update_available Boolean column and replace it with
from __future__ import print_function
import logging
import sys
from sqlalchemy import Boolean, Column, MetaData, Table
from sqlalchemy.exc import NoSuchTableError
from sqlalchemy import (
Boolean,
Column,
MetaData,
Table
)
from galaxy.model.custom_types import JSONType
from galaxy.model.migrate.versions.util import add_column, drop_column, engine_false
from galaxy.model.migrate.versions.util import (
add_column,
drop_column,
engine_false
)
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
format = "%(name)s %(levelname)s %(asctime)s %(message)s"
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
log.addHandler(handler)
metadata = MetaData()
@@ -28,35 +28,25 @@ def upgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
try:
ToolShedRepository_table = Table("tool_shed_repository", metadata, autoload=True)
except NoSuchTableError:
ToolShedRepository_table = None
log.debug("Failed loading table tool_shed_repository")
if ToolShedRepository_table is not None:
# SQLAlchemy Migrate has a bug when dropping a boolean column in SQLite
if migrate_engine.name != 'sqlite':
drop_column('update_available', ToolShedRepository_table)
c = Column("tool_shed_status", JSONType, nullable=True)
add_column(c, ToolShedRepository_table)
ToolShedRepository_table = Table("tool_shed_repository", metadata, autoload=True)
# SQLAlchemy Migrate has a bug when dropping a boolean column in SQLite
if migrate_engine.name != 'sqlite':
drop_column('update_available', ToolShedRepository_table)
c = Column("tool_shed_status", JSONType, nullable=True)
add_column(c, ToolShedRepository_table)
def downgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
try:
ToolShedRepository_table = Table("tool_shed_repository", metadata, autoload=True)
except NoSuchTableError:
ToolShedRepository_table = None
log.debug("Failed loading table tool_shed_repository")
if ToolShedRepository_table is not None:
# For some unknown reason it is no longer possible to drop a column in a migration script if using the sqlite database.
if migrate_engine.name != 'sqlite':
drop_column('tool_shed_status', ToolShedRepository_table)
c = Column("update_available", Boolean, default=False)
add_column(c, ToolShedRepository_table)
try:
migrate_engine.execute("UPDATE tool_shed_repository SET update_available=%s" % engine_false(migrate_engine))
except Exception:
log.exception("Updating column 'update_available' of table 'tool_shed_repository' failed.")
ToolShedRepository_table = Table("tool_shed_repository", metadata, autoload=True)
# For some unknown reason it is no longer possible to drop a column in a migration script if using the sqlite database.
if migrate_engine.name != 'sqlite':
drop_column('tool_shed_status', ToolShedRepository_table)
c = Column("update_available", Boolean, default=False)
add_column(c, ToolShedRepository_table)
try:
migrate_engine.execute("UPDATE tool_shed_repository SET update_available=%s" % engine_false(migrate_engine))
except Exception:
log.exception("Updating column 'update_available' of table 'tool_shed_repository' failed.")
lib/galaxy/model/migrate/versions/0119_job_metrics.py
+13 -2
View File
@@ -5,9 +5,20 @@ from __future__ import print_function
import logging
from sqlalchemy import Column, ForeignKey, Integer, MetaData, Numeric, Table, Unicode
from sqlalchemy import (
Column,
ForeignKey,
Integer,
MetaData,
Numeric,
Table,
Unicode
)
from galaxy.model.migrate.versions.util import create_table, drop_table
from galaxy.model.migrate.versions.util import (
create_table,
drop_table
)
log = logging.getLogger(__name__)
metadata = MetaData()
lib/galaxy/model/migrate/versions/0120_dataset_collections.py
+21 -16
View File
@@ -6,10 +6,25 @@ from __future__ import print_function
import datetime
import logging
from sqlalchemy import Boolean, Column, DateTime, ForeignKey, Integer, MetaData, Table, TEXT, Unicode
from sqlalchemy import (
Boolean,
Column,
DateTime,
ForeignKey,
Integer,
MetaData,
Table,
TEXT,
Unicode
)
from galaxy.model.custom_types import TrimmedString
from galaxy.model.migrate.versions.util import create_table, drop_table
from galaxy.model.migrate.versions.util import (
add_column,
create_table,
drop_column,
drop_table
)
now = datetime.datetime.utcnow
log = logging.getLogger(__name__)
@@ -108,9 +123,6 @@ ImplicitlyCreatedDatasetCollectionInput_table = Table("implicitly_created_datase
Column("input_dataset_collection_id", Integer, ForeignKey("history_dataset_collection_association.id"), index=True),
Column("name", Unicode(255)))
# TODO: Find a better name for this column...
HiddenBeneathCollection_column = Column("hidden_beneath_collection_instance_id", Integer, ForeignKey("history_dataset_collection_association.id"), nullable=True)
TABLES = [
DatasetCollection_table,
@@ -137,23 +149,16 @@ def upgrade(migrate_engine):
for table in TABLES:
create_table(table)
try:
hda_table = Table("history_dataset_association", metadata, autoload=True)
HiddenBeneathCollection_column.create(hda_table)
except Exception:
log.exception("Creating HDA column failed.")
# TODO: Find a better name for this column...
HiddenBeneathCollection_column = Column("hidden_beneath_collection_instance_id", Integer, ForeignKey("history_dataset_collection_association.id"), nullable=True)
add_column(HiddenBeneathCollection_column, 'history_dataset_association', metadata)
def downgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
try:
hda_table = Table("history_dataset_association", metadata, autoload=True)
hidden_beneath_collection_instance_id_col = hda_table.c.hidden_beneath_collection_instance_id
hidden_beneath_collection_instance_id_col.drop()
except Exception:
log.exception("Dropping HDA column failed.")
drop_column('hidden_beneath_collection_instance_id', 'history_dataset_association', metadata)
for table in reversed(TABLES):
drop_table(table)
lib/galaxy/model/migrate/versions/0123_add_workflow_request_tables.py
+22 -4
View File
@@ -5,10 +5,28 @@ from __future__ import print_function
import logging
from sqlalchemy import Column, ForeignKey, Integer, MetaData, String, Table, TEXT, Unicode
from sqlalchemy import (
Column,
ForeignKey,
Integer,
MetaData,
String,
Table,
TEXT,
Unicode
)
from galaxy.model.custom_types import JSONType, TrimmedString, UUIDType
from galaxy.model.migrate.versions.util import add_column, create_table, drop_column, drop_table
from galaxy.model.custom_types import (
JSONType,
TrimmedString,
UUIDType
)
from galaxy.model.migrate.versions.util import (
add_column,
create_table,
drop_column,
drop_table
)
log = logging.getLogger(__name__)
metadata = MetaData()
@@ -62,8 +80,8 @@ TABLES = [
def upgrade(migrate_engine):
metadata.bind = migrate_engine
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
for table in TABLES:
lib/galaxy/model/migrate/versions/0127_output_collection_adjustments.py
+17 -11
View File
@@ -5,10 +5,23 @@ from __future__ import print_function
import logging
from sqlalchemy import Column, ForeignKey, Integer, MetaData, Table, TEXT, Unicode
from sqlalchemy import (
Column,
ForeignKey,
Integer,
MetaData,
Table,
TEXT,
Unicode
)
from galaxy.model.custom_types import TrimmedString
from galaxy.model.migrate.versions.util import add_column, create_table, drop_column, drop_table
from galaxy.model.migrate.versions.util import (
add_column,
create_table,
drop_column,
drop_table
)
log = logging.getLogger(__name__)
metadata = MetaData()
@@ -22,18 +35,12 @@ JobToImplicitOutputDatasetCollectionAssociation_table = Table(
)
TABLES = [
JobToImplicitOutputDatasetCollectionAssociation_table,
]
def upgrade(migrate_engine):
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
for table in TABLES:
create_table(table)
create_table(JobToImplicitOutputDatasetCollectionAssociation_table)
dataset_collection_table = Table("dataset_collection", metadata, autoload=True)
# need server_default because column in non-null
@@ -48,8 +55,7 @@ def downgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
for table in TABLES:
drop_table(table)
drop_table(JobToImplicitOutputDatasetCollectionAssociation_table)
dataset_collection_table = Table("dataset_collection", metadata, autoload=True)
drop_column('populated_state', dataset_collection_table)
lib/galaxy/model/migrate/versions/0136_collection_and_workflow_state.py
+25 -19
View File
@@ -5,16 +5,26 @@ from __future__ import print_function
import datetime
import logging
from collections import OrderedDict
from sqlalchemy import Column, ForeignKey, Integer, MetaData, String, Table
from sqlalchemy import (
Column,
ForeignKey,
Integer,
MetaData,
String,
Table
)
from galaxy.model.custom_types import TrimmedString
from galaxy.model.migrate.versions.util import add_column, create_table, drop_column, drop_table
now = datetime.datetime.utcnow
from galaxy.model.migrate.versions.util import (
add_column,
create_table,
drop_column,
drop_table
)
log = logging.getLogger(__name__)
now = datetime.datetime.utcnow
metadata = MetaData()
workflow_invocation_output_dataset_association_table = Table(
@@ -71,16 +81,14 @@ def get_new_tables():
# Normally we define this globally in the file, but we need to delay the
# reading of existing tables because an existing workflow_invocation_step
# table exists that we want to recreate.
tables = OrderedDict()
tables["workflow_invocation_output_dataset_association"] = workflow_invocation_output_dataset_association_table
tables["workflow_invocation_output_dataset_collection_association"] = workflow_invocation_output_dataset_collection_association_table
tables["workflow_invocation_step_output_dataset_association"] = workflow_invocation_step_output_dataset_association_table
tables["workflow_invocation_step_output_dataset_collection_association"] = workflow_invocation_step_output_dataset_collection_association_table
tables["implicit_collection_jobs"] = implicit_collection_jobs_table
tables["implicit_collection_jobs_job_association"] = implicit_collection_jobs_job_association_table
return tables
return [
workflow_invocation_output_dataset_association_table,
workflow_invocation_output_dataset_collection_association_table,
workflow_invocation_step_output_dataset_association_table,
workflow_invocation_step_output_dataset_collection_association_table,
implicit_collection_jobs_table,
implicit_collection_jobs_job_association_table
]
def upgrade(migrate_engine):
@@ -88,8 +96,7 @@ def upgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
tables = get_new_tables()
for table in tables.values():
for table in get_new_tables():
create_table(table)
# Set default for creation to scheduled, actual mapping has new as default.
@@ -127,6 +134,5 @@ def downgrade(migrate_engine):
drop_column("state", "workflow_invocation_step", metadata)
drop_column("element_count", "dataset_collection", metadata)
tables = get_new_tables()
for table in reversed(list(tables.values())):
for table in reversed(get_new_tables()):
drop_table(table)
lib/galaxy/model/migrate/versions/0139_add_history_dataset_association_history_table.py
+21 -14
View File
@@ -6,13 +6,26 @@ from __future__ import print_function
import datetime
import logging
from sqlalchemy import Column, DateTime, ForeignKey, Integer, MetaData, Table
from sqlalchemy import (
Column,
DateTime,
ForeignKey,
Integer,
MetaData,
Table
)
from galaxy.model.custom_types import MetadataType, TrimmedString
from galaxy.model.custom_types import (
MetadataType,
TrimmedString
)
from galaxy.model.migrate.versions.util import (
create_table,
drop_table
)
now = datetime.datetime.utcnow
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
now = datetime.datetime.utcnow
metadata = MetaData()
HistoryDatasetAssociationHistory_table = Table(
@@ -32,18 +45,12 @@ def upgrade(migrate_engine):
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
try:
HistoryDatasetAssociationHistory_table.create()
log.debug("Created history_dataset_association_history table")
except Exception:
log.exception("Creating history_dataset_association_history table failed.")
create_table(HistoryDatasetAssociationHistory_table)
def downgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
try:
HistoryDatasetAssociationHistory_table.drop()
log.debug("Dropped history_dataset_association_history table")
except Exception:
log.exception("Dropping history_dataset_association_history table failed.")
drop_table(HistoryDatasetAssociationHistory_table)
lib/galaxy/model/migrate/versions/0144_add_cleanup_event_user_table.py
+15 -13
View File
@@ -6,12 +6,22 @@ from __future__ import print_function
import datetime
import logging
from sqlalchemy import Column, DateTime, ForeignKey, Integer, MetaData, Table
from sqlalchemy import (
Column,
DateTime,
ForeignKey,
Integer,
MetaData,
Table
)
from galaxy.model.migrate.versions.util import (
create_table,
drop_table
)
now = datetime.datetime.utcnow
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
metadata = MetaData()
# New table to log cleanup events
@@ -28,19 +38,11 @@ def upgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
try:
CleanupEventUserAssociation_table.create()
log.debug("Created cleanup_event_user_association table")
except Exception:
log.exception("Creating cleanup_event_user_association table failed.")
create_table(CleanupEventUserAssociation_table)
def downgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
try:
CleanupEventUserAssociation_table.drop()
log.debug("Dropped cleanup_event_user_association table")
except Exception:
log.exception("Dropping cleanup_event_user_association table failed.")
drop_table(CleanupEventUserAssociation_table)
lib/galaxy/model/migrate/versions/0145_add_workflow_step_input.py
+4 -1
View File
@@ -17,7 +17,10 @@ from sqlalchemy import (
)
from galaxy.model.custom_types import JSONType
from galaxy.model.migrate.versions.util import create_table, drop_table
from galaxy.model.migrate.versions.util import (
create_table,
drop_table
)
log = logging.getLogger(__name__)
metadata = MetaData()
lib/galaxy/model/migrate/versions/0147_job_messages.py
+6 -1
View File
@@ -5,7 +5,12 @@ from __future__ import print_function
import logging
from sqlalchemy import Column, MetaData, Table, TEXT
from sqlalchemy import (
Column,
MetaData,
Table,
TEXT
)
from galaxy.model.custom_types import JSONType
from galaxy.model.migrate.versions.util import (
lib/galaxy/model/migrate/versions/0148_add_checksum_table.py
+18 -15
View File
@@ -5,13 +5,22 @@ from __future__ import print_function
import logging
from sqlalchemy import Column, ForeignKey, Integer, MetaData, Table, TEXT
from sqlalchemy import (
Column,
ForeignKey,
Integer,
MetaData,
Table,
TEXT
)
from galaxy.model.custom_types import JSONType
from galaxy.model.migrate.versions.util import (
create_table,
drop_table
)
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
metadata = MetaData()
dataset_source_table = Table(
@@ -45,20 +54,14 @@ def upgrade(migrate_engine):
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
try:
dataset_source_table.create()
dataset_hash_table.create()
dataset_source_hash_table.create()
except Exception:
log.exception("Adding dataset source and hash tables failed.")
create_table(dataset_source_table)
create_table(dataset_hash_table)
create_table(dataset_source_hash_table)
def downgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
try:
dataset_source_hash_table.drop()
dataset_hash_table.drop()
dataset_source_table.drop()
except Exception:
log.exception("Dropping dataset source and hash tables failed.")
drop_table(dataset_source_hash_table)
drop_table(dataset_hash_table)
drop_table(dataset_source_table)
lib/galaxy/model/migrate/versions/0149_dynamic_tools.py
+3 -10
View File
@@ -9,8 +9,8 @@ from sqlalchemy import Boolean, Column, DateTime, ForeignKey, Integer, MetaData,
from galaxy.model.custom_types import JSONType, UUIDType
from galaxy.model.migrate.versions.util import add_column, create_table, drop_column, drop_table
now = datetime.datetime.utcnow
log = logging.getLogger(__name__)
now = datetime.datetime.utcnow
metadata = MetaData()
@@ -30,18 +30,13 @@ DynamicTool_table = Table(
Column("value", JSONType()),
)
TABLES = [
DynamicTool_table,
]
def upgrade(migrate_engine):
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
for table in TABLES:
create_table(table)
create_table(DynamicTool_table)
if migrate_engine.name in ['postgres', 'postgresql']:
workflow_dynamic_tool_id_column = Column("dynamic_tool_id", Integer, ForeignKey("dynamic_tool.id"), nullable=True)
@@ -60,6 +55,4 @@ def downgrade(migrate_engine):
drop_column("dynamic_tool_id", "workflow_step", metadata)
drop_column("dynamic_tool_id", "job", metadata)
for table in TABLES:
drop_table(table)
drop_table(DynamicTool_table)
lib/galaxy/model/migrate/versions/0151_add_worker_process.py
+4 -1
View File
@@ -15,7 +15,10 @@ from sqlalchemy import (
UniqueConstraint,
)
from galaxy.model.migrate.versions.util import create_table, drop_table
from galaxy.model.migrate.versions.util import (
create_table,
drop_table
)
from galaxy.model.orm.now import now
log = logging.getLogger(__name__)
lib/galaxy/model/migrate/versions/0152_add_metadata_file_uuid.py
+8 -2
View File
@@ -6,10 +6,16 @@ from __future__ import print_function
import logging
from sqlalchemy import Column, MetaData
from sqlalchemy import (
Column,
MetaData
)
from galaxy.model.custom_types import UUIDType
from galaxy.model.migrate.versions.util import add_column, drop_column
from galaxy.model.migrate.versions.util import (
add_column,
drop_column
)
log = logging.getLogger(__name__)
lib/galaxy/model/migrate/versions/0153_add_custos_authnz_token_table.py
+18 -10
View File
@@ -5,8 +5,22 @@ from __future__ import print_function
import logging
from sqlalchemy import (Column, DateTime, ForeignKey, Integer, MetaData,
String, Table, Text, UniqueConstraint)
from sqlalchemy import (
Column,
DateTime,
ForeignKey,
Integer,
MetaData,
String,
Table,
Text,
UniqueConstraint
)
from galaxy.model.migrate.versions.util import (
create_table,
drop_table
)
log = logging.getLogger(__name__)
metadata = MetaData()
@@ -32,17 +46,11 @@ def upgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
try:
CustosAuthnzToken_table.create()
except Exception:
log.exception("Failed to create custos_authnz_token table")
create_table(CustosAuthnzToken_table)
def downgrade(migrate_engine):
metadata.bind = migrate_engine
metadata.reflect()
try:
CustosAuthnzToken_table.drop()
except Exception:
log.exception("Failed to drop custos_authnz_token table")
drop_table(CustosAuthnzToken_table)
lib/galaxy/model/migrate/versions/0154_created_from_basename.py
+11 -4
View File
@@ -4,18 +4,25 @@ Adds created_from_basename to dataset.
import datetime
import logging
from sqlalchemy import Column, MetaData, TEXT
from sqlalchemy import (
Column,
MetaData,
TEXT
)
from galaxy.model.migrate.versions.util import add_column, drop_column
from galaxy.model.migrate.versions.util import (
add_column,
drop_column
)
now = datetime.datetime.utcnow
log = logging.getLogger(__name__)
now = datetime.datetime.utcnow
metadata = MetaData()
def upgrade(migrate_engine):
metadata.bind = migrate_engine
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
created_from_basename_column = Column("created_from_basename", TEXT, default=None)
lib/galaxy/model/migrate/versions/0155_job_galaxy_version.py
+13 -4
View File
@@ -1,21 +1,30 @@
"""
Add 'galaxy_version' attribute to Job table.
"""
from __future__ import print_function
import datetime
import logging
from sqlalchemy import Column, MetaData, String
from sqlalchemy import (
Column,
MetaData,
String
)
from galaxy.model.migrate.versions.util import add_column, drop_column
from galaxy.model.migrate.versions.util import (
add_column,
drop_column
)
now = datetime.datetime.utcnow
log = logging.getLogger(__name__)
now = datetime.datetime.utcnow
metadata = MetaData()
def upgrade(migrate_engine):
metadata.bind = migrate_engine
print(__doc__)
metadata.bind = migrate_engine
metadata.reflect()
created_from_basename_column = Column("galaxy_version", String(64), default=None)
lib/galaxy/model/migrate/versions/util.py
+8 -1
View File
@@ -51,8 +51,15 @@ def create_table(table):
log.exception("Creating table '%s' failed.", table)
def drop_table(table):
def drop_table(table, metadata=None):
"""
:param table: Table to drop
:type table: :class:`Table` or str
"""
try:
if not isinstance(table, Table):
assert metadata is not None
table = Table(table, metadata, autoload=True)
table.drop()
except Exception:
log.exception("Dropping table '%s' failed.", table)