Python ForeignKeyConstraint.drop方法代码示例

# 需要导入模块: from migrate.changeset.constraint import ForeignKeyConstraint [as 别名]
# 或者: from migrate.changeset.constraint.ForeignKeyConstraint import drop [as 别名]
def upgrade(migrate_engine):
    # Upgrade operations go here. Don't create your own engine; bind
    # migrate_engine to your metadata
    debug = False
    migrate_engine.echo=debug
    meta.bind = migrate_engine
    real_meta = MetaData()
    real_meta.bind = migrate_engine
    real_meta.reflect()
    rt = real_meta.tables['authentication_userrole']
    for ctraint in deepcopy(rt.foreign_keys):
        if 'fk_userrole_user'  in ctraint.name:
            column = ctraint.column
            parent = ctraint.parent
            fk = ForeignKeyConstraint([parent], [column], **{'table': rt})
            fk.name = ctraint.name
            fk.drop()
    fkp = [a for a in UserRole.__table__.foreign_keys if a.name == 'fk_userrole_users'][0]
    fk = ForeignKeyConstraint([fkp.parent], [fkp.column], **{'table': fkp.parent.table})
    fk.name =      fkp.name
    fk.use_alter = fkp.use_alter
    fk.ondelete =  fkp.ondelete
    fk.onupdate =  fkp.onupdate
    fk.create()
    new_meta = MetaData(bind=migrate_engine)
    new_meta.reflect()

# 需要导入模块: from migrate.changeset.constraint import ForeignKeyConstraint [as 别名]
# 或者: from migrate.changeset.constraint.ForeignKeyConstraint import drop [as 别名]
def drop_constraints_and_alter_types():
    # 1 drop all foreign key constraints
    dropped_fk_constraints = []
    revision_table = Table('revision', metadata, autoload=True)
    foreign_tables = ['package', 'package_tag', 'package_revision', 'package_tag_revision', 'package_extra', 'package_extra_revision', ]
    for table_name in foreign_tables:
        table = Table(table_name, metadata, autoload=True)
        for constraint in table.constraints.copy():
            if isinstance(constraint, sqlalchemy.schema.ForeignKeyConstraint):
                foreign_key_cols = [key.column for key in constraint.elements]
                fk_col = foreign_key_cols[0]
                if fk_col.table == revision_table:
                    orig_fk = ForeignKeyConstraint(constraint.columns, foreign_key_cols, name=constraint.name, table=table)
                    orig_fk.drop()
                    dropped_fk_constraints.append((constraint.columns, foreign_key_cols, constraint.name, table.name))

    # 2 alter type of revision id and foreign keys
                    id_col = constraint.table.columns[constraint.columns[0]]
                    id_col.alter(type=UnicodeText)

    revision_table = Table('revision', metadata, autoload=True)
    id_col = revision_table.c['id']
    id_col.alter(type=UnicodeText,
                 )

    return dropped_fk_constraints

# 需要导入模块: from migrate.changeset.constraint import ForeignKeyConstraint [as 别名]
# 或者: from migrate.changeset.constraint.ForeignKeyConstraint import drop [as 别名]
def drop_constraints_and_alter_types(primary_table_name, foreign_tables, revision_table_name):
    # 1 drop all foreign key constraints
    dropped_fk_constraints = []
    primary_table = Table(primary_table_name, metadata, autoload=True)
    for table_name in foreign_tables:
        table = Table(table_name, metadata, autoload=True)
        for constraint in table.constraints.copy():
            if isinstance(constraint, sqlalchemy.schema.ForeignKeyConstraint):
                foreign_key_cols = [key.column for key in constraint.elements]
                fk_col = foreign_key_cols[0]
                if fk_col.table == primary_table:
                    orig_fk = ForeignKeyConstraint(constraint.columns, foreign_key_cols, name=constraint.name, table=table)
                    orig_fk.drop()
                    dropped_fk_constraints.append((constraint.columns, foreign_key_cols, constraint.name, table.name))
                    #print 'CON', dropped_fk_constraints[-1]

    # 2 alter type of primary table id and foreign keys
                    id_col = constraint.table.columns[constraint.columns[0]]
                    id_col.alter(type=UnicodeText)

    primary_table = Table(primary_table_name, metadata, autoload=True)
    id_col = primary_table.c['id']
    id_col.alter(type=UnicodeText)

    if revision_table_name:
        # Revision table id column type changed as well
        revision_table = Table(revision_table_name, metadata, autoload=True)
        id_col = revision_table.c['id']
        id_col.alter(type=UnicodeText)

    return dropped_fk_constraints

# 需要导入模块: from migrate.changeset.constraint import ForeignKeyConstraint [as 别名]
# 或者: from migrate.changeset.constraint.ForeignKeyConstraint import drop [as 别名]
def downgrade(migrate_engine):
    # Operations to reverse the above upgrade go here.
    meta = MetaData(bind=migrate_engine)
    mt = Table('meas_MeasurementTable', meta, autoload=True)
    et = Table('meas_ExtractionTable', meta, autoload=True)
    st = Table('meas_ScriptTable', meta, autoload=True)

    fk = ForeignKeyConstraint([mt.c.script_id], [st.c.id])
    fk.drop()
    fk = ForeignKeyConstraint([et.c.script_id], [st.c.id])
    fk.drop()

    st.drop()

    c = Column('script_blob', BLOB)
    c.create(mt)
    c = Column('hash', String(32))
    c.create(mt)
    c = Column('script_name', String(80))
    c.create(mt)
# #
    c = Column('script_blob', BLOB)
    c.create(et)
    c = Column('hash', String(32))
    c.create(et)
    c = Column('script_name', BLOB)
    c.create(et)

    mt.c.script_id.drop()
    et.c.script_id.drop()

# 需要导入模块: from migrate.changeset.constraint import ForeignKeyConstraint [as 别名]
# 或者: from migrate.changeset.constraint.ForeignKeyConstraint import drop [as 别名]
def upgrade(migrate_engine):
    metadata = sa.MetaData()
    metadata.bind = migrate_engine

    builders = sautils.Table('builders', metadata, autoload=True)
    masters = sautils.Table('masters', metadata, autoload=True)
    workers = sautils.Table('workers', metadata, autoload=True)
    builder_masters = sautils.Table('builder_masters', metadata, autoload=True)
    configured_workers = sautils.Table('configured_workers', metadata,
                                       autoload=True)
    fks_to_change = []
    # we need to parse the reflected model in order to find the automatic fk name that was put
    # mysql and pgsql have different naming convention so this is not very easy to have generic code working.
    for table, keys in [(builder_masters, (builders.c.id, masters.c.id)),
                        (configured_workers, (builder_masters.c.id, workers.c.id))]:
        for fk in table.constraints:
            if not isinstance(fk, sa.ForeignKeyConstraint):
                continue
            for c in fk.elements:
                if c.column in keys:
                    # migrate.xx.ForeignKeyConstraint is changing the model so initializing here
                    # would break the iteration (Set changed size during iteration)
                    fks_to_change.append((
                        table, (fk.columns, [c.column]), dict(name=fk.name, ondelete='CASCADE')))

    for table, args, kwargs in fks_to_change:
        fk = ForeignKeyConstraint(*args, **kwargs)
        table.append_constraint(fk)
        try:
            fk.drop()
        except NotSupportedError:
            pass  # some versions of sqlite do not support drop, but will still update the fk
        fk.create()

# 需要导入模块: from migrate.changeset.constraint import ForeignKeyConstraint [as 别名]
# 或者: from migrate.changeset.constraint.ForeignKeyConstraint import drop [as 别名]
def upgrade(migrate_engine):
    class AuthUserLog(Base):
        """
        event:
          L - Login
          R - Register
          P - Password
          F - Forgot
        """
        __tablename__ = 'auth_user_log'
        __table_args__ = {"sqlite_autoincrement": True}

        id = Column(Integer, primary_key=True)
        user_id = Column(Integer, ForeignKey("auth_users.id", onupdate='CASCADE', ondelete='CASCADE'), index=True)
        time = Column(DateTime(), default=func.now())
        ip_addr = Column(Unicode(39), nullable=False)
        internal_user = Column(Boolean, nullable=False, default=False)
        external_user = Column(Boolean, nullable=False, default=False)
        event = Column(Enum(u'L',u'R',u'P',u'F', name=u"event"), default=u'L')

    recreate_constraints = [AuthUserLog]
    # Upgrade operations go here. Don't create your own engine; bind
    # migrate_engine to your metadata
    debug = True
    session.configure(bind=migrate_engine)
    migrate_engine.echo=debug
    metadata.bind = migrate_engine
    metadata.reflect(only=['auth_users'])
    r_meta = s.MetaData(migrate_engine, True)
    def commit():
        session.commit()
        r_meta.bind.execute  ('COMMIT;')
        metadata.bind.execute('COMMIT;')
    # create constraints
    fks = []
    for md in recreate_constraints:
        t = md.__table__
        rt = r_meta.tables[t.name]
        rt_constraints = [a for a in rt.foreign_keys]
        for cs in deepcopy(t.foreign_keys):
            if cs.__class__.__name__ == 'ForeignKey':
                table, column = cs.target_fullname.split('.')
                target = [r_meta.tables[table].c[column]]
                parent = [r_meta.tables[cs.parent.table.name].c[cs.parent.name]]
                fk = ForeignKeyConstraint(columns=parent,refcolumns=target)
                fk.use_alter = cs.use_alter
                fk.ondelete = 'CASCADE'
                fk.onupdate = 'CASCADE'
                fk.name = cs.name
                fks.append(fk)
                if (cs.name in [a.name for a in rt_constraints]
                    or (cs.target_fullname
                        in [a.target_fullname for a in rt_constraints])):
                    fk.drop(migrate_engine)
                    commit()

    for fk in fks:
        fk.create(migrate_engine)
        commit()

# 需要导入模块: from migrate.changeset.constraint import ForeignKeyConstraint [as 别名]
# 或者: from migrate.changeset.constraint.ForeignKeyConstraint import drop [as 别名]
def downgrade(migrate_engine):
    meta = MetaData(bind=migrate_engine)

    pci_devices = Table("pci_devices", meta, autoload=True)
    compute_nodes = Table("compute_nodes", meta, autoload=True)

    fkey = ForeignKeyConstraint(columns=[pci_devices.c.compute_node_id], refcolumns=[compute_nodes.c.id])
    fkey.drop()

# 需要导入模块: from migrate.changeset.constraint import ForeignKeyConstraint [as 别名]
# 或者: from migrate.changeset.constraint.ForeignKeyConstraint import drop [as 别名]
def drop_foreign_key_constraints(constraint_names, columns, ref_columns):
    """Drop the foreign key constraints that match the given
    criteria.
    :param constraint_names: List of foreign key constraint names
    :param columns: List of the foreign key columns.
    :param ref_columns: List of the referenced columns.
    """
    for constraint_name in constraint_names:
        fkey_constraint = ForeignKeyConstraint(columns=columns, refcolumns=ref_columns, name=constraint_name)
        fkey_constraint.drop()

# 需要导入模块: from migrate.changeset.constraint import ForeignKeyConstraint [as 别名]
# 或者: from migrate.changeset.constraint.ForeignKeyConstraint import drop [as 别名]
def upgrade(migrate_engine):
    # Upgrade operations go here. Don't create your own engine; bind
    # migrate_engine to your metadata
    debug = False
    migrate_engine.echo=debug
    meta.bind = migrate_engine
    real_meta = MetaData()
    real_meta.bind = migrate_engine
    real_meta.reflect()
    # finally i decided to go to a separate permission table
    if 'authentication_permission' not in real_meta.tables:
        permission.create()
    for acl, item in ((aclusers, 'users'), (aclprojects, 'projects')):
        rt = real_meta.tables[acl.name]
        for ctraint in deepcopy(rt.foreign_keys):
            if ('perm' in ctraint.name) or ('perm' in ctraint.parent.name):
                column = ctraint.column
                parent = ctraint.parent
                fk = ForeignKeyConstraint([parent], [column], **{'table': rt})
                fk.name = ctraint.name
                fk.drop()
        if 'permission' in rt.c:
            if len(rt.c["permission"].foreign_keys) > 0:
                rt.c["permission"].drop()
        if 'permission' in rt.c:
            ctype = rt.c['permission'].type.__class__.__name__
            drop = False
            if 'CHAR' in ctype:
                drop = True
            if 'INTEGER' in ctype:
                drop = True
            if drop:
                rt.c["permission"].drop()
        if not ('permission' in rt.c):
            acl.c["permission"].create()
        # refresh metA
        fkp = {"users":ForeignKey("authentication_permission.id", name="fk_userssacl_permission", use_alter=True, ondelete="CASCADE", onupdate="CASCADE"),
              "projects":ForeignKey("authentication_permission.id", name="fk_projectsacl_permission", use_alter=True, ondelete="CASCADE", onupdate="CASCADE"),
             }.get(item)
        fk = ForeignKeyConstraint([acl.c.permission], [permission.c.id], **{'table': acl})
        fk.name =      fkp.name
        fk.use_alter = fkp.use_alter
        fk.ondelete =  fkp.ondelete
        fk.onupdate =  fkp.onupdate
        fk.create()
        new_meta = MetaData(bind=migrate_engine)
        new_meta.reflect()
        nt = new_meta.tables[acl.name]
        columns = []
        if 'project' in item:
            columns.append(nt.c['rid'])
        columns.extend([nt.c['role'], nt.c['permission']])
        pk = PrimaryKeyConstraint(*columns)
        pk.create()

# 需要导入模块: from migrate.changeset.constraint import ForeignKeyConstraint [as 别名]
# 或者: from migrate.changeset.constraint.ForeignKeyConstraint import drop [as 别名]
def upgrade(migrate_engine):
    metadata = sa.MetaData()
    metadata.bind = migrate_engine

    table_names = set(TABLES_FKEYS_SET_NULL.keys())
    table_names.update(TABLES_COLUMNS_NOT_NULL.keys())

    tables = {}
    for t in table_names:
        tables[t] = sautils.Table(t, metadata, autoload=True)

    fks_to_change = []
    # We need to parse the reflected model in order to find the automatic
    # fk name that was put.
    # Mysql and postgres have different naming convention so this is not very
    # easy to have generic code working.
    for t, keys in TABLES_FKEYS_SET_NULL.items():
        table = tables[t]
        for fk in table.constraints:
            if not isinstance(fk, sa.ForeignKeyConstraint):
                continue
            for c in fk.elements:
                if str(c.column) in keys:
                    # migrate.xx.ForeignKeyConstraint is changing the model
                    # so initializing here would break the iteration
                    # (Set changed size during iteration)
                    fks_to_change.append((
                        table, (fk.columns, [c.column]),
                        dict(name=fk.name, ondelete='SET NULL')))

    for table, args, kwargs in fks_to_change:
        fk = ForeignKeyConstraint(*args, **kwargs)
        table.append_constraint(fk)
        try:
            fk.drop()
        except NotSupportedError:
            # some versions of sqlite do not support drop,
            # but will still update the fk
            pass
        fk.create()

    for t, cols in TABLES_COLUMNS_NOT_NULL.items():
        table = tables[t]
        if table.dialect_options.get('mysql', {}).get('engine') == 'InnoDB':
            migrate_engine.execute('SET FOREIGN_KEY_CHECKS = 0;')
        try:
            for c in table.columns:
                if c.name in cols:
                    c.alter(nullable=False)
        finally:
            if table.dialect_options.get('mysql', {}).get('engine') == 'InnoDB':
                migrate_engine.execute('SET FOREIGN_KEY_CHECKS = 1;')

# 需要导入模块: from migrate.changeset.constraint import ForeignKeyConstraint [as 别名]
# 或者: from migrate.changeset.constraint.ForeignKeyConstraint import drop [as 别名]
def downgrade(migrate_engine):
    # Operations to reverse the above upgrade go here.
    meta = MetaData(bind=migrate_engine)

    tt = Table('meas_IsotopeTable', meta, autoload=True)

    t = Table('proc_FitTable', meta, autoload=True)

    cons = ForeignKeyConstraint([t.c.isotope_id], [tt.c.id])
    cons.drop()

    try:
        t.c.isotope_id.drop()
    except:
        pass

# 需要导入模块: from migrate.changeset.constraint import ForeignKeyConstraint [as 别名]
# 或者: from migrate.changeset.constraint.ForeignKeyConstraint import drop [as 别名]
def downgrade(migrate_engine):
    # Operations to reverse the above upgrade go here.
    meta.bind = migrate_engine

    shelter = Table('shelter', meta, autoload=True)
    puppy = Table('puppy', meta, autoload=True)
    shelter_puppies = Table('shelter_puppies', meta, autoload=True)

    cons1 = ForeignKeyConstraint([shelter_puppies.c.shelter_id], [shelter.c.id])
    cons1.drop()

    cons2 = ForeignKeyConstraint([shelter_puppies.c.puppy_id], [puppy.c.id])
    cons2.drop()

    shelter_puppies.drop()
    pass

# 需要导入模块: from migrate.changeset.constraint import ForeignKeyConstraint [as 别名]
# 或者: from migrate.changeset.constraint.ForeignKeyConstraint import drop [as 别名]
def downgrade(migrate_engine):
    # Operations to reverse the above upgrade go here.
    meta.bind = migrate_engine

    puppy = Table('puppy', meta, autoload=True)
    adoptors = Table('adoptors', meta, autoload=True)
    puppy_adoptors = Table('puppy_adoptors', meta, autoload=True)

    cons1 = ForeignKeyConstraint([puppy_adoptors.c.puppy_id], [puppy.c.id])
    cons1.drop()

    cons2 = ForeignKeyConstraint([puppy_adoptors.c.adoptor_id], [adoptors.c.id])
    cons2.drop()

    puppy_adoptors.drop()
    pass

# 需要导入模块: from migrate.changeset.constraint import ForeignKeyConstraint [as 别名]
# 或者: from migrate.changeset.constraint.ForeignKeyConstraint import drop [as 别名]
def downgrade(migrate_engine):
    # Operations to reverse the above upgrade go here.

    meta = MetaData(bind=migrate_engine)
    mt = Table('meas_MeasurementTable', meta, autoload=True)
    sp = Table('meas_SpectrometerParametersTable', meta, autoload=True)
    c = Column('measurement_id', Integer)
    c.create(sp)

    fk = ForeignKeyConstraint([sp.c.measurement_id], [mt.c.id])
    fk.create()
    fk = ForeignKeyConstraint([mt.c.spectrometer_parameters_id], [sp.c.id])
    fk.drop()

    mt.c.spectrometer_parameters_id.drop()
    sp.c.hash.drop()

# 需要导入模块: from migrate.changeset.constraint import ForeignKeyConstraint [as 别名]
# 或者: from migrate.changeset.constraint.ForeignKeyConstraint import drop [as 别名]
def downgrade(migrate_engine):
    # Operations to reverse the above upgrade go here.
    meta.bind = migrate_engine
    mst = Table('gen_MassSpectrometerTable', meta, autoload=True)
    tt = Table('meas_ExtractionTable', meta, autoload=True)

    cons = ForeignKeyConstraint([t.c.mass_spectrometer_id], [mst.c.id])
    cons.drop()

    cons = ForeignKeyConstraint([tt.c.sensitivity_id], [t.c.id])
    cons.drop()

    tt.c.sensitivity_multiplier.drop()
    tt.c.sensitivity_id.drop()


    t.drop()