Иерархия типов¶

SQLAlchemy предоставляет абстракции для большинства распространенных типов данных баз данных, а также несколько техник для настройки типов данных.

Типы баз данных представлены с помощью классов Python, все из которых в конечном счете расширяются от класса базового типа, известного как TypeEngine. Существует две общие категории типов данных, каждая из которых по-разному выражается в иерархии типов. Категория, используемая отдельным классом типа данных, может быть определена на основе использования двух различных соглашений об именовании - «CamelCase» и «UPPERCASE».

См.также

Установить - в Унифицированный учебник по SQLAlchemy. Иллюстрирует самое элементарное использование объектов типа TypeEngine для определения метаданных Table и вводит понятие объектов типа в обучающей форме.

Типы данных «CamelCase»¶

Рудиментарные типы имеют имена «CamelCase», такие как String, Numeric, Integer и DateTime. Все непосредственные подклассы TypeEngine являются типами «CamelCase». Типы «CamelCase» в максимально возможной степени независимы от базы данных, что означает, что все они могут быть использованы на любом бэкенде базы данных, где они будут вести себя таким образом, который соответствует этому бэкенду, чтобы создать желаемое поведение.

Примером прямого типа данных «CamelCase» является String. На большинстве бэкендов использование этого типа данных в table specification будет соответствовать типу базы данных VARCHAR, используемому на целевом бэкенде, передавая строковые значения в базу данных и из нее, как в примере ниже:

from sqlalchemy import MetaData
from sqlalchemy import Table, Column, Integer, String

metadata_obj = MetaData()

user = Table(
    "user",
    metadata_obj,
    Column("user_name", String, primary_key=True),
    Column("email_address", String(60)),
)

При использовании определенного класса TypeEngine в определении Table или в общем выражении SQL, если аргументы не требуются, он может быть передан как сам класс, то есть без инстанцирования его с помощью (). Если аргументы необходимы, как, например, аргумент длины 60 в столбце "email_address" выше, тип может быть инстанцирован.

Другой тип данных «CamelCase», который выражает более специфическое для бэкенда поведение, - это тип данных Boolean. В отличие от String, который представляет строковый тип данных, который есть во всех базах данных, не каждый бэкенд имеет настоящий «булевый» тип данных; некоторые используют целые числа или BIT значения 0 и 1, некоторые имеют булевые литеральные константы true и false, а другие нет. Для этого типа данных Boolean может отображаться BOOLEAN на бэкенде, таком как PostgreSQL, BIT на бэкенде MySQL и SMALLINT на Oracle. Поскольку данные отправляются и принимаются из базы данных с использованием этого типа, в зависимости от используемого диалекта он может интерпретировать числовые или булевы значения Python.

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

Ссылка на общий набор типов данных «CamelCase» находится ниже по ссылке Общие типы «CamelCase».

Типы данных «UPPERCASE»¶

В отличие от типов «CamelCase» существуют типы данных «UPPERCASE». Эти типы данных всегда наследуются от определенного типа данных «CamelCase» и всегда представляют собой точный тип данных. При использовании типа данных «UPPERCASE» имя типа всегда отображается в точности так, как оно задано, без учета того, поддерживает ли его текущий бэкенд. Поэтому использование типов «UPPERCASE» в приложении SQLAlchemy указывает на то, что требуются определенные типы данных, что подразумевает, что приложение обычно, без дополнительных шагов, будет ограничено теми бэкендами, которые используют тип именно так, как он задан. Примерами типов UPPERCASE являются VARCHAR, NUMERIC, INTEGER и TIMESTAMP, которые наследуются непосредственно от ранее упомянутых типов «CamelCase» String, Numeric, Integer и DateTime соответственно.

Типы данных «UPPERCASE», которые являются частью sqlalchemy.types, являются обычными типами SQL, которые обычно ожидаются доступными как минимум на двух бэкендах, если не больше.

Ссылка на общий набор типов данных «UPPERCASE» приведена ниже в Стандартный SQL и типы «UPPERCASE» нескольких поставщиков.

Специфические для бэкенда типы данных «UPPERCASE»¶

Большинство баз данных также имеют свои собственные типы данных, которые либо полностью специфичны для этих баз данных, либо добавляют дополнительные аргументы, специфичные для этих баз данных. Для таких типов данных определенные диалекты SQLAlchemy предоставляют специфичные для бэкенда «UPPERCASE» типы данных, для типа SQL, который не имеет аналогов в других бэкендах. Примерами специфических для бэкенда прописных типов данных являются JSONB в PostgreSQL, IMAGE в SQL Server и TINYTEXT в MySQL.

Определенные бэкенды могут также включать типы данных «UPPERCASE», которые расширяют аргументы, доступные в том же типе данных «UPPERCASE», который находится в модуле sqlalchemy.types. Например, при создании строкового типа данных MySQL можно указать специфические для MySQL аргументы, такие как charset или national, которые доступны в MySQL версии VARCHAR в виде параметров VARCHAR.charset и VARCHAR.national, доступных только для MySQL.

Документация API для типов, специфичных для бэкенда, находится в документации для конкретного диалекта, перечисленной в Диалекты.

Использование «UPPERCASE» и типов, специфичных для бэкенда, для нескольких бэкендов¶

Рассмотрение наличия типов «UPPERCASE» и «CamelCase» приводит к естественному случаю использования типов данных «UPPERCASE» для опций, специфичных для бэкенда, но только когда этот бэкенд используется. Чтобы связать вместе системы «CamelCase», не зависящие от базы данных, и «UPPERCASE», специфичные для бэкенда, используется метод TypeEngine.with_variant(), чтобы составить типы вместе для работы с определенным поведением на конкретных бэкендах.

Например, для использования типа данных String, но при работе на MySQL для использования параметра VARCHAR.charset из VARCHAR при создании таблицы на MySQL или MariaDB можно использовать TypeEngine.with_variant(), как показано ниже:

from sqlalchemy import MetaData
from sqlalchemy import Table, Column, Integer, String
from sqlalchemy.dialects.mysql import VARCHAR

metadata_obj = MetaData()

user = Table(
    "user",
    metadata_obj,
    Column("user_name", String(100), primary_key=True),
    Column(
        "bio",
        String(255).with_variant(VARCHAR(255, charset="utf8"), "mysql", "mariadb"),
    ),
)

В приведенном выше определении таблицы столбец "bio" будет иметь строковое поведение на всех бэкендах. На большинстве бэкендов он будет отображаться в DDL как VARCHAR. Однако на MySQL и MariaDB (на это указывают URL базы данных, начинающиеся с mysql или mariadb), он будет отображаться как VARCHAR(255) CHARACTER SET utf8.

См.также

TypeEngine.with_variant() - дополнительные примеры использования и примечания

Общие типы «CamelCase»¶

Общие типы задают столбец, который может читать, записывать и хранить определенный тип данных Python. SQLAlchemy при выпуске оператора CREATE TABLE будет выбирать наилучший тип столбца базы данных, доступный в целевой базе данных. Для полного контроля над тем, какой тип столбца выдается в CREATE TABLE, например VARCHAR, смотрите Стандартный SQL и типы «UPPERCASE» нескольких поставщиков и другие разделы этой главы.

Object Name	Description
BigInteger	Тип для больших целых чисел `int`.
Boolean	Тип данных bool.
Date	Тип для объектов `datetime.date()`.
DateTime	Тип для объектов `datetime.datetime()`.
Double	Тип для двойных `FLOAT` типов с плавающей точкой.
Enum	Generic Enum Type.
Float	Тип, представляющий типы с плавающей точкой, такие как `FLOAT` или `REAL`.
Integer	Тип для целых чисел `int`.
Interval	Тип для объектов `datetime.timedelta()`.
LargeBinary	Тип для больших двоичных байтовых данных.
MatchType	Относится к возвращаемому типу оператора MATCH.
Numeric	База для нецелых числовых типов, таких как `NUMERIC`, `FLOAT`, `DECIMAL` и других вариантов.
PickleType	Хранит объекты Python, которые сериализуются с помощью pickle.
SchemaType	Добавить возможности к типу, которые позволяют ассоциировать DDL на уровне схемы с типом.
SmallInteger	Тип для небольших целых чисел `int`.
String	Основа для всех типов строк и символов.
Text	Тип строки с переменным размером.
Time	Тип для объектов `datetime.time()`.
Unicode	Строковый тип Unicode переменной длины.
UnicodeText	Строковый тип Unicode неограниченной длины.
Uuid	Представляет собой тип данных UUID, не зависящий от базы данных.

class sqlalchemy.types.BigInteger¶

Тип для больших целых чисел int.

Обычно генерирует BIGINT в DDL, а в остальном действует как обычный Integer на стороне Python.

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

класс sqlalchemy.types.BigInteger (sqlalchemy.types.Integer)

class sqlalchemy.types.Boolean¶

Тип данных bool.

Boolean обычно использует BOOLEAN или SMALLINT на стороне DDL, а на стороне Python имеет дело с True или False.

Тип данных Boolean в настоящее время имеет два уровня утверждения, что сохраняемые значения являются простыми значениями true/false. Для всех бэкендов в качестве значений параметров принимаются только значения None, True, False, 1 или 0. Для тех бэкендов, которые не поддерживают тип данных «native boolean», существует возможность также создать ограничение CHECK для целевого столбца

Изменено в версии 1.2: тип данных Boolean теперь утверждает, что входящие значения Python уже находятся в чистой булевой форме.

Members

__init__(), bind_processor(), literal_processor(), python_type, result_processor()

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

class sqlalchemy.types.Boolean (sqlalchemy.types.SchemaType, sqlalchemy.types.Emulated, sqlalchemy.types.TypeEngine)

method sqlalchemy.types.Boolean.__init__(create_constraint: bool = False, name: Optional[str] = None, _create_events: bool = True, _adapted_from: Optional[SchemaType] = None)¶

Сконструируйте булево значение.

Параметры:

create_constraint – по умолчанию имеет значение False. Если булево значение генерируется как int/smallint, также создайте ограничение CHECK на таблице, которое гарантирует 1 или 0 в качестве значения. … примечание:: настоятельно рекомендуется, чтобы ограничение CHECK имело явное имя для поддержки управления схемой. Это можно сделать либо путем установки параметра Boolean.name, либо путем создания соответствующего соглашения об именовании; см. справочную информацию в Настройка соглашений об именовании ограничений. … versionchanged:: 1.4 - этот флаг теперь имеет значение по умолчанию False, что означает, что для неродного перечислимого типа не генерируется ограничение CHECK.
name – если создается ограничение CHECK, укажите имя ограничения.

method sqlalchemy.types.Boolean.bind_processor(dialect)¶

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

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

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

Примечание

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

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

См.также

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

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

method sqlalchemy.types.Boolean.literal_processor(dialect)¶

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

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

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

Примечание

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

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

См.также

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

attribute sqlalchemy.types.Boolean.python_type¶

method sqlalchemy.types.Boolean.result_processor(dialect, coltype)¶

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

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

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

Примечание

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

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

См.также

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

Параметры:

dialect – Используемый диалектный экземпляр.
coltype – DBAPI coltype аргумент, полученный в cursor.description.

class sqlalchemy.types.Date¶

Тип для объектов datetime.date().

Members

get_dbapi_type(), literal_processor(), python_type

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

class sqlalchemy.types.Date (sqlalchemy.types._RenderISO8601NoT, sqlalchemy.types.HasExpressionLookup, sqlalchemy.types.TypeEngine)

method sqlalchemy.types.Date.get_dbapi_type(dbapi)¶

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

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

method sqlalchemy.types.Date.literal_processor(dialect)¶

Примечание

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

См.также

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

attribute sqlalchemy.types.Date.python_type¶

class sqlalchemy.types.DateTime¶

Тип для объектов datetime.datetime().

Типы даты и времени возвращают объекты из модуля Python datetime. Большинство DBAPI имеют встроенную поддержку модуля datetime, за исключением SQLite. В случае SQLite типы даты и времени хранятся в виде строк, которые затем преобразуются обратно в объекты datetime при возврате строк.

Для представления времени в типе datetime некоторые бэкенды включают дополнительные опции, такие как поддержка часовых поясов и дробных секунд. Для дробных секунд используйте тип данных, специфичный для диалекта, например TIME. Для поддержки часовых поясов используйте по крайней мере тип данных TIMESTAMP, если не диалектный объект типа данных.

Members

__init__(), get_dbapi_type(), literal_processor(), python_type

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

class sqlalchemy.types.DateTime (sqlalchemy.types._RenderISO8601NoT, sqlalchemy.types.HasExpressionLookup, sqlalchemy.types.TypeEngine)

method sqlalchemy.types.DateTime.__init__(timezone: bool = False)¶

Создайте новый DateTime.

Параметры:: timezone – булево. Указывает, что тип datetime должен включать поддержку временных зон, если она доступна только для базового типа удержания даты/времени. Рекомендуется использовать непосредственно тип данных TIMESTAMP при использовании этого флага, так как некоторые базы данных включают отдельные общие типы даты/времени, отличные от типа данных TIMESTAMP с поддержкой временных зон, например, Oracle.

method sqlalchemy.types.DateTime.get_dbapi_type(dbapi)¶

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

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

method sqlalchemy.types.DateTime.literal_processor(dialect)¶

Примечание

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

См.также

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

attribute sqlalchemy.types.DateTime.python_type¶

class sqlalchemy.types.Enum¶

Generic Enum Type.

Тип Enum предоставляет набор возможных строковых значений, на которые ограничивается столбец.

Тип Enum будет использовать собственный тип бэкенда «ENUM», если он доступен; в противном случае он использует тип данных VARCHAR. Также существует возможность автоматически создавать ограничение CHECK, когда создается вариант VARCHAR (так называемый «неродной»); см. флаг Enum.create_constraint.

Тип Enum также обеспечивает проверку строковых значений на языке Python во время операций чтения и записи. При чтении значения из базы данных в наборе результатов строковое значение всегда проверяется по списку возможных значений, и при отсутствии совпадения выдается сообщение LookupError. При передаче значения в базу данных в виде простой строки в операторе SQL, если параметр Enum.validate_strings установлен в True, то для любого строкового значения, которое не находится в заданном списке возможных значений, выдается ошибка LookupError; обратите внимание, что это влияет на использование выражений LIKE с перечислимыми значениями (необычный случай использования).

Источником перечисляемых значений может быть список строковых значений или альтернативный перечисляемый класс, соответствующий стандарту PEP-435. Для целей типа данных Enum этот класс должен предоставлять только метод __members__.

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

import enum
from sqlalchemy import Enum

class MyEnum(enum.Enum):
    one = 1
    two = 2
    three = 3

t = Table(
    'data', MetaData(),
    Column('value', Enum(MyEnum))
)

connection.execute(t.insert(), {"value": MyEnum.two})
assert connection.scalar(t.select()) is MyEnum.two

Выше, строковые имена каждого элемента, например, «один», «два», «три», сохраняются в базе данных; значения Python Enum, обозначенные здесь как целые числа, не используются; значение каждого перечисления может быть любым объектом Python, независимо от того, является ли он сохраняемым или нет.

Чтобы сохранить значения, а не имена, можно использовать параметр Enum.values_callable. Значение этого параметра представляет собой пользовательскую вызываемую переменную, которая предназначена для использования с перечислимым классом, соответствующим стандарту PEP-435, и возвращает список строковых значений, которые необходимо сохранить. Для простого перечисления, использующего строковые значения, достаточно такой вызываемой переменной, как lambda x: [e.value for e in x].

См.также

Использование типов Python Enum или pep-586 Literal в карте типов - информация об использовании типа данных Enum с функцией ORM Annotated Declarative в ORM.

ENUM - специфический для PostgreSQL тип, обладающий дополнительной функциональностью.

ENUM - специфический для MySQL тип

Members

__init__(), create(), drop()

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

class sqlalchemy.types.Enum (sqlalchemy.types.String, sqlalchemy.types.SchemaType, sqlalchemy.types.Emulated, sqlalchemy.types.TypeEngine)

method sqlalchemy.types.Enum.__init__(*enums: object, **kw: Any)¶

Постройте перечисление.

Аргументы ключевых слов, которые не относятся к определенному бэкенду, игнорируются этим бэкендом.

Параметры:

*enums – либо ровно один перечислимый тип, соответствующий стандарту PEP-435, либо одна или несколько строковых меток.
create_constraint – по умолчанию имеет значение False. При создании неродного перечислимого типа также создайте ограничение CHECK в базе данных на допустимые значения. … примечание:: настоятельно рекомендуется, чтобы ограничение CHECK имело явное имя для поддержки управления схемой. Это можно сделать либо задав параметр Enum.name, либо установив соответствующее соглашение об именовании; см. справочную информацию в Настройка соглашений об именовании ограничений. … versionchanged:: 1.4 - этот флаг теперь имеет значение по умолчанию False, что означает, что для неродного перечислимого типа не генерируется ограничение CHECK.
metadata – Свяжите этот тип непосредственно с объектом MetaData. Для типов, существующих в целевой базе данных как независимая конструкция схемы (PostgreSQL), этот тип будет создаваться и удаляться в рамках операций create_all() и drop_all(). Если тип не связан ни с одним объектом MetaData, он будет связан с каждой Table, в которой он используется, и будет создан при создании любой из этих отдельных таблиц после проверки на его существование. Однако тип будет сброшен только тогда, когда drop_all() будет вызван для метаданных этого Table объекта. Значение параметра MetaData.schema объекта MetaData, если оно установлено, будет использоваться как значение по умолчанию Enum.schema для этого объекта, если явное значение не указано. … versionchanged:: 1.4.12 Enum наследует параметр MetaData.schema объекта MetaData, если он присутствует, при передаче с помощью параметра Enum.metadata.
name – Имя данного типа. Это необходимо для PostgreSQL и любой будущей поддерживаемой базы данных, которая требует явно названного типа или явно названного ограничения, чтобы создать тип и/или таблицу, которая его использует. Если использовался перечислимый класс PEP-435, то по умолчанию используется его имя (преобразованное в нижний регистр).
native_enum – Использовать собственный тип ENUM базы данных, если он доступен. По умолчанию установлено значение True. Если False, используется VARCHAR + ограничение проверки для всех бэкендов. Когда False, длина VARCHAR может контролироваться с помощью Enum.length; в настоящее время «длина» игнорируется, если native_enum=True.
length – Позволяет указать пользовательскую длину для VARCHAR, когда используется неродной тип данных перечисления. По умолчанию используется длина самого длинного значения. … versionchanged:: 2.0.0 Параметр Enum.length безоговорочно используется для рендеринга VARCHAR независимо от параметра Enum.native_enum для тех бэкендов, где VARCHAR используется для перечислимых типов данных.
schema – Имя схемы данного типа. Для типов, которые существуют в целевой базе данных как независимая конструкция схемы (PostgreSQL), этот параметр указывает именованную схему, в которой присутствует тип. Если он отсутствует, имя схемы будет взято из коллекции MetaData, если передано как Enum.metadata, для MetaData, включающего параметр MetaData.schema. … versionchanged:: 1.4.12 Enum наследует параметр MetaData.schema объекта MetaData, если он присутствует, при передаче с помощью параметра Enum.metadata. В противном случае, если флаг Enum.inherit_schema установлен в True, схема будет наследоваться от связанного объекта Table, если таковой имеется; когда Enum.inherit_schema имеет значение по умолчанию False, схема таблицы-владельца не используется.
quote – Установите предпочтения явного цитирования для имени типа.
inherit_schema – Когда True, «схема» из принадлежащего Table будет скопирована в атрибут «схема» этого Enum, заменяя любое значение, переданное для атрибута schema. Это также вступает в силу при использовании операции Table.to_metadata().
validate_strings – при значении True строковые значения, передаваемые в базу данных в SQL-запросе, будут проверяться на достоверность по списку перечисленных значений. Нераспознанные значения приведут к появлению сообщения LookupError.
values_callable – Вызываемый объект, которому будет передан перечислимый тип, соответствующий стандарту PEP-435, который затем должен вернуть список строковых значений для сохранения. Это позволяет использовать альтернативные варианты, например, использовать строковое значение перечисления для сохранения в базе данных вместо его имени. … versionadded:: 1.2.3
sort_key_function – Python callable, который может быть использован в качестве аргумента «ключ» во встроенной функции Python sorted(). SQLAlchemy ORM требует, чтобы столбцы первичного ключа, которые отображаются, были каким-то образом сортируемыми. При использовании несортируемого объекта перечисления, такого как объект Python 3 Enum, этот параметр может быть использован для установки функции ключа сортировки по умолчанию для объектов. По умолчанию в качестве функции сортировки используется значение базы данных перечисления. … versionadded:: 1.3.8
omit_aliases – Булево значение, которое при значении true будет удалять псевдонимы из перечислений pep 435. по умолчанию True. … versionchanged:: 2.0 Этот параметр теперь имеет значение по умолчанию True.

method sqlalchemy.types.Enum.create(bind, checkfirst=False)¶: наследуется от SchemaType.create() метода SchemaType

Выпустите CREATE DDL для этого типа, если применимо.

method sqlalchemy.types.Enum.drop(bind, checkfirst=False)¶: наследуется от SchemaType.drop() метода SchemaType

Выпустите DROP DDL для этого типа, если применимо.

class sqlalchemy.types.Double¶

Тип для двойных FLOAT типов с плавающей точкой.

Обычно генерирует DOUBLE или DOUBLE_PRECISION в DDL, а в остальном действует как обычный Float на стороне Python.

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

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

класс sqlalchemy.types.Double (sqlalchemy.types.Float)

class sqlalchemy.types.Float¶

Тип, представляющий типы с плавающей точкой, такие как FLOAT или REAL.

Этот тип по умолчанию возвращает объекты Python float, если только флаг Float.asdecimal не установлен в True, в этом случае они принудительно преобразуются в объекты decimal.Decimal.

Members

__init__(), result_processor()

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

класс sqlalchemy.types.Float (sqlalchemy.types.Numeric)

method sqlalchemy.types.Float.__init__(precision: Optional[int] = None, asdecimal: bool = False, decimal_return_scale: Optional[int] = None)¶

Постройте поплавок.

Параметры:

precision – числовая точность для использования в DDL CREATE TABLE. Бэкенды должны пытаться обеспечить, чтобы эта точность указывала на число цифр для общего типа данных Float. … примечание:: Для бэкенда Oracle параметр Float.precision не принимается при рендеринге DDL, поскольку Oracle не поддерживает точность float, указанную как число десятичных знаков. Вместо этого используйте специфический для Oracle тип данных FLOAT и укажите параметр FLOAT.binary_precision. Это новое в версии 2.0 SQLAlchemy. Чтобы создать независимый от базы данных Float, отдельно указывающий двоичную точность для Oracle, используйте TypeEngine.with_variant() следующим образом: from sqlalchemy import Column from sqlalchemy import Float from sqlalchemy.dialects import oracle Column( «float_data», Float(5).with_variant(oracle.FLOAT(binary_precision=16), «oracle») )
asdecimal – тот же флаг, что и у Numeric, но по умолчанию имеет значение False. Обратите внимание, что установка этого флага в значение True приводит к преобразованию с плавающей точкой.
decimal_return_scale – Масштаб по умолчанию, используемый при преобразовании значений с плавающей точкой в десятичные числа Python. Значения с плавающей точкой обычно намного длиннее из-за неточности десятичных дробей, а большинство типов баз данных с плавающей точкой не имеют понятия «масштаб», поэтому по умолчанию тип float ищет первые десять десятичных знаков при преобразовании. Указание этого значения отменяет эту длину. Обратите внимание, что типы MySQL float, которые включают «масштаб», будут использовать «масштаб» по умолчанию для decimal_return_scale, если не указано иное.

method sqlalchemy.types.Float.result_processor(dialect, coltype)¶

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

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

Примечание

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

См.также

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

Параметры:

dialect – Используемый диалектный экземпляр.
coltype – DBAPI coltype аргумент, полученный в cursor.description.

class sqlalchemy.types.Integer¶

Тип для целых чисел int.

Members

get_dbapi_type(), literal_processor(), python_type

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

класс sqlalchemy.types.Integer (sqlalchemy.types.HasExpressionLookup, sqlalchemy.types.TypeEngine)

method sqlalchemy.types.Integer.get_dbapi_type(dbapi)¶

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

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

method sqlalchemy.types.Integer.literal_processor(dialect)¶

Примечание

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

См.также

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

attribute sqlalchemy.types.Integer.python_type¶

class sqlalchemy.types.Interval¶

Тип для объектов datetime.timedelta().

Тип Interval работает с объектами datetime.timedelta. В PostgreSQL используется собственный тип INTERVAL; для других типов значение хранится как дата, которая является относительной к «эпохе» (1 января 1970 года).

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

Members

__init__(), adapt_to_emulated(), bind_processor(), cache_ok, coerce_compared_value(), comparator_factory, impl, python_type, result_processor()

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

class sqlalchemy.types.Interval (sqlalchemy.types.Emulated, sqlalchemy.types._AbstractInterval, sqlalchemy.types.TypeDecorator)

class Comparator¶: Классная подпись

класс sqlalchemy.types.Interval.Comparator (sqlalchemy.types.Comparator, sqlalchemy.types.Comparator)

method sqlalchemy.types.Interval.__init__(native: bool = True, second_precision: Optional[int] = None, day_precision: Optional[int] = None)¶

Создайте объект Interval.

Параметры:

native – если True, использовать фактический тип INTERVAL, предоставляемый базой данных, если он поддерживается (в настоящее время PostgreSQL, Oracle). В противном случае данные интервала представляются как значение эпохи независимо от этого.
second_precision – Для собственных типов интервалов, которые поддерживают параметр «точность долей секунды», т.е. Oracle и PostgreSQL
day_precision – для собственных типов интервалов, которые поддерживают параметр «точность дня», т.е. Oracle.

method sqlalchemy.types.Interval.adapt_to_emulated(impltype, **kw)¶

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

Имплант также должен быть «эмулированной» версией этого типа, скорее всего, того же класса, что и сам тип.

например: sqltypes.Enum адаптируется к классу Enum.

method sqlalchemy.types.Interval.bind_processor(dialect: Dialect) → _BindProcessorType[dt.timedelta]¶

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

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

Примечание

См.также

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

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

attribute sqlalchemy.types.Interval.cache_ok: Optional[bool] = True¶

Укажите, являются ли утверждения, использующие этот 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

method sqlalchemy.types.Interval.coerce_compared_value(op, value)¶

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

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

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

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

attribute sqlalchemy.types.Interval.comparator_factory¶: alias of Comparator

attribute sqlalchemy.types.Interval.impl¶: alias of DateTime

attribute sqlalchemy.types.Interval.python_type¶

method sqlalchemy.types.Interval.result_processor(dialect: Dialect, coltype: Any) → _ResultProcessorType[dt.timedelta]¶

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

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

Примечание

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

См.также

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

Параметры:

dialect – Используемый диалектный экземпляр.
coltype – DBAPI coltype аргумент, полученный в cursor.description.

class sqlalchemy.types.LargeBinary¶

Тип для больших двоичных байтовых данных.

Тип LargeBinary соответствует большому и/или недлинному двоичному типу для целевой платформы, например BLOB для MySQL и BYTEA для PostgreSQL. Он также обрабатывает необходимые преобразования для DBAPI.

Members

__init__()

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

класс sqlalchemy.types.LargeBinary (sqlalchemy.types._Binary)

method sqlalchemy.types.LargeBinary.__init__(length: Optional[int] = None)¶

Создайте тип LargeBinary.

Параметры:: length – опционально, длина столбца для использования в DDL-запросах, для тех бинарных типов, которые принимают длину, например, тип MySQL BLOB.

class sqlalchemy.types.MatchType¶

Относится к возвращаемому типу оператора MATCH.

Поскольку ColumnOperators.match() является, вероятно, самым неограниченным оператором в общем ядре SQLAlchemy Core, мы не можем предположить возвращаемый тип во время оценки SQL, поскольку MySQL возвращает плавающую точку, а не булеву, а другие бэкенды могут делать что-то другое. Поэтому этот тип действует как заполнитель, в настоящее время подклассифицируя Boolean. Тип позволяет диалектам внедрять функциональность обработки результатов, если это необходимо, и на MySQL будет возвращать значения с плавающей точкой.

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

класс sqlalchemy.types.MatchType (sqlalchemy.types.Boolean)

class sqlalchemy.types.Numeric¶

База для нецелых числовых типов, таких как NUMERIC, FLOAT, DECIMAL и других вариантов.

Тип данных Numeric при непосредственном использовании будет отображать DDL, соответствующий точным числовым значениям, если они доступны, например NUMERIC(precision, scale). Подкласс Float попытается отобразить тип данных с плавающей точкой, например FLOAT(precision).

По умолчанию Numeric возвращает объекты Python decimal.Decimal, основываясь на значении по умолчанию True для параметра Numeric.asdecimal. Если этот параметр установлен в False, возвращаемые значения принудительно приводятся к объектам Python float.

Подтип Float, будучи более специфичным для плавающей точки, по умолчанию устанавливает флаг Float.asdecimal в False, так что по умолчанию в Python используется тип данных float.

Примечание

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

Members

__init__(), bind_processor(), get_dbapi_type(), literal_processor(), python_type, result_processor()

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

класс sqlalchemy.types.Numeric (sqlalchemy.types.HasExpressionLookup, sqlalchemy.types.TypeEngine)

method sqlalchemy.types.Numeric.__init__(precision: Optional[int] = None, scale: Optional[int] = None, decimal_return_scale: Optional[int] = None, asdecimal: bool = True)¶

Постройте числовое значение.

Параметры:

precision – числовая точность для использования в DDL CREATE TABLE.
scale – числовая шкала для использования в DDL CREATE TABLE.
asdecimal – по умолчанию True. Возвращает, следует ли отправлять значения в виде десятичных объектов Python или в виде плавающих чисел. Различные DBAPI отправляют одно или другое, основываясь на типах данных - тип Numeric обеспечит постоянство возвращаемых значений в DBAPI.
decimal_return_scale – Масштаб по умолчанию, используемый при преобразовании значений с плавающей точкой в десятичные числа Python. Значения с плавающей точкой обычно намного длиннее из-за неточности десятичных дробей, а большинство типов баз данных с плавающей точкой не имеют понятия «масштаб», поэтому по умолчанию тип float ищет первые десять десятичных знаков при преобразовании. Указание этого значения отменяет эту длину. Типы, которые включают явное значение «.scale», такие как база Numeric, а также типы MySQL float, будут использовать значение «.scale» по умолчанию для decimal_return_scale, если не указано иное.

При использовании типа Numeric следует убедиться, что параметр asdecimal соответствует используемому DBAPI - когда Numeric применяет преобразование из Decimal->float или float-> Decimal, это преобразование влечет за собой дополнительные затраты производительности для всех полученных столбцов результатов.

DBAPI, возвращающие десятичные числа (например, psycopg2), будут иметь лучшую точность и более высокую производительность при установке True, поскольку перевод в десятичную систему сокращает количество проблем с плавающей точкой, и сам тип Numeric не нуждается в дополнительных преобразованиях. Однако, другой DBAPI, который изначально возвращает плавающие числа, будет нести дополнительные накладные расходы на преобразование, и все еще подвержен потере данных с плавающей точкой - в этом случае asdecimal=False по крайней мере устранит дополнительные накладные расходы на преобразование.

method sqlalchemy.types.Numeric.bind_processor(dialect)¶

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

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

Примечание

См.также

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

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

method sqlalchemy.types.Numeric.get_dbapi_type(dbapi)¶

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

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

method sqlalchemy.types.Numeric.literal_processor(dialect)¶

Примечание

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

См.также

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

attribute sqlalchemy.types.Numeric.python_type¶

method sqlalchemy.types.Numeric.result_processor(dialect, coltype)¶

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

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

Примечание

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

См.также

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

Параметры:

dialect – Используемый диалектный экземпляр.
coltype – DBAPI coltype аргумент, полученный в cursor.description.

class sqlalchemy.types.PickleType¶

Хранит объекты Python, которые сериализуются с помощью pickle.

PickleType основан на типе Binary, чтобы применять Python pickle.dumps() к входящим объектам и pickle.loads() на выходе, позволяя хранить любой pickleable Python объект в виде сериализованного двоичного поля.

Чтобы разрешить распространение событий изменений ORM для элементов, связанных с PickleType, см. Отслеживание мутаций.

Members

__init__(), bind_processor(), cache_ok, compare_values(), impl, result_processor()

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

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

method sqlalchemy.types.PickleType.__init__(protocol: int = 5, pickler: Any = None, comparator: Optional[Callable[[Any, Any], bool]] = None, impl: Optional[_TypeEngineArgument[Any]] = None)¶

Создайте PickleType.

Параметры:

protocol – по умолчанию pickle.HIGHEST_PROTOCOL.
pickler – По умолчанию используется pickle. Может быть любым объектом с совместимыми с pickle методами dumps и loads.
comparator – 2-арговый вызываемый предикат, используемый для сравнения значений данного типа. Если оставить значение None, то для сравнения значений используется оператор Python «equals».
impl – Класс или экземпляр TypeEngine, хранящий двоичные значения, который используется вместо LargeBinary по умолчанию. Например, класс :class: _mysql.LONGBLOB может быть более эффективным при использовании MySQL. … версия добавлена:: 1.4.20

method sqlalchemy.types.PickleType.bind_processor(dialect)¶

Предоставить функцию обработки связанного значения для заданного Dialect.

Это метод, выполняющий контракт TypeEngine для преобразования связанного значения, которое обычно происходит через метод TypeEngine.bind_processor().

Примечание

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

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

attribute sqlalchemy.types.PickleType.cache_ok: Optional[bool] = True¶

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

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')))

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')

>>> # 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

method sqlalchemy.types.PickleType.compare_values(x, y)¶

Учитывая два значения, сравните их на равенство.

По умолчанию это вызывает TypeEngine.compare_values() из базового «impl», который, в свою очередь, обычно использует оператор равенства Python ==.

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

attribute sqlalchemy.types.PickleType.impl¶: alias of LargeBinary

method sqlalchemy.types.PickleType.result_processor(dialect, coltype)¶

Предоставить функцию обработки значения результата для заданного Dialect.

Это метод, выполняющий контракт TypeEngine для преобразования связанного значения, которое обычно происходит через метод TypeEngine.result_processor().

Примечание

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

Параметры:

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

class sqlalchemy.types.SchemaType¶

Добавить возможности к типу, которые позволяют ассоциировать DDL на уровне схемы с типом.

Поддерживает типы, которые должны быть явно созданы/удалены (т.е. тип PG ENUM), а также типы, которые дополняются ограничениями на уровне таблицы или схемы, триггерами и другими правилами.

Классы SchemaType также могут быть целями для событий DDLEvents.before_parent_attach() и DDLEvents.after_parent_attach(), где события срабатывают вокруг ассоциации объекта типа с родительским Column.

См.также

Enum

Boolean

Members

adapt(), copy(), create(), drop(), name

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

класс sqlalchemy.types.SchemaType (sqlalchemy.sql.expression.SchemaEventTarget, sqlalchemy.types.TypeEngineMixin)

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

method sqlalchemy.types.SchemaType.copy(**kw)¶

method sqlalchemy.types.SchemaType.create(bind, checkfirst=False)¶: Выпустите CREATE DDL для этого типа, если применимо.

method sqlalchemy.types.SchemaType.drop(bind, checkfirst=False)¶: Выпустите DROP DDL для этого типа, если применимо.

attribute sqlalchemy.types.SchemaType.name: Optional[str]¶

class sqlalchemy.types.SmallInteger¶

Тип для небольших целых чисел int.

Обычно генерирует SMALLINT в DDL, а в остальном действует как обычный Integer на стороне Python.

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

класс sqlalchemy.types.SmallInteger (sqlalchemy.types.Integer)

class sqlalchemy.types.String¶

Основа для всех типов строк и символов.

В SQL соответствует VARCHAR.

Поле length обычно требуется, когда тип String используется в операторе CREATE TABLE, так как VARCHAR требует длины в большинстве баз данных.

Members

__init__(), bind_processor(), get_dbapi_type(), literal_processor(), python_type, result_processor()

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

класс sqlalchemy.types.String (sqlalchemy.types.Concatenable, sqlalchemy.types.TypeEngine)

method sqlalchemy.types.String.__init__(length: Optional[int] = None, collation: Optional[str] = None)¶

Создайте тип, удерживающий строку.

Параметры:

length – необязательный, длина столбца для использования в выражениях DDL и CAST. Может быть опущена, если не будет выдаваться CREATE TABLE. Некоторые базы данных могут требовать length для использования в DDL, и будут выдавать исключение при выдаче CREATE TABLE DDL, если включена VARCHAR без длины. Интерпретируется ли значение как байты или как символы, зависит от конкретной базы данных.
collation – Необязательно, collation на уровне столбцов для использования в выражениях DDL и CAST. Используется ключевое слово COLLATE, поддерживаемое SQLite, MySQL и PostgreSQL. Например: … sourcecode:: pycon+sql >>> from sqlalchemy import cast, select, String >>> print(select(cast(„some string“, String(collation=“utf8“)))) {printsql}SELECT CAST(:param_1 AS VARCHAR COLLATE utf8) AS anon_1 … примечание:: В большинстве случаев для Unicode или UnicodeText следует использовать типы данных Column, которые предполагают хранение неасксичных данных. Эти типы данных гарантируют, что в базе данных используются правильные типы.

method sqlalchemy.types.String.bind_processor(dialect)¶

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

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

Примечание

См.также

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

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

method sqlalchemy.types.String.get_dbapi_type(dbapi)¶

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

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

method sqlalchemy.types.String.literal_processor(dialect)¶

Примечание

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

См.также

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

attribute sqlalchemy.types.String.python_type¶

method sqlalchemy.types.String.result_processor(dialect, coltype)¶

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

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

Примечание

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

См.также

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

Параметры:

dialect – Используемый диалектный экземпляр.
coltype – DBAPI coltype аргумент, полученный в cursor.description.

class sqlalchemy.types.Text¶

Тип строки с переменным размером.

В SQL обычно соответствует CLOB или TEXT. Как правило, объекты TEXT не имеют длины; хотя некоторые базы данных принимают здесь аргумент длины, другие его отвергают.

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

класс sqlalchemy.types.Text (sqlalchemy.types.String)

class sqlalchemy.types.Time¶

Тип для объектов datetime.time().

Members

get_dbapi_type(), literal_processor(), python_type

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

class sqlalchemy.types.Time (sqlalchemy.types._RenderISO8601NoT, sqlalchemy.types.HasExpressionLookup, sqlalchemy.types.TypeEngine)

method sqlalchemy.types.Time.get_dbapi_type(dbapi)¶

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

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

method sqlalchemy.types.Time.literal_processor(dialect)¶

Примечание

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

См.также

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

attribute sqlalchemy.types.Time.python_type¶

class sqlalchemy.types.Unicode¶

Строковый тип Unicode переменной длины.

Тип Unicode является подклассом String, который предполагает входные и выходные строки, которые могут содержать символы, отличные от ASCII, и для некоторых бэкендов подразумевает базовый тип столбца, который явно поддерживает данные, отличные от ASCII, например NVARCHAR в Oracle и SQL Server. Это повлияет на вывод операторов CREATE TABLE и функций CAST на уровне диалекта.

Кодировка символов, используемая типом Unicode, который используется для передачи и приема данных в базу данных, обычно определяется самим DBAPI. Все современные DBAPI поддерживают строки, отличные от ASCII, но могут иметь различные методы управления кодировками базы данных; при необходимости эта кодировка должна быть настроена, как подробно описано в примечаниях к целевой DBAPI в разделе Диалекты.

В современном SQLAlchemy использование типа данных Unicode не подразумевает никакого поведения кодирования/декодирования в самом SQLAlchemy. В Python 3 все строковые объекты по своей природе поддерживают Unicode, и SQLAlchemy не создает байтстринговые объекты и не использует DBAPI, который не возвращает объекты Python Unicode в наборах результатов для строковых значений.

Предупреждение

Некоторые бэкенды баз данных, в частности SQL Server с pyodbc, известны нежелательным поведением в отношении данных, которые отмечены как имеющие тип NVARCHAR в отличие от VARCHAR, включая ошибки несоответствия типа данных и неиспользование индексов. См. раздел DialectEvents.do_setinputsizes() для получения информации о работе над проблемами с символами юникода для таких бэкендов, как SQL Server с pyodbc, а также cx_Oracle.

См.также

UnicodeText - не удлиненный текстовый аналог Unicode.

DialectEvents.do_setinputsizes()

Members

__init__()

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

класс sqlalchemy.types.Unicode (sqlalchemy.types.String)

method sqlalchemy.types.Unicode.__init__(length=None, **kwargs)¶

Создайте объект Unicode.

Параметры те же, что и у String.

class sqlalchemy.types.UnicodeText¶

Строковый тип Unicode неограниченной длины.

См. Unicode для получения подробной информации о поведении этого объекта в юникоде.

Как и Unicode, использование типа UnicodeText подразумевает использование на бэкенде типа, поддерживающего уникод, например NCLOB, NTEXT.

Members

__init__()

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

класс sqlalchemy.types.UnicodeText (sqlalchemy.types.Text)

method sqlalchemy.types.UnicodeText.__init__(length=None, **kwargs)¶

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

Параметры те же, что и у TextClause.

class sqlalchemy.types.Uuid¶

Представляет собой тип данных UUID, не зависящий от базы данных.

Для бэкендов, не имеющих «родного» типа данных UUID, значение будет использовать CHAR(32) и хранить UUID как 32-символьную буквенно-цифровую шестнадцатеричную строку.

Для бэкендов, которые, как известно, поддерживают UUID напрямую или аналогичный тип данных для хранения uuid, такой как UNIQUEIDENTIFIER SQL Server, «родной» режим, включенный по умолчанию, позволяет использовать эти типы на этих бэкендах.

В режиме использования по умолчанию, тип данных Uuid ожидает Python uuid объекты, из модуля Python uuid:

import uuid

from sqlalchemy import Uuid
from sqlalchemy import Table, Column, MetaData, String


metadata_obj = MetaData()

t = Table(
    "t",
    metadata_obj,
    Column('uuid_data', Uuid, primary_key=True),
    Column("other_data", String)
)

with engine.begin() as conn:
    conn.execute(
        t.insert(),
        {"uuid_data": uuid.uuid4(), "other_data", "some data"}
    )

Чтобы тип данных Uuid работал со строковыми Uuids (например, с 32-символьными шестнадцатеричными строками), передайте параметру Uuid.as_uuid значение False.

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

См.также

UUID - представляет в точности тип данных UUID без какого-либо поведения, зависящего от бэкенда.

Members

__init__(), bind_processor(), coerce_compared_value(), literal_processor(), python_type, result_processor()

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

класс sqlalchemy.types.Uuid (sqlalchemy.types.Emulated, sqlalchemy.types.TypeEngine)

method sqlalchemy.types.Uuid.__init__(as_uuid: bool = True, native_uuid: bool = True)¶

Сконструируйте тип Uuid.

Параметры:

as_uuid=True – если True, то значения будут интерпретироваться как объекты Python uuid, конвертируемые в/из строки через DBAPI. … versionchanged: 2.0 as_uuid теперь по умолчанию True.
native_uuid=True – если True, то бэкенды, поддерживающие либо непосредственно тип данных UUID, либо значение, хранящее UUID (например, UNIQUEIDENTIFIER SQL Server), будут использоваться этими бэкендами. Если False, тип данных CHAR(32) будет использоваться для всех бэкендов, независимо от их поддержки.

method sqlalchemy.types.Uuid.bind_processor(dialect)¶

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

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

Примечание

См.также

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

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

method sqlalchemy.types.Uuid.coerce_compared_value(op, value)¶: Описание см. в разделе TypeEngine.coerce_compared_value().

method sqlalchemy.types.Uuid.literal_processor(dialect)¶

Примечание

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

См.также

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

attribute sqlalchemy.types.Uuid.python_type¶

method sqlalchemy.types.Uuid.result_processor(dialect, coltype)¶

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

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

Примечание

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

См.также

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

Параметры:

dialect – Используемый диалектный экземпляр.
coltype – DBAPI coltype аргумент, полученный в cursor.description.

Стандартный SQL и типы «UPPERCASE» нескольких поставщиков¶

Эта категория типов относится к типам, которые либо являются частью стандарта SQL, либо потенциально встречаются в подмножестве бэкендов баз данных. В отличие от «общих» типов, типы стандарта SQL/мультипроизводителей не имеют нет гарантии работы на всех бэкендах, и будут работать только на тех бэкендах, которые явно поддерживают их по имени. То есть, тип всегда будет выдавать свое точное имя в DDL при выдаче CREATE TABLE.

Object Name	Description
ARRAY	Представляет тип массива SQL.
BIGINT	Тип SQL BIGINT.
BINARY	Тип SQL BINARY.
BLOB	Тип SQL BLOB.
BOOLEAN	Тип SQL BOOLEAN.
CHAR	Тип SQL CHAR.
CLOB	Тип CLOB.
DATE	Тип SQL DATE.
DATETIME	Тип SQL DATETIME.
DECIMAL	Тип SQL DECIMAL.
DOUBLE	Тип SQL DOUBLE.
DOUBLE_PRECISION	Тип SQL DOUBLE PRECISION.
FLOAT	Тип SQL FLOAT.
INT	alias of `INTEGER`
INTEGER	Тип SQL INT или INTEGER.
JSON	Представляет тип SQL JSON.
NCHAR	Тип SQL NCHAR.
NUMERIC	Тип SQL NUMERIC.
NVARCHAR	Тип SQL NVARCHAR.
REAL	Тип SQL REAL.
SMALLINT	Тип SQL SMALLINT.
TEXT	Тип SQL TEXT.
TIME	Тип SQL TIME.
TIMESTAMP	Тип SQL TIMESTAMP.
UUID	Представляет тип SQL UUID.
VARBINARY	Тип SQL VARBINARY.
VARCHAR	Тип SQL VARCHAR.

class sqlalchemy.types.ARRAY¶

Представляет тип массива SQL.

Примечание

Этот тип служит основой для всех операций ARRAY. Однако в настоящее время только бэкенд PostgreSQL имеет поддержку SQL-массивов в SQLAlchemy. Рекомендуется использовать специфичный для PostgreSQL тип sqlalchemy.dialects.postgresql.ARRAY непосредственно при использовании типов ARRAY с PostgreSQL, поскольку он предоставляет дополнительные операторы, специфичные для этого бэкенда.

ARRAY является частью Core для поддержки различных стандартных функций SQL, таких как array_agg, которые явно включают массивы; однако, за исключением бэкенда PostgreSQL и, возможно, некоторых сторонних диалектов, ни один другой встроенный диалект SQLAlchemy не имеет поддержки этого типа.

Тип ARRAY строится с учетом «типа» элемента:

mytable = Table("mytable", metadata,
        Column("data", ARRAY(Integer))
    )

Приведенный выше тип представляет собой N-мерный массив, что означает, что поддерживающий бэкенд, такой как PostgreSQL, будет автоматически интерпретировать значения с любым количеством измерений. Для создания конструкции INSERT, передающей одномерный массив целых чисел:

connection.execute(
        mytable.insert(),
        {"data": [1,2,3]}
)

Тип ARRAY может быть построен при фиксированном количестве измерений:

mytable = Table("mytable", metadata,
        Column("data", ARRAY(Integer, dimensions=2))
    )

Передача числа размерности необязательна, но рекомендуется, если тип данных должен представлять массивы более чем одной размерности. Используется это число:

При передаче в базу данных самого объявления типа, например, INTEGER[][].
При переводе значений Python в значения базы данных и наоборот, например, ARRAY из объектов Unicode использует это число для эффективного доступа к строковым значениям внутри структур массивов, не прибегая к проверке типа каждой строки.
При использовании с аксессором Python getitem количество измерений служит для определения типа, который должен вернуть оператор [], например, для ARRAY of INTEGER с двумя измерениями:
```
>>> expr = table.c.column[5]  # returns ARRAY(Integer, dimensions=1)
>>> expr = expr[6]  # returns Integer
```

Для одномерных массивов экземпляр ARRAY без параметра размерности обычно предполагает одномерное поведение.

Выражения SQL типа ARRAY имеют поддержку поведения «индекса» и «среза». Оператор Python [] здесь работает нормально, учитывая целочисленные индексы или срезы. Массивы по умолчанию индексируются по 1. Оператор создает конструкции бинарных выражений, которые будут производить соответствующий SQL, как для операторов SELECT:

select(mytable.c.data[5], mytable.c.data[2:7])

а также операторы UPDATE при использовании метода Update.values():

mytable.update().values({
    mytable.c.data[5]: 7,
    mytable.c.data[2:7]: [1, 2, 3]
})

Тип ARRAY также предусматривает операторы Comparator.any() и Comparator.all(). Специфическая для PostgreSQL версия ARRAY также предоставляет дополнительные операторы.

Обнаружение изменений в столбцах ARRAY при использовании ORM.

Тип ARRAY при использовании с SQLAlchemy ORM не обнаруживает мутации массива на месте. Для их обнаружения необходимо использовать расширение sqlalchemy.ext.mutable, используя класс MutableList:

from sqlalchemy import ARRAY
from sqlalchemy.ext.mutable import MutableList

class SomeOrmClass(Base):
    # ...

    data = Column(MutableList.as_mutable(ARRAY(Integer)))

Это расширение позволит изменениям «на месте» в массиве, таким как .append(), создавать события, которые будут обнаружены блоком работы. Обратите внимание, что изменения элементов внутри массива, включая подмассивы, которые изменяются на месте, не обнаруживаются.

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

См.также

sqlalchemy.dialects.postgresql.ARRAY

Members

all(), any(), contains(), __init__(), comparator_factory, compare_values(), hashable, literal_processor(), python_type, zero_indexes

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

class sqlalchemy.types.ARRAY (sqlalchemy.sql.expression.SchemaEventTarget, sqlalchemy.types.Indexable, sqlalchemy.types.Concatenable, sqlalchemy.types.TypeEngine)

class Comparator¶

Определите операции сравнения для ARRAY.

Дополнительные операторы доступны в диалектной форме этого типа. См. Comparator.

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

класс sqlalchemy.types.ARRAY.Comparator (sqlalchemy.types.Comparator, sqlalchemy.types.Comparator)

method sqlalchemy.types.ARRAY.Comparator.all(other, operator=None)¶

Вернуть условие other operator ALL (array).

Примечание

Этот метод является специфической конструкцией ARRAY, которая теперь заменена функцией any_(), имеющей другой стиль вызова. Функция any_() также зеркально отражена на уровне метода через метод ColumnOperators.any_().

Использование специфических для массива Comparator.all() осуществляется следующим образом:

from sqlalchemy.sql import operators

conn.execute(
    select(table.c.data).where(
            table.c.data.all(7, operator=operators.lt)
        )
)

Параметры:

other – сравниваемое выражение
operator – объект оператора из пакета sqlalchemy.sql.operators, по умолчанию eq().

См.также

all_()

Comparator.any()

method sqlalchemy.types.ARRAY.Comparator.any(other, operator=None)¶

Вернуть условие other operator ANY (array).

Примечание

Использование специфических для массива Comparator.any() осуществляется следующим образом:

from sqlalchemy.sql import operators

conn.execute(
    select(table.c.data).where(
            table.c.data.any(7, operator=operators.lt)
        )
)

Параметры:

other – сравниваемое выражение
operator – объект оператора из пакета sqlalchemy.sql.operators, по умолчанию eq().

См.также

any_()

Comparator.all()

method sqlalchemy.types.ARRAY.Comparator.contains(*arg, **kw)¶

Реализуйте оператор „contains“.

Вырабатывает выражение LIKE, которое проверяет совпадение с серединой строкового значения:

column LIKE '%' || <other> || '%'

Например:

stmt = select(sometable).\
    where(sometable.c.column.contains("foobar"))

Поскольку оператор использует LIKE, символы подстановки "%" и "_", присутствующие внутри выражения <other>, также будут вести себя как символы подстановки. Для буквальных строковых значений флаг ColumnOperators.contains.autoescape может быть установлен в значение True, чтобы применить экранирование к вхождениям этих символов в строковое значение так, чтобы они совпадали сами по себе, а не как символы подстановки. В качестве альтернативы, параметр ColumnOperators.contains.escape устанавливает данный символ как символ экранирования, что может быть полезно, когда целевое выражение не является литеральной строкой.

Параметры:

other – выражение для сравнения. Обычно это обычное строковое значение, но может быть и произвольным выражением SQL. Символы подстановки LIKE % и _ по умолчанию не экранируются, если только флаг ColumnOperators.contains.autoescape не установлен в True.
autoescape – boolean; при значении True устанавливает символ экранирования в выражении LIKE, затем применяет его ко всем вхождениям "%", "_" и самого символа экранирования в значении сравнения, которое считается литеральной строкой, а не выражением SQL. Выражение типа:: somecolumn.contains(«foo%bar», autoescape=True) будет выглядеть так:: somecolumn LIKE „%“ || :param || „%“ ESCAPE „/“ Со значением :param как "foo/%bar".
escape – символ, который при передаче будет отображаться с ключевым словом ESCAPE, чтобы установить этот символ в качестве управляющего символа. Затем этот символ может быть помещен перед вхождениями % и _, чтобы позволить им действовать как самим себе, а не как символам подстановки. Выражение типа:: somecolumn.contains(«foo/%bar», escape=»^») будет выглядеть так:: somecolumn LIKE „%“ || :param || „%“ ESCAPE „^“ Параметр также может быть объединен с ColumnOperators.contains.autoescape:: somecolumn.contains(«foo%bar^bat», escape=»^», autoescape=True) Где выше, заданный литеральный параметр будет преобразован в "foo^%bar^^bat" перед передачей в базу данных.

См.также

ColumnOperators.startswith()

ColumnOperators.endswith()

ColumnOperators.like()

method sqlalchemy.types.ARRAY.__init__(item_type: _TypeEngineArgument[Any], as_tuple: bool = False, dimensions: Optional[int] = None, zero_indexes: bool = False)¶

Сконструируйте ARRAY.

Например:

Column('myarray', ARRAY(Integer))

Аргументы таковы:

Параметры:

item_type – Тип данных элементов этого массива. Обратите внимание, что размерность здесь не имеет значения, поэтому многомерные массивы, такие как INTEGER[][], строятся как ARRAY(Integer), а не как ARRAY(ARRAY(Integer)) или подобные.
as_tuple=False – Укажите, следует ли преобразовывать возвращаемые результаты в кортежи из списков. Этот параметр обычно не нужен, поскольку список в Python хорошо соответствует массиву SQL.
dimensions – если нет, то ARRAY будет иметь фиксированное число измерений. Это влияет на то, как массив объявляется в базе данных, как он интерпретирует значения Python и результаты, а также на поведение выражения в сочетании с оператором «getitem». Дополнительные подробности см. в описании по адресу ARRAY.
zero_indexes=False – когда True, значения индексов будут преобразованы между нулевыми индексами Python и единичными индексами SQL, например, значение единицы будет добавлено ко всем значениям индексов перед передачей в базу данных.

attribute sqlalchemy.types.ARRAY.comparator_factory¶: alias of Comparator

method sqlalchemy.types.ARRAY.compare_values(x, y)¶: Сравните два значения на равенство.

attribute sqlalchemy.types.ARRAY.hashable¶

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

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

method sqlalchemy.types.ARRAY.literal_processor(dialect)¶

Примечание

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

См.также

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

attribute sqlalchemy.types.ARRAY.python_type¶

attribute sqlalchemy.types.ARRAY.zero_indexes = False¶: Если True, нулевые индексы Python должны интерпретироваться как единичные на стороне SQL-выражения.

class sqlalchemy.types.BIGINT¶: Тип SQL BIGINT.

См.также

BigInteger - документация для базового типа.

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

класс sqlalchemy.types.BIGINT (sqlalchemy.types.BigInteger)

class sqlalchemy.types.BINARY¶: Тип SQL BINARY.

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

класс sqlalchemy.types.BINARY (sqlalchemy.types._Binary)

class sqlalchemy.types.BLOB¶

Тип SQL BLOB.

Members

__init__()

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

класс sqlalchemy.types.BLOB (sqlalchemy.types.LargeBinary)

method sqlalchemy.types.BLOB.__init__(length: Optional[int] = None)¶

наследуется от sqlalchemy.types.LargeBinary.__init__ метода LargeBinary

Создайте тип LargeBinary.

Параметры:: length – опционально, длина столбца для использования в DDL-запросах, для тех бинарных типов, которые принимают длину, например, тип MySQL BLOB.

class sqlalchemy.types.BOOLEAN¶

Тип SQL BOOLEAN.

Members

__init__()

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

класс sqlalchemy.types.BOOLEAN (sqlalchemy.types.Boolean)

method sqlalchemy.types.BOOLEAN.__init__(create_constraint: bool = False, name: Optional[str] = None, _create_events: bool = True, _adapted_from: Optional[SchemaType] = None)¶

наследуется от sqlalchemy.types.Boolean.__init__ метода Boolean

Сконструируйте булево значение.

Параметры:

create_constraint – по умолчанию имеет значение False. Если булево значение генерируется как int/smallint, также создайте ограничение CHECK на таблице, которое гарантирует 1 или 0 в качестве значения. … примечание:: настоятельно рекомендуется, чтобы ограничение CHECK имело явное имя для поддержки управления схемой. Это можно сделать либо путем установки параметра Boolean.name, либо путем создания соответствующего соглашения об именовании; см. справочную информацию в Настройка соглашений об именовании ограничений. … versionchanged:: 1.4 - этот флаг теперь имеет значение по умолчанию False, что означает, что для неродного перечислимого типа не генерируется ограничение CHECK.
name – если создается ограничение CHECK, укажите имя ограничения.

class sqlalchemy.types.CHAR¶

Тип SQL CHAR.

Members

__init__()

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

класс sqlalchemy.types.CHAR (sqlalchemy.types.String)

method sqlalchemy.types.CHAR.__init__(length: Optional[int] = None, collation: Optional[str] = None)¶

наследуется от sqlalchemy.types.String.__init__ метода String

Создайте тип, удерживающий строку.

Параметры:

length – необязательный, длина столбца для использования в выражениях DDL и CAST. Может быть опущена, если не будет выдаваться CREATE TABLE. Некоторые базы данных могут требовать length для использования в DDL, и будут выдавать исключение при выдаче CREATE TABLE DDL, если включена VARCHAR без длины. Интерпретируется ли значение как байты или как символы, зависит от конкретной базы данных.
collation – Необязательно, collation на уровне столбцов для использования в выражениях DDL и CAST. Используется ключевое слово COLLATE, поддерживаемое SQLite, MySQL и PostgreSQL. Например: … sourcecode:: pycon+sql >>> from sqlalchemy import cast, select, String >>> print(select(cast(„some string“, String(collation=“utf8“)))) {printsql}SELECT CAST(:param_1 AS VARCHAR COLLATE utf8) AS anon_1 … примечание:: В большинстве случаев для Unicode или UnicodeText следует использовать типы данных Column, которые предполагают хранение неасксичных данных. Эти типы данных гарантируют, что в базе данных используются правильные типы.

class sqlalchemy.types.CLOB¶

Тип CLOB.

Этот тип встречается в Oracle и Informix.

Members

__init__()

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

класс sqlalchemy.types.CLOB (sqlalchemy.types.Text)

method sqlalchemy.types.CLOB.__init__(length: Optional[int] = None, collation: Optional[str] = None)¶

наследуется от sqlalchemy.types.String.__init__ метода String

Создайте тип, удерживающий строку.

Параметры:

length – необязательный, длина столбца для использования в выражениях DDL и CAST. Может быть опущена, если не будет выдаваться CREATE TABLE. Некоторые базы данных могут требовать length для использования в DDL, и будут выдавать исключение при выдаче CREATE TABLE DDL, если включена VARCHAR без длины. Интерпретируется ли значение как байты или как символы, зависит от конкретной базы данных.
collation – Необязательно, collation на уровне столбцов для использования в выражениях DDL и CAST. Используется ключевое слово COLLATE, поддерживаемое SQLite, MySQL и PostgreSQL. Например: … sourcecode:: pycon+sql >>> from sqlalchemy import cast, select, String >>> print(select(cast(„some string“, String(collation=“utf8“)))) {printsql}SELECT CAST(:param_1 AS VARCHAR COLLATE utf8) AS anon_1 … примечание:: В большинстве случаев для Unicode или UnicodeText следует использовать типы данных Column, которые предполагают хранение неасксичных данных. Эти типы данных гарантируют, что в базе данных используются правильные типы.

class sqlalchemy.types.DATE¶: Тип SQL DATE.

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

класс sqlalchemy.types.DATE (sqlalchemy.types.Date)

class sqlalchemy.types.DATETIME¶

Тип SQL DATETIME.

Members

__init__()

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

класс sqlalchemy.types.DATETIME (sqlalchemy.types.DateTime)

method sqlalchemy.types.DATETIME.__init__(timezone: bool = False)¶

наследуется от sqlalchemy.types.DateTime.__init__ метода DateTime

Создайте новый DateTime.

Параметры:: timezone – булево. Указывает, что тип datetime должен включать поддержку временных зон, если она доступна только для базового типа удержания даты/времени. Рекомендуется использовать непосредственно тип данных TIMESTAMP при использовании этого флага, так как некоторые базы данных включают отдельные общие типы даты/времени, отличные от типа данных TIMESTAMP с поддержкой временных зон, например, Oracle.

class sqlalchemy.types.DECIMAL¶

Тип SQL DECIMAL.

См.также

Numeric - документация для базового типа.

Members

__init__()

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

класс sqlalchemy.types.DECIMAL (sqlalchemy.types.Numeric)

method sqlalchemy.types.DECIMAL.__init__(precision: Optional[int] = None, scale: Optional[int] = None, decimal_return_scale: Optional[int] = None, asdecimal: bool = True)¶

наследуется от sqlalchemy.types.Numeric.__init__ метода Numeric

Постройте числовое значение.

Параметры:

precision – числовая точность для использования в DDL CREATE TABLE.
scale – числовая шкала для использования в DDL CREATE TABLE.
asdecimal – по умолчанию True. Возвращает, следует ли отправлять значения в виде десятичных объектов Python или в виде плавающих чисел. Различные DBAPI отправляют одно или другое, основываясь на типах данных - тип Numeric обеспечит постоянство возвращаемых значений в DBAPI.
decimal_return_scale – Масштаб по умолчанию, используемый при преобразовании значений с плавающей точкой в десятичные числа Python. Значения с плавающей точкой обычно намного длиннее из-за неточности десятичных дробей, а большинство типов баз данных с плавающей точкой не имеют понятия «масштаб», поэтому по умолчанию тип float ищет первые десять десятичных знаков при преобразовании. Указание этого значения отменяет эту длину. Типы, которые включают явное значение «.scale», такие как база Numeric, а также типы MySQL float, будут использовать значение «.scale» по умолчанию для decimal_return_scale, если не указано иное.

class sqlalchemy.types.DOUBLE¶

Тип SQL DOUBLE.

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

См.также

Double - документация для базового типа.

Members

__init__()

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

класс sqlalchemy.types.DOUBLE (sqlalchemy.types.Double)

method sqlalchemy.types.DOUBLE.__init__(precision: Optional[int] = None, asdecimal: bool = False, decimal_return_scale: Optional[int] = None)¶

наследуется от sqlalchemy.types.Float.__init__ метода Float

Постройте поплавок.

Параметры:

precision – числовая точность для использования в DDL CREATE TABLE. Бэкенды должны пытаться обеспечить, чтобы эта точность указывала на число цифр для общего типа данных Float. … примечание:: Для бэкенда Oracle параметр Float.precision не принимается при рендеринге DDL, поскольку Oracle не поддерживает точность float, указанную как число десятичных знаков. Вместо этого используйте специфический для Oracle тип данных FLOAT и укажите параметр FLOAT.binary_precision. Это новое в версии 2.0 SQLAlchemy. Чтобы создать независимый от базы данных Float, отдельно указывающий двоичную точность для Oracle, используйте TypeEngine.with_variant() следующим образом: from sqlalchemy import Column from sqlalchemy import Float from sqlalchemy.dialects import oracle Column( «float_data», Float(5).with_variant(oracle.FLOAT(binary_precision=16), «oracle») )
asdecimal – тот же флаг, что и у Numeric, но по умолчанию имеет значение False. Обратите внимание, что установка этого флага в значение True приводит к преобразованию с плавающей точкой.
decimal_return_scale – Масштаб по умолчанию, используемый при преобразовании значений с плавающей точкой в десятичные числа Python. Значения с плавающей точкой обычно намного длиннее из-за неточности десятичных дробей, а большинство типов баз данных с плавающей точкой не имеют понятия «масштаб», поэтому по умолчанию тип float ищет первые десять десятичных знаков при преобразовании. Указание этого значения отменяет эту длину. Обратите внимание, что типы MySQL float, которые включают «масштаб», будут использовать «масштаб» по умолчанию для decimal_return_scale, если не указано иное.

class sqlalchemy.types.DOUBLE_PRECISION¶

Тип SQL DOUBLE PRECISION.

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

См.также

Double - документация для базового типа.

Members

__init__()

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

класс sqlalchemy.types.DOUBLE_PRECISION (sqlalchemy.types.Double)

method sqlalchemy.types.DOUBLE_PRECISION.__init__(precision: Optional[int] = None, asdecimal: bool = False, decimal_return_scale: Optional[int] = None)¶

наследуется от sqlalchemy.types.Float.__init__ метода Float

Постройте поплавок.

Параметры:

precision – числовая точность для использования в DDL CREATE TABLE. Бэкенды должны пытаться обеспечить, чтобы эта точность указывала на число цифр для общего типа данных Float. … примечание:: Для бэкенда Oracle параметр Float.precision не принимается при рендеринге DDL, поскольку Oracle не поддерживает точность float, указанную как число десятичных знаков. Вместо этого используйте специфический для Oracle тип данных FLOAT и укажите параметр FLOAT.binary_precision. Это новое в версии 2.0 SQLAlchemy. Чтобы создать независимый от базы данных Float, отдельно указывающий двоичную точность для Oracle, используйте TypeEngine.with_variant() следующим образом: from sqlalchemy import Column from sqlalchemy import Float from sqlalchemy.dialects import oracle Column( «float_data», Float(5).with_variant(oracle.FLOAT(binary_precision=16), «oracle») )
asdecimal – тот же флаг, что и у Numeric, но по умолчанию имеет значение False. Обратите внимание, что установка этого флага в значение True приводит к преобразованию с плавающей точкой.
decimal_return_scale – Масштаб по умолчанию, используемый при преобразовании значений с плавающей точкой в десятичные числа Python. Значения с плавающей точкой обычно намного длиннее из-за неточности десятичных дробей, а большинство типов баз данных с плавающей точкой не имеют понятия «масштаб», поэтому по умолчанию тип float ищет первые десять десятичных знаков при преобразовании. Указание этого значения отменяет эту длину. Обратите внимание, что типы MySQL float, которые включают «масштаб», будут использовать «масштаб» по умолчанию для decimal_return_scale, если не указано иное.

class sqlalchemy.types.FLOAT¶

Тип SQL FLOAT.

См.также

Float - документация для базового типа.

Members

__init__()

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

класс sqlalchemy.types.FLOAT (sqlalchemy.types.Float)

method sqlalchemy.types.FLOAT.__init__(precision: Optional[int] = None, asdecimal: bool = False, decimal_return_scale: Optional[int] = None)¶

наследуется от sqlalchemy.types.Float.__init__ метода Float

Постройте поплавок.

Параметры:

precision – числовая точность для использования в DDL CREATE TABLE. Бэкенды должны пытаться обеспечить, чтобы эта точность указывала на число цифр для общего типа данных Float. … примечание:: Для бэкенда Oracle параметр Float.precision не принимается при рендеринге DDL, поскольку Oracle не поддерживает точность float, указанную как число десятичных знаков. Вместо этого используйте специфический для Oracle тип данных FLOAT и укажите параметр FLOAT.binary_precision. Это новое в версии 2.0 SQLAlchemy. Чтобы создать независимый от базы данных Float, отдельно указывающий двоичную точность для Oracle, используйте TypeEngine.with_variant() следующим образом: from sqlalchemy import Column from sqlalchemy import Float from sqlalchemy.dialects import oracle Column( «float_data», Float(5).with_variant(oracle.FLOAT(binary_precision=16), «oracle») )
asdecimal – тот же флаг, что и у Numeric, но по умолчанию имеет значение False. Обратите внимание, что установка этого флага в значение True приводит к преобразованию с плавающей точкой.
decimal_return_scale – Масштаб по умолчанию, используемый при преобразовании значений с плавающей точкой в десятичные числа Python. Значения с плавающей точкой обычно намного длиннее из-за неточности десятичных дробей, а большинство типов баз данных с плавающей точкой не имеют понятия «масштаб», поэтому по умолчанию тип float ищет первые десять десятичных знаков при преобразовании. Указание этого значения отменяет эту длину. Обратите внимание, что типы MySQL float, которые включают «масштаб», будут использовать «масштаб» по умолчанию для decimal_return_scale, если не указано иное.

attribute sqlalchemy.types..sqlalchemy.types.INT¶: alias of INTEGER

class sqlalchemy.types.JSON¶

Представляет тип SQL JSON.

Примечание

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

PostgreSQL - см. sqlalchemy.dialects.postgresql.JSON и sqlalchemy.dialects.postgresql.JSONB для примечаний, специфичных для бэкенда
MySQL - см. sqlalchemy.dialects.mysql.JSON для примечаний, специфичных для бэкенда
SQLite начиная с версии 3.9 - см. sqlalchemy.dialects.sqlite.JSON для примечаний, специфичных для бэкенда
Microsoft SQL Server 2016 и более поздние версии - см. sqlalchemy.dialects.mssql.JSON для получения информации о специфических бэкендах

JSON является частью Core в поддержку растущей популярности собственных типов данных JSON.

Тип JSON хранит данные произвольного формата JSON, например:

data_table = Table('data_table', metadata,
    Column('id', Integer, primary_key=True),
    Column('data', JSON)
)

with engine.connect() as conn:
    conn.execute(
        data_table.insert(),
        {"data": {"key1": "value1", "key2": "value2"}}
    )

JSON-специфические операторы выражения.

Тип данных JSON предоставляет эти дополнительные операции SQL:

Операции с ключевыми индексами:
```
data_table.c.data['some key']
```
Операции с целочисленными индексами:
```
data_table.c.data[3]
```

Операции с индексом пути:

data_table.c.data[('key_1', 'key_2', 5, ..., 'key_n')]

Кастеры данных для определенных типов элементов JSON, после вызова операции индекса или пути:
```
data_table.c.data["some key"].as_integer()
```
Добавлено в версии 1.3.11.

Дополнительные операции могут быть доступны в диалектно-специфических версиях JSON, таких как sqlalchemy.dialects.postgresql.JSON и sqlalchemy.dialects.postgresql.JSONB, которые предлагают дополнительные операции, специфичные для PostgreSQL.

Приведение элементов JSON к другим типам.

Индексные операции, т.е. те, которые вызываются вызовом выражения с помощью оператора скобок Python, как в some_column['some key'], возвращают объект выражения, тип которого по умолчанию равен JSON, так что дальнейшие JSON-ориентированные инструкции могут быть вызваны по типу результата. Однако чаще всего ожидается, что индексная операция вернет определенный скалярный элемент, например, строку или целое число. Для того чтобы обеспечить доступ к этим элементам способом, не зависящим от бэкенда, предусмотрена серия роликов данных:

Comparator.as_string() - вернуть элемент в виде строки
Comparator.as_boolean() - вернуть элемент как булево значение
Comparator.as_float() - вернуть элемент в виде float
Comparator.as_integer() - вернуть элемент в виде целого числа

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

# integer comparison
data_table.c.data["some_integer_key"].as_integer() == 5

# boolean comparison
data_table.c.data["some_boolean"].as_boolean() == True

Добавлено в версии 1.3.11: Добавлены специфичные для типа ролики для основных типов элементов данных JSON.

Примечание

Функции кастера данных являются новыми в версии 1.3.11 и заменяют предыдущие документированные подходы к использованию CAST; для справки, это выглядело так:

from sqlalchemy import cast, type_coerce
from sqlalchemy import String, JSON
cast(
    data_table.c.data['some_key'], String
) == type_coerce(55, JSON)

Вышеописанный случай теперь работает напрямую как:

data_table.c.data['some_key'].as_integer() == 5

Подробнее о предыдущем подходе к сравнению в серии 1.3.x смотрите документацию к SQLAlchemy 1.2 или включенные HTML-файлы в каталоге doc/ дистрибутива этой версии.

Обнаружение изменений в колонках JSON при использовании ORM.

Тип JSON при использовании с SQLAlchemy ORM не обнаруживает мутации структуры на месте. Для того чтобы их обнаружить, необходимо использовать расширение sqlalchemy.ext.mutable, чаще всего с помощью класса MutableDict. Это расширение позволит изменениям структуры данных «на месте» создавать события, которые будут обнаружены блоком работы. Смотрите пример в HSTORE для простого примера со словарем.

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

Поддержка для JSON null против SQL NULL.

При работе со значениями NULL тип JSON рекомендует использовать две специальные константы, чтобы отличить столбец, который оценивается как SQL NULL, т.е. не имеет значения, от JSON-кодированной строки "null". Чтобы вставить или выбрать значение, которое является SQL NULL, используйте константу null(). Этот символ может быть передан в качестве значения параметра специально при использовании типа данных JSON, который содержит специальную логику, интерпретирующую этот символ как то, что значение столбца должно быть SQL NULL в отличие от JSON "null":

from sqlalchemy import null
conn.execute(table.insert(), {"json_value": null()})

Для вставки или выбора из значения, которое является JSON "null", используйте константу JSON.NULL:

conn.execute(table.insert(), {"json_value": JSON.NULL})

Тип JSON поддерживает флаг JSON.none_as_null, при установке которого в True константа Python None будет оцениваться в значение SQL NULL, а при установке в False константа Python None будет оцениваться в значение JSON "null". Значение Python None может использоваться в сочетании с JSON.NULL и null() для обозначения значений NULL, но в этих случаях необходимо соблюдать осторожность в отношении значения JSON.none_as_null.

Настройка сериализатора JSON.

Сериализатор и десериализатор JSON, используемые JSON, по умолчанию используют функции Python json.dumps и json.loads; в случае диалекта psycopg2, psycopg2 может использовать свою собственную функцию загрузчика.

Чтобы повлиять на сериализатор / десериализатор, в настоящее время они настраиваются на уровне create_engine() через параметры create_engine.json_serializer и create_engine.json_deserializer. Например, чтобы отключить ensure_ascii:

engine = create_engine(
    "sqlite://",
    json_serializer=lambda obj: json.dumps(obj, ensure_ascii=False))

Изменено в версии 1.3.7: Параметры диалекта SQLite json_serializer и json_deserializer переименованы из _json_serializer и _json_deserializer.

См.также

sqlalchemy.dialects.postgresql.JSON

sqlalchemy.dialects.postgresql.JSONB

sqlalchemy.dialects.mysql.JSON

sqlalchemy.dialects.sqlite.JSON

Members

as_boolean(), as_float(), as_integer(), as_json(), as_numeric(), as_string(), bind_processor(), literal_processor(), NULL, __init__(), bind_processor(), comparator_factory, hashable, python_type, result_processor(), should_evaluate_none

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

класс sqlalchemy.types.JSON (sqlalchemy.types.Indexable, sqlalchemy.types.TypeEngine)

class Comparator¶

Определите операции сравнения для JSON.

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

класс sqlalchemy.types.JSON.Comparator (sqlalchemy.types.Comparator, sqlalchemy.types.Comparator)

method sqlalchemy.types.JSON.Comparator.as_boolean()¶

Приведите индексированное значение к виду boolean.

например:

stmt = select(
    mytable.c.json_column['some_data'].as_boolean()
).where(
    mytable.c.json_column['some_data'].as_boolean() == True
)

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

method sqlalchemy.types.JSON.Comparator.as_float()¶

Приведите индексированное значение к виду float.

например:

stmt = select(
    mytable.c.json_column['some_data'].as_float()
).where(
    mytable.c.json_column['some_data'].as_float() == 29.75
)

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

method sqlalchemy.types.JSON.Comparator.as_integer()¶

Приведение индексированного значения к целочисленному виду.

например:

stmt = select(
    mytable.c.json_column['some_data'].as_integer()
).where(
    mytable.c.json_column['some_data'].as_integer() == 5
)

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

method sqlalchemy.types.JSON.Comparator.as_json()¶

Приведите индексированное значение к виду JSON.

например:

stmt = select(mytable.c.json_column['some_data'].as_json())

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

Обратите внимание, что сравнение полных структур JSON может поддерживаться не всеми бэкендами.

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

method sqlalchemy.types.JSON.Comparator.as_numeric(precision, scale, asdecimal=True)¶

Приведение индексированного значения к числовому/десятичному виду.

например:

stmt = select(
    mytable.c.json_column['some_data'].as_numeric(10, 6)
).where(
    mytable.c.
    json_column['some_data'].as_numeric(10, 6) == 29.75
)

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

method sqlalchemy.types.JSON.Comparator.as_string()¶

Приведение индексированного значения к строковому виду.

например:

stmt = select(
    mytable.c.json_column['some_data'].as_string()
).where(
    mytable.c.json_column['some_data'].as_string() ==
    'some string'
)

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

class JSONElementType¶

Общая функция для элементов индекса / пути в выражении JSON.

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

класс sqlalchemy.types.JSON.JSONElementType (sqlalchemy.types.TypeEngine)

method sqlalchemy.types.JSON.JSONElementType.bind_processor(dialect)¶

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

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

Примечание

См.также

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

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

method sqlalchemy.types.JSON.JSONElementType.literal_processor(dialect)¶

Примечание

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

См.также

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

class JSONIndexType¶

Место для обозначения типа данных значения индекса JSON.

Это позволяет во время выполнения обрабатывать значения индексов JSON для специальных синтаксисов.

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

класс sqlalchemy.types.JSON.JSONIndexType (sqlalchemy.types.JSONElementType)

class JSONIntIndexType¶

Место для обозначения типа данных значения индекса JSON.

Это позволяет во время выполнения обрабатывать значения индексов JSON для специальных синтаксисов.

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

класс sqlalchemy.types.JSON.JSONIntIndexType (sqlalchemy.types.JSONIndexType)

class JSONPathType¶

Тип заполнителя для операций с путями JSON.

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

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

класс sqlalchemy.types.JSON.JSONPathType (sqlalchemy.types.JSONElementType)

class JSONStrIndexType¶

Место для обозначения типа данных значения индекса JSON.

Это позволяет во время выполнения обрабатывать значения индексов JSON для специальных синтаксисов.

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

класс sqlalchemy.types.JSON.JSONStrIndexType (sqlalchemy.types.JSONIndexType)

attribute sqlalchemy.types.JSON.NULL = symbol('JSON_NULL')¶

Опишите json-значение NULL.

Это значение используется для того, чтобы заставить использовать в качестве значения JSON значение "null". Значение Python None будет распознано либо как SQL NULL, либо как JSON "null", в зависимости от установки флага JSON.none_as_null; константа JSON.NULL может быть использована для того, чтобы всегда разрешаться в JSON "null" независимо от этой установки. Это противоположно конструкции null(), которая всегда разрешается в SQL NULL. Например:

from sqlalchemy import null
from sqlalchemy.dialects.postgresql import JSON

# will *always* insert SQL NULL
obj1 = MyObject(json_value=null())

# will *always* insert JSON string "null"
obj2 = MyObject(json_value=JSON.NULL)

session.add_all([obj1, obj2])
session.commit()

Для того чтобы установить JSON NULL в качестве значения по умолчанию для столбца, наиболее прозрачным методом является использование text():

Table(
    'my_table', metadata,
    Column('json_data', JSON, default=text("'null'"))
)

Хотя в этом контексте можно использовать JSON.NULL, значение JSON.NULL будет возвращено как значение столбца, что в контексте ORM или другого повторного использования значения по умолчанию может быть нежелательным. Использование SQL-выражения означает, что значение будет повторно получено из базы данных в контексте извлечения сгенерированных значений по умолчанию.

method sqlalchemy.types.JSON.__init__(none_as_null: bool = False)¶

Сконструируйте тип JSON.

Параметры:: none_as_null=False – если True, сохранять значение None как значение SQL NULL, а не JSON-кодировку null. Обратите внимание, что когда этот флаг равен False, конструкция null() все еще может быть использована для сохранения значения NULL, которое может быть передано непосредственно как значение параметра, которое специально интерпретируется типом JSON как SQL NULL:: from sqlalchemy import null conn.execute(table.insert(), {«data»: null()}) … note:: JSON.none_as_null не применяется к значениям, переданным в Column.default и Column.server_default; значение None, переданное для этих параметров, означает «по умолчанию отсутствует». Кроме того, при использовании в выражениях сравнения SQL, значение Python None продолжает ссылаться на SQL null, а не на JSON NULL. Флаг JSON.none_as_null явно указывает на постоянство значения в операторе INSERT или UPDATE. Значение JSON.NULL следует использовать для SQL-выражений, которые хотят сравнить с JSON null. … см. также:: JSON.NULL

method sqlalchemy.types.JSON.bind_processor(dialect)¶

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

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

Примечание

См.также

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

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

attribute sqlalchemy.types.JSON.comparator_factory¶: alias of Comparator

attribute sqlalchemy.types.JSON.hashable = False¶

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

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

attribute sqlalchemy.types.JSON.python_type¶

method sqlalchemy.types.JSON.result_processor(dialect, coltype)¶

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

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

Примечание

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

См.также

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

Параметры:

dialect – Используемый диалектный экземпляр.
coltype – DBAPI coltype аргумент, полученный в cursor.description.

attribute sqlalchemy.types.JSON.should_evaluate_none: bool¶

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

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

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

См.также

TypeEngine.evaluates_none()

class sqlalchemy.types.INTEGER¶: Тип SQL INT или INTEGER.

См.также

Integer - документация для базового типа.

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

класс sqlalchemy.types.INTEGER (sqlalchemy.types.Integer)

class sqlalchemy.types.NCHAR¶

Тип SQL NCHAR.

Members

__init__()

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

класс sqlalchemy.types.NCHAR (sqlalchemy.types.Unicode)

method sqlalchemy.types.NCHAR.__init__(length=None, **kwargs)¶

наследуется от sqlalchemy.types.Unicode.__init__ метода Unicode

Создайте объект Unicode.

Параметры те же, что и у String.

class sqlalchemy.types.NVARCHAR¶

Тип SQL NVARCHAR.

Members

__init__()

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

класс sqlalchemy.types.NVARCHAR (sqlalchemy.types.Unicode)

method sqlalchemy.types.NVARCHAR.__init__(length=None, **kwargs)¶

наследуется от sqlalchemy.types.Unicode.__init__ метода Unicode

Создайте объект Unicode.

Параметры те же, что и у String.

class sqlalchemy.types.NUMERIC¶

Тип SQL NUMERIC.

См.также

Numeric - документация для базового типа.

Members

__init__()

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

класс sqlalchemy.types.NUMERIC (sqlalchemy.types.Numeric)

method sqlalchemy.types.NUMERIC.__init__(precision: Optional[int] = None, scale: Optional[int] = None, decimal_return_scale: Optional[int] = None, asdecimal: bool = True)¶

наследуется от sqlalchemy.types.Numeric.__init__ метода Numeric

Постройте числовое значение.

Параметры:

precision – числовая точность для использования в DDL CREATE TABLE.
scale – числовая шкала для использования в DDL CREATE TABLE.
asdecimal – по умолчанию True. Возвращает, следует ли отправлять значения в виде десятичных объектов Python или в виде плавающих чисел. Различные DBAPI отправляют одно или другое, основываясь на типах данных - тип Numeric обеспечит постоянство возвращаемых значений в DBAPI.
decimal_return_scale – Масштаб по умолчанию, используемый при преобразовании значений с плавающей точкой в десятичные числа Python. Значения с плавающей точкой обычно намного длиннее из-за неточности десятичных дробей, а большинство типов баз данных с плавающей точкой не имеют понятия «масштаб», поэтому по умолчанию тип float ищет первые десять десятичных знаков при преобразовании. Указание этого значения отменяет эту длину. Типы, которые включают явное значение «.scale», такие как база Numeric, а также типы MySQL float, будут использовать значение «.scale» по умолчанию для decimal_return_scale, если не указано иное.

class sqlalchemy.types.REAL¶

Тип SQL REAL.

См.также

Float - документация для базового типа.

Members

__init__()

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

класс sqlalchemy.types.REAL (sqlalchemy.types.Float)

method sqlalchemy.types.REAL.__init__(precision: Optional[int] = None, asdecimal: bool = False, decimal_return_scale: Optional[int] = None)¶

наследуется от sqlalchemy.types.Float.__init__ метода Float

Постройте поплавок.

Параметры:

precision – числовая точность для использования в DDL CREATE TABLE. Бэкенды должны пытаться обеспечить, чтобы эта точность указывала на число цифр для общего типа данных Float. … примечание:: Для бэкенда Oracle параметр Float.precision не принимается при рендеринге DDL, поскольку Oracle не поддерживает точность float, указанную как число десятичных знаков. Вместо этого используйте специфический для Oracle тип данных FLOAT и укажите параметр FLOAT.binary_precision. Это новое в версии 2.0 SQLAlchemy. Чтобы создать независимый от базы данных Float, отдельно указывающий двоичную точность для Oracle, используйте TypeEngine.with_variant() следующим образом: from sqlalchemy import Column from sqlalchemy import Float from sqlalchemy.dialects import oracle Column( «float_data», Float(5).with_variant(oracle.FLOAT(binary_precision=16), «oracle») )
asdecimal – тот же флаг, что и у Numeric, но по умолчанию имеет значение False. Обратите внимание, что установка этого флага в значение True приводит к преобразованию с плавающей точкой.
decimal_return_scale – Масштаб по умолчанию, используемый при преобразовании значений с плавающей точкой в десятичные числа Python. Значения с плавающей точкой обычно намного длиннее из-за неточности десятичных дробей, а большинство типов баз данных с плавающей точкой не имеют понятия «масштаб», поэтому по умолчанию тип float ищет первые десять десятичных знаков при преобразовании. Указание этого значения отменяет эту длину. Обратите внимание, что типы MySQL float, которые включают «масштаб», будут использовать «масштаб» по умолчанию для decimal_return_scale, если не указано иное.

class sqlalchemy.types.SMALLINT¶: Тип SQL SMALLINT.

См.также

SmallInteger - документация для базового типа.

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

класс sqlalchemy.types.SMALLINT (sqlalchemy.types.SmallInteger)

class sqlalchemy.types.TEXT¶

Тип SQL TEXT.

Members

__init__()

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

класс sqlalchemy.types.TEXT (sqlalchemy.types.Text)

method sqlalchemy.types.TEXT.__init__(length: Optional[int] = None, collation: Optional[str] = None)¶

наследуется от sqlalchemy.types.String.__init__ метода String

Создайте тип, удерживающий строку.

Параметры:

length – необязательный, длина столбца для использования в выражениях DDL и CAST. Может быть опущена, если не будет выдаваться CREATE TABLE. Некоторые базы данных могут требовать length для использования в DDL, и будут выдавать исключение при выдаче CREATE TABLE DDL, если включена VARCHAR без длины. Интерпретируется ли значение как байты или как символы, зависит от конкретной базы данных.
collation – Необязательно, collation на уровне столбцов для использования в выражениях DDL и CAST. Используется ключевое слово COLLATE, поддерживаемое SQLite, MySQL и PostgreSQL. Например: … sourcecode:: pycon+sql >>> from sqlalchemy import cast, select, String >>> print(select(cast(„some string“, String(collation=“utf8“)))) {printsql}SELECT CAST(:param_1 AS VARCHAR COLLATE utf8) AS anon_1 … примечание:: В большинстве случаев для Unicode или UnicodeText следует использовать типы данных Column, которые предполагают хранение неасксичных данных. Эти типы данных гарантируют, что в базе данных используются правильные типы.

class sqlalchemy.types.TIME¶: Тип SQL TIME.

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

класс sqlalchemy.types.TIME (sqlalchemy.types.Time)

class sqlalchemy.types.TIMESTAMP¶

Тип SQL TIMESTAMP.

Типы данных TIMESTAMP имеют поддержку хранения временных зон в некоторых бэкендах, таких как PostgreSQL и Oracle. Используйте аргумент TIMESTAMP.timezone для того, чтобы включить «TIMESTAMP WITH TIMEZONE» для этих бэкендов.

Members

__init__(), get_dbapi_type()

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

класс sqlalchemy.types.TIMESTAMP (sqlalchemy.types.DateTime)

method sqlalchemy.types.TIMESTAMP.__init__(timezone: bool = False)¶

Создайте новый TIMESTAMP.

Параметры:: timezone – булево. Указывает, что тип TIMESTAMP должен включать поддержку временных зон, если она доступна в целевой базе данных. На основе каждого диалекта аналогично «TIMESTAMP WITH TIMEZONE». Если целевая база данных не поддерживает временные зоны, этот флаг игнорируется.

method sqlalchemy.types.TIMESTAMP.get_dbapi_type(dbapi)¶

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

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

class sqlalchemy.types.UUID¶

Представляет тип SQL UUID.

Это SQL-нативная форма агностического типа данных базы данных Uuid и обратно совместима с предыдущей версией UUID, предназначенной только для PostgreSQL.

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

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

См.также

Uuid

Members

__init__()

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

класс sqlalchemy.types.UUID (sqlalchemy.types.Uuid, sqlalchemy.types.NativeForEmulated)

method sqlalchemy.types.UUID.__init__(as_uuid: bool = True)¶

Сконструируйте тип UUID.

Параметры:: as_uuid=True – если True, то значения будут интерпретироваться как объекты Python uuid, конвертируемые в/из строки через DBAPI. … versionchanged: 2.0 as_uuid теперь по умолчанию True.

class sqlalchemy.types.VARBINARY¶: Тип SQL VARBINARY.

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

класс sqlalchemy.types.VARBINARY (sqlalchemy.types._Binary)

class sqlalchemy.types.VARCHAR¶

Тип SQL VARCHAR.

Members

__init__()

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

класс sqlalchemy.types.VARCHAR (sqlalchemy.types.String)

method sqlalchemy.types.VARCHAR.__init__(length: Optional[int] = None, collation: Optional[str] = None)¶

наследуется от sqlalchemy.types.String.__init__ метода String

Создайте тип, удерживающий строку.

Параметры:

length – необязательный, длина столбца для использования в выражениях DDL и CAST. Может быть опущена, если не будет выдаваться CREATE TABLE. Некоторые базы данных могут требовать length для использования в DDL, и будут выдавать исключение при выдаче CREATE TABLE DDL, если включена VARCHAR без длины. Интерпретируется ли значение как байты или как символы, зависит от конкретной базы данных.
collation – Необязательно, collation на уровне столбцов для использования в выражениях DDL и CAST. Используется ключевое слово COLLATE, поддерживаемое SQLite, MySQL и PostgreSQL. Например: … sourcecode:: pycon+sql >>> from sqlalchemy import cast, select, String >>> print(select(cast(„some string“, String(collation=“utf8“)))) {printsql}SELECT CAST(:param_1 AS VARCHAR COLLATE utf8) AS anon_1 … примечание:: В большинстве случаев для Unicode или UnicodeText следует использовать типы данных Column, которые предполагают хранение неасксичных данных. Эти типы данных гарантируют, что в базе данных используются правильные типы.

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

Пользовательские типы

Вернуться на верх

Иерархия типов¶

Типы данных «CamelCase»¶

Типы данных «UPPERCASE»¶

Специфические для бэкенда типы данных «UPPERCASE»¶

Использование «UPPERCASE» и типов, специфичных для бэкенда, для нескольких бэкендов¶

Общие типы «CamelCase»¶

Стандартный SQL и типы «UPPERCASE» нескольких поставщиков¶

SQLAlchemy 2.0

Содержание

Дополнительно

Вы здесь: