La modification d'un Enum champ à l'aide d'un Alambic

Comment puis-je ajouter un élément à un champ Enum dans un alambic de la migration lors de l'utilisation d'une version de PostgreSQL âgés de plus de 9.1 (ce qui ajoute de l'ALTER TYPE pour les enums)? Cette DONC, la question, explique le direct, mais je ne suis pas tout à fait sûr de la meilleure façon de le traduire à l'aide de l'alambic.

C'est ce que j'ai:

new_type = sa.Enum('nonexistent_executable', 'output_limit_exceeded',
                   'signal', 'success', 'timed_out', name='status')
old_type = sa.Enum('nonexistent_executable', 'signal', 'success', 'timed_out',
                   name='status')
tcr = sa.sql.table('testcaseresult',
                   sa.Column('status', new_type, nullable=False))


def upgrade():
    op.alter_column('testcaseresult', u'status', type_=new_type,
                    existing_type=old_type)


def downgrade():
    op.execute(tcr.update().where(tcr.c.status==u'output_limit_exceeded')
               .values(status='timed_out'))
    op.alter_column('testcaseresult', u'status', type_=old_type,
                    existing_type=new_type)

Ci-dessus, malheureusement, ne produit ALTER TABLE testcaseresult ALTER COLUMN status TYPE status lors de la mise à niveau, qui consiste essentiellement à ne rien.

InformationsquelleAutor bboe | 2013-02-13

J'ai décidé d'essayer de suivre le postgres approche aussi directement que possible, et est venu avec la suite de la migration.

from alembic import op
import sqlalchemy as sa
old_options = ('nonexistent_executable', 'signal', 'success', 'timed_out')
new_options = sorted(old_options + ('output_limit_exceeded',))
old_type = sa.Enum(*old_options, name='status')
new_type = sa.Enum(*new_options, name='status')
tmp_type = sa.Enum(*new_options, name='_status')
tcr = sa.sql.table('testcaseresult',
sa.Column('status', new_type, nullable=False))
def upgrade():
# Create a tempoary "_status" type, convert and drop the "old" type
tmp_type.create(op.get_bind(), checkfirst=False)
op.execute('ALTER TABLE testcaseresult ALTER COLUMN status TYPE _status'
' USING status::text::_status')
old_type.drop(op.get_bind(), checkfirst=False)
# Create and convert to the "new" status type
new_type.create(op.get_bind(), checkfirst=False)
op.execute('ALTER TABLE testcaseresult ALTER COLUMN status TYPE status'
' USING status::text::status')
tmp_type.drop(op.get_bind(), checkfirst=False)
def downgrade():
# Convert 'output_limit_exceeded' status into 'timed_out'
op.execute(tcr.update().where(tcr.c.status==u'output_limit_exceeded')
.values(status='timed_out'))
# Create a tempoary "_status" type, convert and drop the "new" type
tmp_type.create(op.get_bind(), checkfirst=False)
op.execute('ALTER TABLE testcaseresult ALTER COLUMN status TYPE _status'
' USING status::text::_status')
new_type.drop(op.get_bind(), checkfirst=False)
# Create and convert to the "old" status type
old_type.create(op.get_bind(), checkfirst=False)
op.execute('ALTER TABLE testcaseresult ALTER COLUMN status TYPE status'
' USING status::text::status')
tmp_type.drop(op.get_bind(), checkfirst=False)

Il semble que l'alambic a pas de support direct pour les USING déclaration dans son alter_table méthode.

Fonctionne avec un alambic de 0,7 et de Postgresql 9.4. PITA avoir à le faire de cette façon. Sans doute l'espoir je n'ai pas plus faire des ajustements à mes Énumérations!
avez-vous vu stackoverflow.com/a/16821396/176978? Sur Postgresql 9.4, vous devriez être en mesure de le faire beaucoup plus simplement.
Oui mais malheureusement j'ai était à la baisse plutôt que d'ajouter de laquelle il ne semble pas y avoir de soutien pour encore, même dans 9.4.
ADD VALUE a été autour depuis 9.1. Cependant, même dans la section 9.4, l'opération ne peut pas être fait à l'intérieur d'une transaction de bloc et tous alambic migrations se produisent dans les transactions.
juste au cas où quelqu'un a été vous demandez-vous: Pas de soutien à la transaction, pour ADD VALUE dans PostgreSQL 10 et autant que je sache aucun des plans à mettre en œuvre que dans la version 11.

InformationsquelleAutor bboe

J'ai utilisé un peu plus simple avec moins d'étapes que l'on a accepté la réponse, que j'ai basé cette sur. Dans cet exemple, je vais faire semblant de l'enum en question est appelé "status_enum", parce que dans la accepté de répondre à l'utilisation de "statut" pour la colonne et enum qui me confond.

from alembic import op 
import sqlalchemy as sa
name = 'status_enum'
tmp_name = 'tmp_' + name
old_options = ('nonexistent_executable', 'signal', 'success', 'timed_out')
new_options = sorted(old_options + ('output_limit_exceeded',))
new_type = sa.Enum(*new_options, name=name)
old_type = sa.Enum(*old_options, name=name)
tcr = sa.sql.table('testcaseresult',
sa.Column('status', new_type, nullable=False))
def upgrade():
op.execute('ALTER TYPE ' + name + ' RENAME TO ' + tmp_name)
new_type.create(op.get_bind())
op.execute('ALTER TABLE testcaseresult ALTER COLUMN status ' +
'TYPE ' + name + ' USING status::text::' + name)
op.execute('DROP TYPE ' + tmp_name)
def downgrade():
# Convert 'output_limit_exceeded' status into 'timed_out'                                                                                                                      
op.execute(tcr.update().where(tcr.c.status=='output_limit_exceeded')
.values(status='timed_out'))
op.execute('ALTER TYPE ' + name + ' RENAME TO ' + tmp_name)
old_type.create(op.get_bind())
op.execute('ALTER TABLE testcaseresult ALTER COLUMN status ' +
'TYPE ' + name + ' USING status::text::' + name)
op.execute('DROP TYPE ' + tmp_name)

Salut @JelteF, j'ai utilisé votre approche, mais il renvoie une erreur: sqlalchemy.exc.ProgrammingError: (psycopg2.ProgrammingError) column "category_type" does not exist mon nom de colonne est caterory_types' and enum name is CATEGORY_TYPE` qui est un OrderedDict , j'utilise Postgres 10.4 et alambic 0.9.9

InformationsquelleAutor JelteF

11

De Postgres 9.1 l'ajout d'une nouvelle valeur à une enum peut être fait avec le MODIFIER le TYPE déclaration. Ceci est compliqué par le fait que il ne peut pas être fait dans une transaction. Cependant cela peut être contourné par commettre l'alambic de la transaction voir ici.

J'ai effectivement eu des problèmes en utilisant l'ancienne, plus détaillé, solution parce que Postgres ne pouvait pas convertir automatiquement la valeur par défaut pour la colonne.
- alambic utilise github pour le suivi des problèmes maintenant: Un moyen d'exécuter des non-transactionnelles commandes DDL #123
InformationsquelleAutor Rob Young

Cela fonctionne sans problèmes:

from alembic import op
def upgrade():
op.execute("COMMIT")
op.execute("ALTER TYPE enum_type ADD VALUE 'new_value'")
def downgrade():
...

Référence

> lors de l'utilisation d'une version de PostgreSQL âgés de plus de 9.1

InformationsquelleAutor Aditya

6

J'ai eu le même problème en essayant de migration d'un type de colonne à l'autre. J'utilise les conditions suivantes:
```
Alembic==0.9.4
SQLAlchemy==1.1.12 
```
Vous pouvez fournir l'argument postgresql_using comme un kwarg de alembic.op.alter_column.
```
from alembic import op
import sqlalchemy as types
op.alter_column(
table_name='my_table',
column_name='my_column',
type_=types.NewType,
# allows to use postgresql USING
postgresql_using="my_column::PostgesEquivalentOfNewType",
)
```
J'espère que cela peut aider.
- Dans le cas d'une Postgres les Énumérations, on peut vouloir utiliser un cast (OLD_TYPE -> text -> NEW_TYPE): postgresql_using="my_column::text::PostgesEquivalentOfNewType" Dans le cas de cette question, il est en fait un must have. Cependant, cette réponse est génial, il m'a sauvé beaucoup de temps 🙂
- Couru dans cette question et cette réponse fonctionne très bien et est beaucoup moins... compliqué que les autres réponses, sérieux merci
InformationsquelleAutor Jeyfel Brandauer
3

En droit SQL, ce serait travailler pour Postgres, si l'ordre des choses dans votre enum n'a pas besoin d'être exactement comme ci-dessus:
```
ALTER TYPE status ADD value 'output_limit_exceeded' after 'timed_out'; 
```
- Ce soutien a été ajouté dans PostgreSQL 9.1. Je vais mettre à jour la question pour être plus précis (je souhaite que je l'aide a été 9.1).
- Le point de l'ensemble de l'utilisation de l'Alambic et de SQLAlchemy est d'éviter d'écrire pur SQL, sauf si vous avez. Et, idéalement, obtenir la migration des scripts générés automatiquement, basée sur SQLAlchemy modèles.
- Le principal problème, c'est que ALTER TYPE ... ADD VALUE ... ne peut pas être utilisé à l'intérieur d'une transaction.
- Cette question est au sujet de la migration, donc, comment faire pour supprimer une valeur ajoutée dans l'ENUM? Comment au sujet de la downgrade
- à la dure, de la création d'un nouveau type, et de les échanger avec l'ancien, postgres ne prend pas en charge la suppression d'une valeur à partir d'un enum =/
InformationsquelleAutor thisfred

J'avais besoin de déplacer des données lors de la migration de types de, y compris la suppression de certains vieux types, alors j'ai pensé écrire une manière plus générale de faire cela en fonction sur le (génial) a accepté de répondre (https://stackoverflow.com/a/14845740/629272). Espérons que cela aide quelqu'un d'autre dans le même bateau!

# This migration will move data from one column to two others based on the type
# for a given row, and modify the type of each row.
from alembic import op
import sqlalchemy as sa
from sqlalchemy.dialects import postgresql
revision = '000000000001'
down_revision = '000000000000'
branch_labels = None
depends_on = None
# This set of options makes up the old type.
example_types_old = (
'EXAMPLE_A',
'EXAMPLE_B',
'EXAMPLE_C',
)
example_type_enum_old = postgresql.ENUM(*example_types_old, name='exampletype')
# This set of options makes up the new type.
example_types_new = (
'EXAMPLE_C',
'EXAMPLE_D',
'EXAMPLE_E',
)
example_type_enum_new = postgresql.ENUM(*example_types_new, name='exampletype')
# This set of options includes everything from the old and new types.
example_types_tmp = set(example_types_old + example_types_new)
example_type_enum_tmp = postgresql.ENUM(*example_types_tmp, name='_exampletype')
# This is a table view from which we can select and update as necessary. This
# only needs to include the relevant columns which are in either the old or new
# version of the table.
examples_view = sa.Table(
# Use the name of the actual table so it is modified in the upgrade and
# downgrade.
'examples',
sa.MetaData(),
sa.Column('id', sa.Integer, primary_key=True),
# Use the _tmp type so all types are usable.
sa.Column('example_type', example_type_enum_tmp),
# This is a column from which the data will be migrated, after which the
# column will be removed.
sa.Column('example_old_column', sa.Integer),
# This is a column to which data from the old column will be added if the
# type is EXAMPLE_A.
sa.Column('example_new_column_a', sa.Integer),
# This is a column to which data from the old column will be added if the
# type is EXAMPLE_B.
sa.Column('example_new_column_b', sa.Integer),
)
def upgrade():
connection = op.get_bind()
# Add the new column to which data will be migrated.
example_new_column_a = sa.Column(
'example_new_column_a',
sa.Integer,
nullable=True
)
op.add_column('examples', example_new_column_a)
# Add the new column to which data will be migrated.
example_new_column_b = sa.Column(
'example_new_column_b',
sa.Integer,
nullable=True
)
op.add_column('examples', example_new_column_b)
# Create the temporary enum and change the example_type column to use the
# temporary enum.
# The USING statement automatically maps the old enum to the temporary one.
example_type_enum_tmp.create(connection, checkfirst=False)
# Change to the temporary type and map from the old type to the temporary
# one.
op.execute('''
ALTER TABLE examples
ALTER COLUMN example_type
TYPE _exampletype
USING example_type::text::_exampletype
''')
# Move data from example_old_column to example_new_column_a and change its
# type to EXAMPLE_D if the type is EXAMPLE_A.
connection.execute(
examples_view.update().where(
examples_view.c.example_type == 'EXAMPLE_A'
).values(
example_type='EXAMPLE_D',
example_new_column_a=examples_view.c.example_old_column,
)
)
# Move data from example_old_column to example_new_column_b and change its
# type to EXAMPLE_E if the type is EXAMPLE_B.
connection.execute(
examples_view.update().where(
examples_view.c.example_type == 'EXAMPLE_B'
).values(
example_type='EXAMPLE_E',
example_new_column_b=examples_view.c.example_old_column,
)
)
# Move any remaining data from example_old_column to example_new_column_a
# and keep its type as EXAMPLE_C.
connection.execute(
examples_view.update().where(
examples_view.c.example_type == 'EXAMPLE_C'
).values(
example_type='EXAMPLE_C',
example_new_column_a=examples_view.c.example_old_column,
)
)
# Delete the old enum now that the data with the old types have been moved.
example_type_enum_old.drop(connection, checkfirst=False)
# Create the new enum and change the example_type column to use the new
# enum.
# The USING statement automatically maps the temporary enum to the new one.
example_type_enum_new.create(connection, checkfirst=False)
op.execute('''
ALTER TABLE examples
ALTER COLUMN example_type
TYPE exampletype
USING example_type::text::exampletype
''')
# Delete the temporary enum.
example_type_enum_tmp.drop(connection, checkfirst=False)
# Remove the old column.
op.drop_column('examples', 'example_old_column')
# The downgrade just performs the opposite of all the upgrade operations but in
# reverse.
def downgrade():
connection = op.get_bind()
example_old_column = sa.Column(
'example_old_column',
sa.Integer,
nullable=True
)
op.add_column('examples', example_old_column)
example_type_enum_tmp.create(connection, checkfirst=False)
op.execute('''
ALTER TABLE examples
ALTER COLUMN example_type
TYPE _exampletype
USING example_type::text::_exampletype
''')
connection.execute(
examples_view.update().where(
examples_view.c.example_type == 'EXAMPLE_C'
).values(
example_type='EXAMPLE_C',
example_old_column=examples_view.c.example_new_column_b,
)
)
connection.execute(
examples_view.update().where(
examples_view.c.example_type == 'EXAMPLE_E'
).values(
example_type='EXAMPLE_B',
example_old_column=examples_view.c.example_new_column_b,
)
)
connection.execute(
examples_view.update().where(
examples_view.c.example_type == 'EXAMPLE_D'
).values(
example_type='EXAMPLE_A',
example_old_column=examples_view.c.example_new_column_a,
)
)
example_type_enum_old.create(connection, checkfirst=False)
op.execute('''
ALTER TABLE examples
ALTER COLUMN example_type
TYPE exampletype
USING example_type::text::exampletype
''')
example_type_enum_tmp.drop(connection, checkfirst=False)
op.drop_column('examples', 'example_new_column_b')
op.drop_column('examples', 'example_new_column_a')

InformationsquelleAutor Californian

Depuis que j'ai eu la conversion des erreurs et des problèmes avec les valeurs par défaut, j'ai écrit un même généralisée de la réponse repose sur le reconnus:

def replace_enum_values(
name: str,
old: [str],
new: [str],
modify: [(str, str, str)]
):
"""
Replaces an enum's list of values.
Args:
name: Name of the enum
new: New list of values
old: Old list of values
modify: List of tuples of table name
and column to modify (which actively use the enum).
Assumes each column has a default val.
"""
connection = op.get_bind()
tmp_name = "{}_tmp".format(name)
# Rename old type
op.execute(
"ALTER TYPE {} RENAME TO {};"
.format(name, tmp_name)
)
# Create new type
lsl = sa.Enum(*new, name=name)
lsl.create(connection)
# Replace all usages
for (table, column) in modify:
# Get default to re-set later
default_typed = connection.execute(
"SELECT column_default "
"FROM information_schema.columns "
"WHERE table_name='{table}' "
"AND column_name='{column}';"
.format(table=table, column=column)
).first()[0]  # type: str
# Is bracketed already
default = default_typed[:default_typed.index("::")]
# Set all now invalid values to default
connection.execute(
"UPDATE {table} "
"SET {column}={default} "
"WHERE {column} NOT IN {allowed};"
.format(
table=table,
column=column,
# Invalid: What isn't contained in both new and old
# Can't just remove what's not in new because we get
# a type error
allowed=tuple(set(old).intersection(set(new))),
default=default
)
)
op.execute(
"ALTER TABLE {table} "
# Default needs to be dropped first
"ALTER COLUMN {column} DROP DEFAULT,"
# Replace the tpye
"ALTER COLUMN {column} TYPE {enum_name} USING {column}::text::{enum_name},"
# Reset default
"ALTER COLUMN {column} SET DEFAULT {default};"
.format(
table=table,
column=column,
enum_name=name,
default=default
)
)
# Remove old type
op.execute("DROP TYPE {};".format(tmp_name))

Cela peut être appelé à partir d'upgrade /downgrade en tant que tel:

replace_enum_values(
name='enum_name',
new=["A", "B"],
old=["A", "C"],
modify=[('some_table', 'some_column')]
)

Tous invalidé les valeurs seront mis à server_default.

InformationsquelleAutor Ivorius

Vous devez vous connecter pour publier un commentaire.