Class ENUM

lib/sqlalchemy/dialects/postgresql/named_types.py:192–390

PostgreSQL ENUM type. This is a subclass of :class:`_types.Enum` which includes support for PG's ``CREATE TYPE`` and ``DROP TYPE``. When the builtin type :class:`_types.Enum` is used and the :paramref:`.Enum.native_enum` flag is left at its default of True, the PostgreSQL backe

class ENUM(NamedType, type_api.NativeForEmulated, sqltypes.Enum):
    """PostgreSQL ENUM type.

    This is a subclass of :class:`_types.Enum` which includes
    support for PG's ``CREATE TYPE`` and ``DROP TYPE``.

    When the builtin type :class:`_types.Enum` is used and the
    :paramref:`.Enum.native_enum` flag is left at its default of
    True, the PostgreSQL backend will use a :class:`_postgresql.ENUM`
    type as the implementation, so the special create/drop rules
    will be used.

    The create/drop behavior of ENUM tries to follow the PostgreSQL behavior,
    with an usability improvement indicated below.

    When using :class:`_types.Enum` or :class:`_postgresql.ENUM`
    in an "inline" fashion, the ``CREATE TYPE`` is emitted
    corresponding to when the :meth:`_schema.Table.create` method is called::

        table = Table(
            "sometable",
            metadata,
            Column("some_enum", ENUM("a", "b", "c", name="myenum")),
        )

        # will check if enum exists and emit CREATE ENUM then CREATE TABLE
        table.create(engine)
        table.drop(engine)  # will *not* drop the enum.

    The enum will not be dropped when the table is dropped, since it's
    associated with the metadata, not the table itself. Call drop on the
    :class:`_postgresql.ENUM` directly to drop the type::

        metadata.get_schema_object_by_name("enum", "myenum").drop(engine)

    To use a common enumerated type between multiple tables, the best
    practice is to declare the :class:`_types.Enum` or
    :class:`_postgresql.ENUM` independently::

        my_enum = ENUM("a", "b", "c", name="myenum", metadata=metadata)

        t1 = Table("sometable_one", metadata, Column("some_enum", myenum))

        t2 = Table("sometable_two", metadata, Column("some_enum", myenum))

    Like before, the type will be created if it does not exist::

        # will check if enum exists and emit CREATE ENUM then CREATE TABLE
        t1.create(engine)

    The type will always be created and dropped if either the metadata-wide
    create/drop is called::

        metadata.create_all(engine)  # will emit CREATE TYPE
        metadata.drop_all(engine)  # will emit DROP TYPE

    The type can also be created and dropped directly::