API базового типа¶

class sqlalchemy.types.TypeEngine¶

Конечный базовый класс для всех типов данных SQL.

Общие подклассы TypeEngine включают String, Integer и Boolean.

Обзор системы типизации SQLAlchemy см. в разделе Объекты типов данных SQL.

См.также

Объекты типов данных SQL

Members

operate(), reverse_operate(), adapt(), as_generic(), bind_expression(), bind_processor(), coerce_compared_value(), column_expression(), comparator_factory, compare_against_backend(), compare_values(), compile(), dialect_impl(), evaluates_none(), get_dbapi_type(), hashable, literal_processor(), python_type, render_bind_cast, render_literal_cast, result_processor(), should_evaluate_none, sort_key_function, with_variant()

Классная подпись

класс sqlalchemy.types.TypeEngine (sqlalchemy.sql.visitors.Visitable, typing.Generic)

class Comparator¶

Базовый класс для пользовательских операций сравнения, определенных на уровне типов. См. TypeEngine.comparator_factory.

Классная подпись

класс sqlalchemy.types.TypeEngine.Comparator (sqlalchemy.sql.expression.ColumnOperators, typing.Generic)

method sqlalchemy.types.TypeEngine.Comparator.operate(op: OperatorType, *other: Any, **kwargs: Any) → ColumnElement[_CT]¶

Оперировать с аргументом.

Это самый низкий уровень работы, по умолчанию поднимает NotImplementedError.

Переопределение этого параметра в подклассе может позволить применять общее поведение ко всем операциям. Например, переопределение ColumnOperators для применения func.lower() к левой и правой стороне:

class MyComparator(ColumnOperators):
    def operate(self, op, other, **kwargs):
        return op(func.lower(self), func.lower(other), **kwargs)

Параметры:

• op – Вызов оператора.

• *other – «другая» сторона операции. Для большинства операций это будет один скаляр.

• **kwargs – модификаторы. Они могут передаваться специальными операторами, такими как ColumnOperators.contains().

method sqlalchemy.types.TypeEngine.Comparator.reverse_operate(op: OperatorType, other: Any, **kwargs: Any) → ColumnElement[_CT]¶

Обратное действие над аргументом.

Используется так же, как и operate().

method sqlalchemy.types.TypeEngine.adapt(cls: Type[Union[TypeEngine, TypeEngineMixin]], **kw: Any) → TypeEngine¶

Произведите «адаптированную» форму этого типа, учитывая класс «impl» для работы.

Этот метод используется для внутренней связи общих типов с типами «реализации», которые специфичны для конкретного диалекта.

method sqlalchemy.types.TypeEngine.as_generic(allow_nulltype: bool = False) → TypeEngine¶

Возвращает экземпляр общего типа, соответствующий данному типу, используя эвристическое правило. Метод может быть переопределен, если этого эвристического правила недостаточно.

>>> from sqlalchemy.dialects.mysql import INTEGER
>>> INTEGER(display_width=4).as_generic()
Integer()

>>> from sqlalchemy.dialects.mysql import NVARCHAR
>>> NVARCHAR(length=100).as_generic()
Unicode(length=100)

Добавлено в версии 1.4.0b2.

См.также

Отражение с помощью типов, не зависящих от базы данных - описывает использование TypeEngine.as_generic() в сочетании с событием DDLEvents.column_reflect(), что является его предполагаемым использованием.

method sqlalchemy.types.TypeEngine.bind_expression(bindvalue: BindParameter[_T]) → Optional[ColumnElement[_T]]¶

Получив значение привязки (т.е. экземпляр BindParameter), верните вместо него SQL-выражение.

Обычно это функция SQL, которая оборачивает существующий связанный параметр внутри оператора. Он используется для специальных типов данных, которые требуют, чтобы литералы были обернуты в какую-то специальную функцию базы данных, чтобы привести значение на уровне приложения к формату, специфичному для базы данных. Это SQL-аналог метода TypeEngine.bind_processor().

Этот метод вызывается на этапе SQL-компиляции оператора при визуализации строки SQL. Он не вызывается против определенных значений.

Обратите внимание, что этот метод при реализации должен всегда возвращать точно такую же структуру, без какой-либо условной логики, поскольку он может быть использован в вызове executemany() против произвольного числа связанных наборов параметров.

Примечание

Этот метод вызывается только относительно объекта типа, специфичного для диалекта, который часто является частным для используемого диалекта и не является тем же самым объектом типа, что и общедоступный, что означает, что невозможно подклассифицировать класс TypeEngine, чтобы обеспечить альтернативный метод TypeEngine.bind_expression(), если только не подклассифицировать класс UserDefinedType явно.

Чтобы обеспечить альтернативное поведение для TypeEngine.bind_expression(), реализуйте класс TypeDecorator и обеспечьте реализацию TypeDecorator.bind_expression().

См.также

Дополнение существующих типов

См.также

Применение привязки/обработки результатов на уровне SQL

method sqlalchemy.types.TypeEngine.bind_processor(dialect: Dialect) → Optional[_BindProcessorType[_T]]¶

Возвращает функцию преобразования для обработки значений привязки.

Возвращает вызываемый объект, который получает значение параметра bind в качестве единственного позиционного аргумента и возвращает значение для отправки в DB-API.

Если обработка не требуется, метод должен вернуть None.

Примечание

Этот метод вызывается только относительно объекта типа, специфичного для диалекта, который часто является частным для используемого диалекта и не является тем же самым объектом типа, что и общедоступный, что означает, что невозможно подклассифицировать класс TypeEngine, чтобы обеспечить альтернативный метод TypeEngine.bind_processor(), если только не подклассифицировать класс UserDefinedType явно.

Чтобы обеспечить альтернативное поведение для TypeEngine.bind_processor(), реализуйте класс TypeDecorator и обеспечьте реализацию TypeDecorator.process_bind_param().

См.также

Дополнение существующих типов

Параметры:

dialect – Используемый диалектный экземпляр.

method sqlalchemy.types.TypeEngine.coerce_compared_value(op: Optional[OperatorType], value: Any) → TypeEngine[Any]¶

Предложите тип для «принудительного» значения Python в выражении.

Учитывая оператор и значение, дает возможность типу вернуть тип, к которому должно быть принуждено значение.

Поведение по умолчанию здесь консервативно; если правая часть уже принудительно приведена к типу SQL на основе ее типа в Python, ее обычно оставляют в покое.

Расширение функциональности конечного пользователя здесь обычно должно осуществляться через TypeDecorator, который обеспечивает более либеральное поведение, поскольку по умолчанию принуждает другую сторону выражения к этому типу, таким образом применяя специальные преобразования Python сверх тех, которые необходимы DBAPI для обоих идов. Он также предоставляет публичный метод TypeDecorator.coerce_compared_value(), который предназначен для настройки этого поведения конечным пользователем.

method sqlalchemy.types.TypeEngine.column_expression(colexpr: ColumnElement[_T]) → Optional[ColumnElement[_T]]¶

Учитывая выражение столбца SELECT, верните обернутое выражение SQL.

Обычно это SQL-функция, которая оборачивает выражение столбца, отображаемое в пункте columns оператора SELECT. Она используется для специальных типов данных, которые требуют, чтобы столбцы были обернуты в какую-то специальную функцию базы данных, чтобы принудительно вывести значение перед отправкой обратно в приложение. Это SQL-аналог метода TypeEngine.result_processor().

Этот метод вызывается на этапе SQL-компиляции оператора при визуализации строки SQL. Он не вызывается против определенных значений.

Примечание

Этот метод вызывается только относительно объекта типа, специфичного для диалекта, который часто является частным для используемого диалекта и не является тем же самым объектом типа, что и общедоступный, что означает, что невозможно подклассифицировать класс TypeEngine, чтобы обеспечить альтернативный метод TypeEngine.column_expression(), если только не подклассифицировать класс UserDefinedType явно.

Чтобы обеспечить альтернативное поведение для TypeEngine.column_expression(), реализуйте класс TypeDecorator и обеспечьте реализацию TypeDecorator.column_expression().

См.также

Дополнение существующих типов

См.также

Применение привязки/обработки результатов на уровне SQL

attribute sqlalchemy.types.TypeEngine.comparator_factory¶

alias of Comparator

method sqlalchemy.types.TypeEngine.compare_against_backend(dialect: Dialect, conn_type: TypeEngine[Any]) → Optional[bool]¶

Сравните данный тип с заданным типом бэкенда.

В настоящее время эта функция не реализована для типов SQLAlchemy, и для всех встроенных типов будет возвращать None. Однако она может быть реализована в пользовательском типе, где она может быть использована инструментами сравнения схем, такими как Alembic autogenerate.

В будущем выпуске SQLAlchemy возможно будет реализован этот метод и для встроенных типов.

Функция должна возвращать True, если данный тип эквивалентен заданному типу; тип обычно отражается из базы данных, поэтому должен быть специфичным для базы данных. Также передается используемый диалект. Функция также может возвращать False, чтобы утверждать, что тип не эквивалентен.

Параметры:

• dialect – a Dialect, который участвует в сравнении.

• conn_type – объект типа, отраженный от бэкенда.

method sqlalchemy.types.TypeEngine.compare_values(x: Any, y: Any) → bool¶

Сравните два значения на равенство.

method sqlalchemy.types.TypeEngine.compile(dialect: Optional[Dialect] = None) → str¶

Произвести строково-компилированную форму данного TypeEngine.

При вызове без аргументов использует диалект «по умолчанию» для получения строкового результата.

Параметры:

dialect – экземпляр Dialect.

method sqlalchemy.types.TypeEngine.dialect_impl(dialect: Dialect) → TypeEngine[_T]¶

Возвращает специфическую для диалекта реализацию для данного TypeEngine.

method sqlalchemy.types.TypeEngine.evaluates_none() → Self¶

Возвращает копию данного типа, у которой флаг should_evaluate_none установлен в True.

Например:

Table(
    'some_table', metadata,
    Column(
        String(50).evaluates_none(),
        nullable=True,
        server_default='no value')
)

ORM использует этот флаг, чтобы указать, что положительное значение None передается в столбец в операторе INSERT, а не опускает столбец в операторе INSERT, что приводит к срабатыванию значений по умолчанию на уровне столбцов. Это также позволяет типам, которые имеют специальное поведение, связанное со значением Python None, указывать, что значение не обязательно переводится в SQL NULL; ярким примером этого является тип JSON, который может захотеть сохранить значение JSON 'null'.

В любом случае, фактическое значение NULL SQL всегда может быть сохранено в любом столбце с помощью конструкции null SQL в операторе INSERT или связано с атрибутом ORM-mapped.

Примечание

Флаг «evaluates none» не применяется к значению None, переданному в Column.default или Column.server_default; в этих случаях None по-прежнему означает «no default».

См.также

Принудительный NULL для столбца со значением по умолчанию - в документации по ORM

JSON.none_as_null - взаимодействие PostgreSQL JSON с этим флагом.

TypeEngine.should_evaluate_none - флаг уровня класса

method sqlalchemy.types.TypeEngine.get_dbapi_type(dbapi: module) → Optional[Any]¶

Возвращает соответствующий объект типа из базового DB-API, если таковой имеется.

Это может быть полезно, например, для вызова setinputsizes().

attribute sqlalchemy.types.TypeEngine.hashable = True¶

Флаг, если False, означает, что значения этого типа не хэшируются.

Используется ORM при уникализации списков результатов.

method sqlalchemy.types.TypeEngine.literal_processor(dialect: Dialect) → Optional[_LiteralProcessorType[_T]]¶

Возвращает функцию преобразования для обработки литеральных значений, которые должны быть отображены напрямую без использования привязок.

Эта функция используется, когда компилятор использует флаг «literal_binds», обычно применяемый при генерации DDL, а также в некоторых сценариях, когда бэкенды не принимают связанные параметры.

Возвращает вызываемый объект, который получает литеральное значение Python в качестве единственного позиционного аргумента и возвращает строковое представление для отображения в SQL-запросе.

Примечание

Этот метод вызывается только относительно объекта типа, специфичного для диалекта, который часто является частным для используемого диалекта и не является тем же самым объектом типа, что и общедоступный, что означает, что невозможно подклассифицировать класс TypeEngine, чтобы обеспечить альтернативный метод TypeEngine.literal_processor(), если только не подклассифицировать класс UserDefinedType явно.

Чтобы обеспечить альтернативное поведение для TypeEngine.literal_processor(), реализуйте класс TypeDecorator и обеспечьте реализацию TypeDecorator.process_literal_param().

См.также

Дополнение существующих типов

attribute sqlalchemy.types.TypeEngine.python_type¶

Возвращает объект типа Python, который, как ожидается, будет возвращен экземплярами этого типа, если он известен.

В принципе, те типы, которые принудительно указывают возвращаемый тип или известны как таковые для всех распространенных DBAPI (например, int), будут возвращать этот тип.

Если тип возврата не определен, выдает NotImplementedError.

Обратите внимание, что тип any также вмещает NULL в SQL, что означает, что вы также можете получить обратно None из любого типа на практике.

attribute sqlalchemy.types.TypeEngine.render_bind_cast = False¶

Рендеринг кастов привязки для режима BindTyping.RENDER_CASTS.

Если True, то этот тип (обычно impl тип уровня диалекта) сигнализирует компилятору, что вокруг связанного параметра для этого типа следует сделать приведение.

Добавлено в версии 2.0.

См.также

BindTyping

attribute sqlalchemy.types.TypeEngine.render_literal_cast = False¶

приводить при выводе значения в виде встроенного литерала, например, с помощью TypeEngine.literal_processor().

Добавлено в версии 2.0.

method sqlalchemy.types.TypeEngine.result_processor(dialect: Dialect, coltype: object) → Optional[_ResultProcessorType[_T]]¶

Возвращает функцию преобразования для обработки значений строки результата.

Возвращает вызываемый объект, который получает значение столбца строки результата в качестве единственного позиционного аргумента и возвращает значение для возврата пользователю.

Если обработка не требуется, метод должен вернуть None.

Примечание

Этот метод вызывается только относительно объекта типа, специфичного для диалекта, который часто является частным для используемого диалекта и не является тем же самым объектом типа, что и общедоступный, что означает, что невозможно подклассифицировать класс TypeEngine, чтобы обеспечить альтернативный метод TypeEngine.result_processor(), если только не подклассифицировать класс UserDefinedType явно.

Чтобы обеспечить альтернативное поведение для TypeEngine.result_processor(), реализуйте класс TypeDecorator и обеспечьте реализацию TypeDecorator.process_result_value().

См.также

Дополнение существующих типов

Параметры:

• dialect – Используемый диалектный экземпляр.

• coltype – DBAPI coltype аргумент, полученный в cursor.description.

attribute sqlalchemy.types.TypeEngine.should_evaluate_none: bool = False¶

Если True, то константа Python None считается явно обрабатываемой данным типом.

ORM использует этот флаг, чтобы указать, что положительное значение None передается в столбец в операторе INSERT, а не опускает столбец в операторе INSERT, что приводит к срабатыванию значений по умолчанию на уровне столбцов. Это также позволяет типам, которые имеют специальное поведение для Python None, например, типу JSON, указать, что они хотели бы обрабатывать значение None в явном виде.

Чтобы установить этот флаг для существующего типа, используйте метод TypeEngine.evaluates_none().

См.также

TypeEngine.evaluates_none()

attribute sqlalchemy.types.TypeEngine.sort_key_function: Optional[Callable[[Any], Any]] = None¶

Функция сортировки, которая может быть передана как ключ к sorted.

Значение по умолчанию None указывает на то, что значения, хранимые этим типом, являются самосортирующимися.

Добавлено в версии 1.3.8.

method sqlalchemy.types.TypeEngine.with_variant(type_: _TypeEngineArgument[Any], *dialect_names: str) → Self¶

Создает копию объекта данного типа, который будет использовать данный тип при применении к диалекту данного имени.

например:

from sqlalchemy.types import String
from sqlalchemy.dialects import mysql

string_type = String()

string_type = string_type.with_variant(
    mysql.VARCHAR(collation='foo'), 'mysql', 'mariadb'
)

Вариантное отображение указывает, что когда данный тип интерпретируется определенным диалектом, он будет трансмутирован в данный тип, вместо того, чтобы использовать первичный тип.

Изменено в версии 2.0: метод TypeEngine.with_variant() теперь работает с объектом TypeEngine «на месте», возвращая копию исходного типа, а не возвращая объект-обертку; класс Variant больше не используется.

Параметры:

• type_ – TypeEngine, который будет выбран в качестве варианта из исходного типа, если используется диалект с данным именем.

• *dialect_names – одно или несколько базовых имен диалекта, использующего данный тип. (т.е. 'postgresql', 'mysql' и т.д.) … versionchanged:: 2.0 Для одного варианта может быть указано несколько имен диалектов.

См.также

Использование «UPPERCASE» и типов, специфичных для бэкенда, для нескольких бэкендов - иллюстрирует использование TypeEngine.with_variant().

class sqlalchemy.types.Concatenable¶

Миксин, который отмечает тип как поддерживающий «конкатенацию», обычно строк.

Members

comparator_factory

Классная подпись

класс sqlalchemy.types.Concatenable (sqlalchemy.types.TypeEngineMixin)

class Comparator¶

Классная подпись

класс sqlalchemy.types.Concatenable.Comparator (sqlalchemy.types.Comparator)

attribute sqlalchemy.types.Concatenable.comparator_factory¶

alias of Comparator

class sqlalchemy.types.Indexable¶

Миксин, который помечает тип как поддерживающий операции индексирования, такие как структуры массивов или JSON.

Members

comparator_factory

Классная подпись

класс sqlalchemy.types.Indexable (sqlalchemy.types.TypeEngineMixin)

class Comparator¶

Классная подпись

класс sqlalchemy.types.Indexable.Comparator (sqlalchemy.types.Comparator)

attribute sqlalchemy.types.Indexable.comparator_factory¶

alias of Comparator

class sqlalchemy.types.NullType¶

Неизвестный тип.

NullType используется как тип по умолчанию для тех случаев, когда тип не может быть определен, включая:

• Во время отражения таблицы, когда тип колонки не распознается Dialect.

• При построении выражений SQL с использованием простых объектов Python неизвестных типов (например, somecolumn == my_special_object)

• Когда создается новый Column, и заданный тип передается как None или не передается вообще.

NullType может быть использован внутри SQL-выражения без проблем, он просто не имеет поведения ни на уровне построения выражения, ни на уровне обработки bind-параметров/результатов. NullType приведет к CompileError, если компилятору будет предложено отобразить сам тип, например, если он используется в операции cast() или в операции создания схемы, например, вызываемой MetaData.create_all() или конструкцией CreateTable.

Классная подпись

класс sqlalchemy.types.NullType (sqlalchemy.types.TypeEngine)

class sqlalchemy.types.ExternalType¶

миксин, определяющий атрибуты и поведение, характерные для сторонних типов данных.

«Сторонние» относятся к типам данных, которые определены вне рамок SQLAlchemy либо в коде приложения конечного пользователя, либо во внешних расширениях SQLAlchemy.

В настоящее время подклассы включают TypeDecorator и UserDefinedType.

Добавлено в версии 1.4.28.

Members

cache_ok

Классная подпись

класс sqlalchemy.types.ExternalType (sqlalchemy.types.TypeEngineMixin)

attribute sqlalchemy.types.ExternalType.cache_ok: Optional[bool] = None¶

Укажите, являются ли утверждения, использующие этот ExternalType, «безопасными для кэширования».

Значение по умолчанию None выдает предупреждение, а затем не разрешает кэширование утверждения, включающего этот тип. Установите значение False, чтобы запретить кэширование утверждений, использующих этот тип, вообще без предупреждения. Если установлено значение True, класс объекта и выбранные элементы из его состояния будут использоваться как часть ключа кэша. Например, при использовании TypeDecorator:

class MyType(TypeDecorator):
    impl = String

    cache_ok = True

    def __init__(self, choices):
        self.choices = tuple(choices)
        self.internal_only = True

Ключ кэша для вышеуказанного типа будет эквивалентен:

>>> MyType(["a", "b", "c"])._static_cache_key
(<class '__main__.MyType'>, ('choices', ('a', 'b', 'c')))

Схема кэширования будет извлекать из типа атрибуты, соответствующие именам параметров в методе __init__(). Выше, атрибут «choices» становится частью ключа кэша, а «internal_only» - нет, потому что нет параметра с именем «internal_only».

Требования к кэшируемым элементам заключаются в том, чтобы они были хэшируемыми, а также в том, чтобы они указывали один и тот же SQL, выводимый для выражений, использующих данный тип, каждый раз для данного значения кэша.

Чтобы приспособиться к типам данных, которые ссылаются на нехешируемые структуры, такие как словари, множества и списки, эти объекты можно сделать «кэшируемыми», назначив атрибутам хэшируемые структуры, имена которых соответствуют именам аргументов. Например, тип данных, который принимает словарь значений для поиска, может опубликовать его как отсортированную серию кортежей. Учитывая ранее не кэшируемый тип как:

class LookupType(UserDefinedType):
    '''a custom type that accepts a dictionary as a parameter.

    this is the non-cacheable version, as "self.lookup" is not
    hashable.

    '''

    def __init__(self, lookup):
        self.lookup = lookup

    def get_col_spec(self, **kw):
        return "VARCHAR(255)"

    def bind_processor(self, dialect):
        # ...  works with "self.lookup" ...

Где «lookup» - это словарь. Тип не сможет генерировать ключ кэша:

>>> type_ = LookupType({"a": 10, "b": 20})
>>> type_._static_cache_key
<stdin>:1: SAWarning: UserDefinedType LookupType({'a': 10, 'b': 20}) will not
produce a cache key because the ``cache_ok`` flag is not set to True.
Set this flag to True if this type object's state is safe to use
in a cache key, or False to disable this warning.
symbol('no_cache')

Если бы мы установили такой ключ кэша, его нельзя было бы использовать. Мы получили бы структуру кортежа, содержащую внутри себя словарь, который сам по себе не может быть использован в качестве ключа в «кэш-словаре», таком как кэш утверждений SQLAlchemy, поскольку словари Python не хэшируются:

>>> # set cache_ok = True
>>> type_.cache_ok = True

>>> # this is the cache key it would generate
>>> key = type_._static_cache_key
>>> key
(<class '__main__.LookupType'>, ('lookup', {'a': 10, 'b': 20}))

>>> # however this key is not hashable, will fail when used with
>>> # SQLAlchemy statement cache
>>> some_cache = {key: "some sql value"}
Traceback (most recent call last): File "<stdin>", line 1,
in <module> TypeError: unhashable type: 'dict'

Тип можно сделать кэшируемым, присвоив отсортированный кортеж кортежей атрибуту «.lookup»:

class LookupType(UserDefinedType):
    '''a custom type that accepts a dictionary as a parameter.

    The dictionary is stored both as itself in a private variable,
    and published in a public variable as a sorted tuple of tuples,
    which is hashable and will also return the same value for any
    two equivalent dictionaries.  Note it assumes the keys and
    values of the dictionary are themselves hashable.

    '''

    cache_ok = True

    def __init__(self, lookup):
        self._lookup = lookup

        # assume keys/values of "lookup" are hashable; otherwise
        # they would also need to be converted in some way here
        self.lookup = tuple(
            (key, lookup[key]) for key in sorted(lookup)
        )

    def get_col_spec(self, **kw):
        return "VARCHAR(255)"

    def bind_processor(self, dialect):
        # ...  works with "self._lookup" ...

Там, где указано выше, ключ кэша для LookupType({"a": 10, "b": 20}) будет:

>>> LookupType({"a": 10, "b": 20})._static_cache_key
(<class '__main__.LookupType'>, ('lookup', (('a', 10), ('b', 20))))

Добавлено в версии 1.4.14: - added the cache_ok flag to allow some configurability of caching for TypeDecorator classes.

Добавлено в версии 1.4.28: - added the ExternalType mixin which generalizes the cache_ok flag to both the TypeDecorator and UserDefinedType classes.

См.также

Кэширование компиляции SQL

class sqlalchemy.types.Variant¶

Устаревший. Символ присутствует для обратной совместимости с обходными рецептами, однако этот фактический тип не должен использоваться.

Members

with_variant()

Классная подпись

класс sqlalchemy.types.Variant (sqlalchemy.types.TypeDecorator)

method sqlalchemy.types.Variant.with_variant(type_: _TypeEngineArgument[Any], *dialect_names: str) → Self¶

наследуется от TypeEngine.with_variant() метода TypeEngine

Создает копию объекта данного типа, который будет использовать данный тип при применении к диалекту данного имени.

например:

from sqlalchemy.types import String
from sqlalchemy.dialects import mysql

string_type = String()

string_type = string_type.with_variant(
    mysql.VARCHAR(collation='foo'), 'mysql', 'mariadb'
)

Вариантное отображение указывает, что когда данный тип интерпретируется определенным диалектом, он будет трансмутирован в данный тип, вместо того, чтобы использовать первичный тип.

Изменено в версии 2.0: метод TypeEngine.with_variant() теперь работает с объектом TypeEngine «на месте», возвращая копию исходного типа, а не возвращая объект-обертку; класс Variant больше не используется.

Параметры:

• type_ – TypeEngine, который будет выбран в качестве варианта из исходного типа, если используется диалект с данным именем.

• *dialect_names – одно или несколько базовых имен диалекта, использующего данный тип. (т.е. 'postgresql', 'mysql' и т.д.) … versionchanged:: 2.0 Для одного варианта может быть указано несколько имен диалектов.

См.также

Использование «UPPERCASE» и типов, специфичных для бэкенда, для нескольких бэкендов - иллюстрирует использование TypeEngine.with_variant().