PostgreSQL¶

Support for the PostgreSQL database.

The following table summarizes current support levels for database release versions.

DBAPI Support¶

The following dialect/DBAPI options are available. Please refer to individual DBAPI sections for connect information.

• psycopg2

• psycopg (a.k.a. psycopg 3)

• pg8000

• asyncpg

• psycopg2cffi

Последовательности/СЕРИАЛ/ИДЕНТИЧНОСТЬ¶

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

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

Table(
    "sometable",
    metadata,
    Column(
        "id", Integer, Sequence("some_id_seq", start=1), primary_key=True
    )
)

Когда SQLAlchemy выпускает один оператор INSERT, чтобы выполнить контракт о наличии «идентификатора последней вставки», в оператор INSERT добавляется предложение RETURNING, которое определяет столбцы первичного ключа, которые должны быть возвращены после завершения оператора. Функция RETURNING работает только при использовании PostgreSQL 8.2 или более поздней версии. В качестве запасного варианта последовательность, заданная явно или неявно через SERIAL, предварительно выполняется независимо, а возвращаемое значение используется в последующей вставке. Обратите внимание, что когда конструкция insert() выполняется с использованием семантики «executemany», функциональность «последний вставленный идентификатор» не применяется; ни предложение RETURNING не выдается, ни последовательность предварительно не выполняется в этом случае.

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

metadata = MetaData()

data = Table(
    "data",
    metadata,
    Column(
        'id', Integer, Identity(start=42, cycle=True), primary_key=True
    ),
    Column('data', String)
)

CREATE TABLE data (
    id INTEGER GENERATED BY DEFAULT AS IDENTITY (START WITH 42 CYCLE),
    data VARCHAR,
    PRIMARY KEY (id)
)

from sqlalchemy.schema import CreateColumn
from sqlalchemy.ext.compiler import compiles


@compiles(CreateColumn, 'postgresql')
def use_identity(element, compiler, **kw):
    text = compiler.visit_create_column(element, **kw)
    text = text.replace(
        "SERIAL", "INT GENERATED BY DEFAULT AS IDENTITY"
     )
    return text

t = Table(
    't', m,
    Column('id', Integer, primary_key=True),
    Column('data', String)
)

CREATE TABLE t (
    id INT GENERATED BY DEFAULT AS IDENTITY,
    data VARCHAR,
    PRIMARY KEY (id)
)

Курсоры на стороне сервера¶

Поддержка курсора на стороне сервера доступна для диалектов psycopg2, asyncpg и может быть доступна в других диалектах.

Курсоры на стороне сервера включаются на основе каждого запроса с помощью опции выполнения соединения Connection.execution_options.stream_results:

with engine.connect() as conn:
    result = conn.execution_options(stream_results=True).execute(text("select * from table"))

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

Уровень изоляции транзакций¶

Большинство диалектов SQLAlchemy поддерживают установку уровня изоляции транзакций с помощью параметра create_engine.isolation_level на уровне create_engine(), а на уровне Connection с помощью параметра Connection.execution_options.isolation_level.

Для диалектов PostgreSQL эта возможность работает либо с использованием специфичных для DBAPI функций, таких как флаги уровня изоляции psycopg2, которые встраивают установку уровня изоляции в строку с оператором "BEGIN", либо для DBAPI без прямой поддержки путем выдачи SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL <level> перед оператором "BEGIN", выдаваемым DBAPI. Для специального уровня изоляции AUTOCOMMIT используются специфические для DBAPI методы, которые обычно представляют собой флаг .autocommit на объекте соединения DBAPI.

Чтобы установить уровень изоляции с помощью create_engine():

engine = create_engine(
    "postgresql+pg8000://scott:tiger@localhost/test",
    isolation_level = "REPEATABLE READ"
)

Чтобы задать параметры выполнения по каждому соединению, выполните следующие действия:

with engine.connect() as conn:
    conn = conn.execution_options(
        isolation_level="REPEATABLE READ"
    )
    with conn.begin():
        # ... work with transaction

Существует также больше вариантов конфигураций уровня изоляции, например, объекты «sub-engine», связанные с основным Engine, в каждом из которых применяются различные настройки уровня изоляции. См. обсуждение в Установка уровней изоляции транзакций, включая DBAPI Autocommit для справки.

Допустимые значения для isolation_level в большинстве диалектов PostgreSQL включают:

• READ COMMITTED

• READ UNCOMMITTED

• REPEATABLE READ

• SERIALIZABLE

• AUTOCOMMIT

Настройка ТОЛЬКО ДЛЯ ЧТЕНИЯ / ОТМЕНА¶

Большинство диалектов PostgreSQL поддерживают установку характеристик транзакции «READ ONLY» и «DEFERRABLE», что является дополнением к установке уровня изоляции. Эти два атрибута могут быть установлены как вместе с уровнем изоляции, так и независимо от него путем передачи флагов postgresql_readonly и postgresql_deferrable с помощью Connection.execution_options(). Приведенный ниже пример иллюстрирует передачу уровня изоляции "SERIALIZABLE" одновременно с установкой «ТОЛЬКО ЧТЕНИЕ» и «РАЗРЕШЕНО»:

with engine.connect() as conn:
    conn = conn.execution_options(
        isolation_level="SERIALIZABLE",
        postgresql_readonly=True,
        postgresql_deferrable=True
    )
    with conn.begin():
        #  ... work with transaction

Обратите внимание, что некоторые DBAPI, такие как asyncpg, поддерживают только «readonly» с изоляцией SERIALIZABLE.

Временная таблица / сброс ресурсов для пула соединений¶

Реализация пула соединений QueuePool, используемая объектом SQLAlchemy Engine, включает поведение reset on return, которое будет вызывать метод DBAPI .rollback(), когда соединения возвращаются в пул. Хотя этот откат очищает непосредственное состояние, использованное предыдущей транзакцией, он не охватывает более широкий диапазон состояния на уровне сессии, включая временные таблицы, а также другие состояния сервера, такие как обработчики подготовленных операторов и кэши операторов. База данных PostgreSQL содержит множество команд, которые могут быть использованы для сброса этого состояния, включая DISCARD, RESET, DEALLOCATE и UNLISTEN.

Чтобы установить одну или несколько этих команд в качестве средства выполнения сброса при возврате, можно использовать крючок события PoolEvents.reset(), как показано в примере ниже. Реализация завершает выполняющиеся транзакции, а также удаляет временные таблицы с помощью команд CLOSE, RESET и DISCARD; см. документацию PostgreSQL для получения информации о том, что делает каждая из этих команд.

Параметр create_engine.pool_reset_on_return устанавливается в None, чтобы пользовательская схема могла полностью заменить поведение по умолчанию. Реализация пользовательского хука в любом случае вызывает .rollback(), поскольку обычно важно, чтобы собственное отслеживание DBAPI фиксации/отката оставалось согласованным с состоянием транзакции:

from sqlalchemy import create_engine
from sqlalchemy import event

postgresql_engine = create_engine(
    "postgresql+pyscopg2://scott:tiger@hostname/dbname",

    # disable default reset-on-return scheme
    pool_reset_on_return=None,
)


@event.listens_for(postgresql_engine, "reset")
def _reset_postgresql(dbapi_connection, connection_record, reset_state):
    if not reset_state.terminate_only:
        dbapi_connection.execute("CLOSE ALL")
        dbapi_connection.execute("RESET ALL")
        dbapi_connection.execute("DISCARD TEMP")

    # so that the DBAPI itself knows that the connection has been
    # reset
    dbapi_connection.rollback()

Настройка альтернативных путей поиска в Connect¶

Переменная PostgreSQL search_path относится к списку имен схем, на которые будут неявно ссылаться при ссылке на определенную таблицу или другой объект в операторе SQL. Как подробно описано в следующем разделе Интроспекция таблиц удаленных схем и поиск_пути в PostgreSQL, SQLAlchemy в целом организована вокруг концепции сохранения значения этой переменной по умолчанию public, однако для того, чтобы она была установлена на любое произвольное имя или имена при автоматическом использовании соединений, команда «SET SESSION search_path» может быть вызвана для всех соединений в пуле с помощью следующего обработчика событий, как обсуждалось в Установка схемы по умолчанию для новых подключений:

from sqlalchemy import event
from sqlalchemy import create_engine

engine = create_engine("postgresql+psycopg2://scott:tiger@host/dbname")

@event.listens_for(engine, "connect", insert=True)
def set_search_path(dbapi_connection, connection_record):
    existing_autocommit = dbapi_connection.autocommit
    dbapi_connection.autocommit = True
    cursor = dbapi_connection.cursor()
    cursor.execute("SET SESSION search_path='%s'" % schema_name)
    cursor.close()
    dbapi_connection.autocommit = existing_autocommit

Причина, по которой рецепт усложнен использованием атрибута DBAPI .autocommit, заключается в том, что когда вызывается директива SET SESSION search_path, она вызывается вне рамок любой транзакции и поэтому не будет возвращена при откате соединения DBAPI.

Интроспекция таблиц удаленных схем и поиск_пути в PostgreSQL¶

Диалект PostgreSQL может отражать таблицы из любой схемы, как описано в Отражение таблиц из других схем.

Что касается таблиц, на которые эти Table объекты ссылаются через иностранный язык

По умолчанию диалект PostgreSQL имитирует поведение, поощряемое собственной встроенной процедурой PostgreSQL pg_get_constraintdef(). Эта функция возвращает образец определения для конкретного языка

test=> CREATE TABLE test_schema.referred(id INTEGER PRIMARY KEY);
CREATE TABLE
test=> CREATE TABLE referring(
test(>         id INTEGER PRIMARY KEY,
test(>         referred_id INTEGER REFERENCES test_schema.referred(id));
CREATE TABLE
test=> SET search_path TO public, test_schema;
test=> SELECT pg_catalog.pg_get_constraintdef(r.oid, true) FROM
test-> pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n
test-> ON n.oid = c.relnamespace
test-> JOIN pg_catalog.pg_constraint r  ON c.oid = r.conrelid
test-> WHERE c.relname='referring' AND r.contype = 'f'
test-> ;
               pg_get_constraintdef
---------------------------------------------------
 FOREIGN KEY (referred_id) REFERENCES referred(id)
(1 row)

Выше мы создали таблицу referred как член удаленной схемы test_schema, однако когда мы добавили test_schema к PG search_path и затем запросили pg_get_constraintdef() синтаксис FOREIGN KEY, test_schema не был включен в вывод функции.

С другой стороны, если мы вернем путь поиска к типичному значению по умолчанию public:

test=> SET search_path TO public;
SET

Тот же запрос к pg_get_constraintdef() теперь возвращает для нас полностью вычисленное по схеме имя:

test=> SELECT pg_catalog.pg_get_constraintdef(r.oid, true) FROM
test-> pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n
test-> ON n.oid = c.relnamespace
test-> JOIN pg_catalog.pg_constraint r  ON c.oid = r.conrelid
test-> WHERE c.relname='referring' AND r.contype = 'f';
                     pg_get_constraintdef
---------------------------------------------------------------
 FOREIGN KEY (referred_id) REFERENCES test_schema.referred(id)
(1 row)

SQLAlchemy по умолчанию будет использовать возвращаемое значение pg_get_constraintdef() для определения имени удаленной схемы. То есть, если наш search_path был установлен на включение test_schema, и мы вызвали процесс отражения таблицы следующим образом:

>>> from sqlalchemy import Table, MetaData, create_engine, text
>>> engine = create_engine("postgresql+psycopg2://scott:tiger@localhost/test")
>>> with engine.connect() as conn:
...     conn.execute(text("SET search_path TO test_schema, public"))
...     metadata_obj = MetaData()
...     referring = Table('referring', metadata_obj,
...                       autoload_with=conn)
...
<sqlalchemy.engine.result.CursorResult object at 0x101612ed0>

Вышеописанный процесс доставит в коллекцию MetaData.tables referred таблицу с именем без схемы:

>>> metadata_obj.tables['referred'].schema is None
True

Чтобы изменить поведение отражения таким образом, чтобы указанная схема сохранялась независимо от установки search_path, используйте опцию postgresql_ignore_search_path, которая может быть указана в качестве диалектного аргумента как для Table, так и для MetaData.reflect():

>>> with engine.connect() as conn:
...     conn.execute(text("SET search_path TO test_schema, public"))
...     metadata_obj = MetaData()
...     referring = Table('referring', metadata_obj,
...                       autoload_with=conn,
...                       postgresql_ignore_search_path=True)
...
<sqlalchemy.engine.result.CursorResult object at 0x1016126d0>

Теперь у нас будет test_schema.referred храниться как schema-qualified:

>>> metadata_obj.tables['test_schema.referred'].schema
'test_schema'

Обратите внимание, что ** во всех случаях** схема «по умолчанию» всегда отражается как None. Схема «по умолчанию» в PostgreSQL - это схема, возвращаемая функцией PostgreSQL current_schema(). В типичной установке PostgreSQL это имя public. Поэтому таблица, которая ссылается на другую, находящуюся в схеме public (т.е. по умолчанию), всегда будет иметь атрибут .schema, установленный в None.

ВСТАВКА/ОБНОВЛЕНИЕ… ВОЗВРАЩЕНИЕ¶

Диалект поддерживает синтаксисы PG 8.2 INSERT..RETURNING, UPDATE..RETURNING и DELETE..RETURNING. INSERT..RETURNING используется по умолчанию для однострочных операторов INSERT для получения вновь созданных идентификаторов первичного ключа. Чтобы указать явное предложение RETURNING, используйте метод _UpdateBase.returning() на основе каждого оператора:

# INSERT..RETURNING
result = table.insert().returning(table.c.col1, table.c.col2).\
    values(name='foo')
print(result.fetchall())

# UPDATE..RETURNING
result = table.update().returning(table.c.col1, table.c.col2).\
    where(table.c.name=='foo').values(name='bar')
print(result.fetchall())

# DELETE..RETURNING
result = table.delete().returning(table.c.col1, table.c.col2).\
    where(table.c.name=='foo')
print(result.fetchall())

INSERT…ON CONFLICT (Upsert)¶

Начиная с версии 9.5, PostgreSQL разрешает «апсерт» (обновление или вставку) строк в таблицу с помощью пункта ON CONFLICT оператора INSERT. Строка-кандидат будет вставлена только в том случае, если она не нарушает никаких уникальных ограничений. В случае нарушения уникальных ограничений может произойти вторичное действие, которое может быть либо «DO UPDATE», что указывает на то, что данные в целевой строке должны быть обновлены, либо «DO NOTHING», что означает молчаливый пропуск этой строки.

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

SQLAlchemy обеспечивает поддержку ON CONFLICT через специфическую для PostgreSQL функцию insert(), которая предоставляет генеративные методы Insert.on_conflict_do_update() и Insert.on_conflict_do_nothing():

>>> from sqlalchemy.dialects.postgresql import insert
>>> insert_stmt = insert(my_table).values(
...     id='some_existing_id',
...     data='inserted value')
>>> do_nothing_stmt = insert_stmt.on_conflict_do_nothing(
...     index_elements=['id']
... )
>>> print(do_nothing_stmt)
{printsql}INSERT INTO my_table (id, data) VALUES (%(id)s, %(data)s)
ON CONFLICT (id) DO NOTHING
{stop}

>>> do_update_stmt = insert_stmt.on_conflict_do_update(
...     constraint='pk_my_table',
...     set_=dict(data='updated value')
... )
>>> print(do_update_stmt)
{printsql}INSERT INTO my_table (id, data) VALUES (%(id)s, %(data)s)
ON CONFLICT ON CONSTRAINT pk_my_table DO UPDATE SET data = %(param_1)s

>>> stmt = insert(my_table).values(id='some_id', data='inserted value')
>>> do_update_stmt = stmt.on_conflict_do_update(
...     index_elements=['id'],
...     set_=dict(data='updated value')
... )
>>> print(do_update_stmt)
{printsql}INSERT INTO my_table (id, data) VALUES (%(id)s, %(data)s)
ON CONFLICT (id) DO UPDATE SET data = %(param_1)s

>>> stmt = insert(my_table).values(
...     id='some_id',
...     data='inserted value',
...     author='jlh'
... )
>>> do_update_stmt = stmt.on_conflict_do_update(
...     index_elements=['id'],
...     set_=dict(data='updated value', author=stmt.excluded.author)
... )
>>> print(do_update_stmt)
{printsql}INSERT INTO my_table (id, data, author)
VALUES (%(id)s, %(data)s, %(author)s)
ON CONFLICT (id) DO UPDATE SET data = %(param_1)s, author = excluded.author

>>> stmt = insert(my_table).values(
...     id='some_id',
...     data='inserted value',
...     author='jlh'
... )
>>> on_update_stmt = stmt.on_conflict_do_update(
...     index_elements=['id'],
...     set_=dict(data='updated value', author=stmt.excluded.author),
...     where=(my_table.c.status == 2)
... )
>>> print(on_update_stmt)
{printsql}INSERT INTO my_table (id, data, author)
VALUES (%(id)s, %(data)s, %(author)s)
ON CONFLICT (id) DO UPDATE SET data = %(param_1)s, author = excluded.author
WHERE my_table.status = %(status_1)s

>>> stmt = insert(my_table).values(id='some_id', data='inserted value')
>>> stmt = stmt.on_conflict_do_nothing(index_elements=['id'])
>>> print(stmt)
{printsql}INSERT INTO my_table (id, data) VALUES (%(id)s, %(data)s)
ON CONFLICT (id) DO NOTHING

>>> stmt = insert(my_table).values(id='some_id', data='inserted value')
>>> stmt = stmt.on_conflict_do_nothing()
>>> print(stmt)
{printsql}INSERT INTO my_table (id, data) VALUES (%(id)s, %(data)s)
ON CONFLICT DO NOTHING

Полнотекстовый поиск¶

Система полнотекстового поиска PostgreSQL доступна благодаря использованию пространства имен func в сочетании с использованием пользовательских операторов с помощью метода Operators.bool_op(). Для простых случаев с некоторой степенью кросс-бэкенд совместимости можно также использовать оператор Operators.match().

select(sometable.c.text.match("search string"))

SELECT text @@ plainto_tsquery('search string') FROM table

from sqlalchemy import func

select(
    sometable.c.text.bool_op("@@")(func.to_tsquery("search string"))
)

SELECT text @@ to_tsquery('search string') FROM table

select(
    func.to_tsquery('cat').bool_op("@>")(func.to_tsquery('cat & rat'))
)

SELECT to_tsquery('cat') @> to_tsquery('cat & rat')

from sqlalchemy.dialects.postgresql import TSVECTOR
from sqlalchemy import select, cast
select(cast("some text", TSVECTOR))

SELECT CAST('some text' AS TSVECTOR) AS anon_1

select(mytable.c.id).where(
    mytable.c.title.match('somestring', postgresql_regconfig='english')
)

SELECT mytable.id FROM mytable
WHERE mytable.title @@ plainto_tsquery('english', 'somestring')

select(mytable.c.id).where(
    func.to_tsvector("english", mytable.c.title).bool_op("@@")(
        func.to_tsquery("english", "somestring")
    )
)

SELECT mytable.id FROM mytable
WHERE to_tsvector('english', mytable.title) @@
    to_tsquery('english', 'somestring')

ТОЛЬКО …¶

Диалект поддерживает ключевое слово ONLY в PostgreSQL для указания только определенной таблицы в иерархии наследования. Это может использоваться для создания синтаксисов SELECT ... FROM ONLY, UPDATE ONLY ... и DELETE FROM ONLY .... Он использует механизм подсказок SQLAlchemy:

# SELECT ... FROM ONLY ...
result = table.select().with_hint(table, 'ONLY', 'postgresql')
print(result.fetchall())

# UPDATE ONLY ...
table.update(values=dict(foo='bar')).with_hint('ONLY',
                                               dialect_name='postgresql')

# DELETE FROM ONLY ...
table.delete().with_hint('ONLY', dialect_name='postgresql')

Параметры индекса, специфичные для PostgreSQL¶

Существует несколько расширений конструкции Index, специфичных для диалекта PostgreSQL.

Index("my_index", table.c.x, postgresql_include=['y'])

Index('my_index', my_table.c.id, postgresql_where=my_table.c.value > 10)

Index(
    'my_index', my_table.c.id, my_table.c.data,
    postgresql_ops={
        'data': 'text_pattern_ops',
        'id': 'int4_ops'
    })

Index(
    'my_index', my_table.c.id,
    func.lower(my_table.c.data).label('data_lower'),
    postgresql_ops={
        'data_lower': 'text_pattern_ops',
        'id': 'int4_ops'
    })

Index('my_index', my_table.c.data, postgresql_using='gin')

Index('my_index', my_table.c.data, postgresql_with={"fillfactor": 50})

Index('my_index', my_table.c.data, postgresql_tablespace='my_tablespace')

tbl = Table('testtbl', m, Column('data', Integer))

idx1 = Index('test_idx1', tbl.c.data, postgresql_concurrently=True)

CREATE INDEX CONCURRENTLY test_idx1 ON testtbl (data)

DROP INDEX CONCURRENTLY test_idx1

metadata = MetaData()
table = Table(
    "foo", metadata,
    Column("id", String))
index = Index(
    "foo_idx", table.c.id, postgresql_concurrently=True)

with engine.connect() as conn:
    with conn.execution_options(isolation_level='AUTOCOMMIT'):
        table.create(conn)

Отражение индекса PostgreSQL¶

База данных PostgreSQL неявно создает UNIQUE INDEX при использовании конструкции UNIQUE CONSTRAINT. При проверке таблицы с помощью Inspector, Inspector.get_indexes() и Inspector.get_unique_constraints() будут сообщать об этих двух конструкциях отдельно; в случае индекса ключ duplicates_constraint будет присутствовать в записи индекса, если будет обнаружено, что он зеркально отражает ограничение. При выполнении отражения с помощью Table(..., autoload_with=engine), UNIQUE INDEX не возвращается в Table.indexes, если обнаруживается, что он зеркально отражает UniqueConstraint в коллекции Table.constraints.

Специальные опции отражения¶

Inspector, используемый для бэкенда PostgreSQL, является экземпляром PGInspector, который предлагает дополнительные методы:

from sqlalchemy import create_engine, inspect

engine = create_engine("postgresql+psycopg2://localhost/test")
insp = inspect(engine)  # will be a PGInspector

print(insp.get_enums())

class sqlalchemy.dialects.postgresql.base.PGInspector¶

Members

get_domains(), get_enums(), get_foreign_table_names(), get_table_oid(), has_type()

**Классный сиг

класс sqlalchemy.dialects.postgresql.base.PGInspector (sqlalchemy.engine.reflection.Inspector)

method sqlalchemy.dialects.postgresql.base.PGInspector.get_domains(schema: Optional[str] = None) → List[ReflectedDomain]¶

Возвращает список объектов DOMAIN.

Каждый член представляет собой словарь, содержащий эти поля:

• имя - имя домена

• schema - имя схемы для домена.

• visible - булево значение, является ли данный домен видимым в пути поиска по умолчанию.

• type - тип, определенный данным доменом.

• nullable - Указывает, может ли этот домен быть NULL.

• default - Значение по умолчанию для домена или None, если домен не имеет значения по умолчанию.

• constraints - Список dict, содержащий ограничения, определенные данным доменом. Каждый элемент содержит два ключа: name из ограничения и check с текстом ограничения.

Параметры:

schema – имя схемы. Если None, используется схема по умолчанию (обычно „public“). Может также иметь значение '*' для указания доменов нагрузки для всех схем.

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

method sqlalchemy.dialects.postgresql.base.PGInspector.get_enums(schema: Optional[str] = None) → List[ReflectedEnum]¶

Возвращает список объектов ENUM.

Каждый член представляет собой словарь, содержащий эти поля:

• имя - имя перечисления

• schema - имя схемы для перечисления.

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

• labels - список строковых меток, которые применяются к перечислению.

Параметры:

schema – имя схемы. Если None, используется схема по умолчанию (обычно „public“). Может также иметь значение '*' для указания загрузки перечислений для всех схем.

method sqlalchemy.dialects.postgresql.base.PGInspector.get_foreign_table_names(schema: Optional[str] = None) → List[str]¶

Возвращает список FOREIG

Поведение аналогично поведению Inspector.get_table_names(), за исключением того, что список ограничен теми таблицами, которые сообщают relkind значение f.

method sqlalchemy.dialects.postgresql.base.PGInspector.get_table_oid(table_name: str, schema: Optional[str] = None) → int¶

Возвращает OID для заданного имени таблицы.

Параметры:

• table_name – строковое имя таблицы. Для специального цитирования используйте quoted_name.

• schema – string имя схемы; если опущено, используется схема по умолчанию соединения с базой данных. Для специального цитирования используйте quoted_name.

method sqlalchemy.dialects.postgresql.base.PGInspector.has_type(type_name: str, schema: Optional[str] = None, **kw: Any) → bool¶

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

Параметры:

• type_name – тип для проверки.

• schema – имя схемы. Если None, используется схема по умолчанию (обычно „public“). Может также иметь значение '*' для проверки всех схем.

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

Параметры таблиц PostgreSQL¶

Несколько опций для CREATE TABLE поддерживаются непосредственно диалектом PostgreSQL в сочетании с конструкцией Table:

• TABLESPACE:

  Table("some_table", metadata, ..., postgresql_tablespace='some_tablespace')

  Приведенная выше опция также доступна для конструкции Index.

• ON COMMIT:

  Table("some_table", metadata, ..., postgresql_on_commit='PRESERVE ROWS')

• WITH OIDS:

  Table("some_table", metadata, ..., postgresql_with_oids=True)

• WITHOUT OIDS:

  Table("some_table", metadata, ..., postgresql_with_oids=False)

• INHERITS:

  Table("some_table", metadata, ..., postgresql_inherits="some_supertable")
  
  Table("some_table", metadata, ..., postgresql_inherits=("t1", "t2", ...))

• PARTITION BY:

  Table("some_table", metadata, ...,
        postgresql_partition_by='LIST (part_column)')
  
  .. versionadded:: 1.2.6

Параметры ограничений PostgreSQL¶

Следующие опции поддерживаются диалектом PostgreSQL в сочетании с выбранными конструкциями ограничений:

• NOT VALID: Эта опция применяется к CHECK и FOREIG

  При использовании инструмента миграции SQL, такого как Alembic, который отображает конструкции ALTER TABLE, аргумент postgresql_not_valid может быть указан как дополнительный аргумент ключевого слова в операции, которая создает ограничение, как в следующем примере Alembic:

  def update():
      op.create_foreign_key(
          "fk_user_address",
          "address",
          "user",
          ["user_id"],
          ["id"],
          postgresql_not_valid=True
      )

  В конечном итоге ключевое слово принимается непосредственно конструкциями CheckConstraint, ForeignKeyConstraint и ForeignKey; при использовании такого инструмента, как Alembic, специфические для диалекта аргументы ключевого слова передаются этим конструкциям из директив операций миграции:

  CheckConstraint("some_field IS NOT NULL", postgresql_not_valid=True)
  
  ForeignKeyConstraint(["some_id"], ["some_table.some_id"], postgresql_not_valid=True)

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

  См.также

  PostgreSQL ALTER TABLE options - в документации по PostgreSQL.

Табличные значения, функции, оценивающие таблицы и столбцы, объекты Row и Tuple¶

В PostgreSQL широко используются современные формы SQL, такие как функции с табличным значением, таблицы и строки как значения. Эти конструкции широко используются как часть поддержки PostgreSQL сложных типов данных, таких как JSON, ARRAY и другие типы данных. Язык SQL-выражений SQLAlchemy имеет встроенную поддержку большинства таблично-значимых и строчно-значимых форм.

>>> from sqlalchemy import table, column, func, tuple_
>>> t = table("t", column("id"), column("fk"))
>>> stmt = t.select().where(
...     tuple_(t.c.id, t.c.fk) > (1,2)
... ).where(
...     func.ROW(t.c.id, t.c.fk) < func.ROW(3, 7)
... )
>>> print(stmt)
{printsql}SELECT t.id, t.fk
FROM t
WHERE (t.id, t.fk) > (:param_1, :param_2) AND ROW(t.id, t.fk) < ROW(:ROW_1, :ROW_2)

>>> from sqlalchemy import table, column, func, select
>>> a = table( "a", column("id"), column("x"), column("y"))
>>> stmt = select(func.row_to_json(a.table_valued()))
>>> print(stmt)
{printsql}SELECT row_to_json(a) AS row_to_json_1
FROM a

Типы ARRAY¶

Диалект PostgreSQL поддерживает массивы, как в виде многомерных типов столбцов, так и в виде литералов массивов:

• ARRAY - тип данных ARRAY

• array - литерал массива

• array_agg() - SQL-функция ARRAY_AGG

• aggregate_order_by - помощник для синтаксиса агрегатной функции ORDER BY в PG.

Типы JSON¶

Диалект PostgreSQL поддерживает оба типа данных JSON и JSONB, включая встроенную поддержку psycopg2 и поддержку всех специальных операторов PostgreSQL:

• JSON

• JSONB

• JSONPATH

Тип HSTORE¶

Поддерживается тип PostgreSQL HSTORE, а также литералы hstore:

• HSTORE - тип данных HSTORE

• hstore - литерал hstore

Типы ENUM¶

В PostgreSQL есть независимо создаваемая структура TYPE, которая используется для реализации перечислимого типа. Этот подход вводит сиг

• ENUM - DDL и поддержка типизации для ENUM.

• PGInspector.get_enums() - получение списка текущих типов ENUM

• ENUM.create() , ENUM.drop() - отдельные команды CREATE и DROP для ENUM.

from sqlalchemy import TypeDecorator
from sqlalchemy.dialects.postgresql import ARRAY


class ArrayOfEnum(TypeDecorator):
    impl = ARRAY

    def bind_expression(self, bindvalue):
        return sa.cast(bindvalue, self)

    def result_processor(self, dialect, coltype):
        super_rp = super(ArrayOfEnum, self).result_processor(dialect, coltype)

        def handle_raw_string(value):
            inner = re.match(r"^{(.*)}$", value).group(1)
            return inner.split(",") if inner else []

        def process(value):
            if value is None:
                return None
            return super_rp(handle_raw_string(value))

        return process

Table(
    "mydata",
    metadata,
    Column("id", Integer, primary_key=True),
    Column("data", ArrayOfEnum(ENUM("a", "b", "c", name="myenum"))),
)

class CastingArray(ARRAY):
    def bind_expression(self, bindvalue):
        return sa.cast(bindvalue, self)

Table(
    "mydata",
    metadata,
    Column("id", Integer, primary_key=True),
    Column("data", CastingArray(JSONB)),
)

Типы диапазонов и мультидиапазонов¶

Диапазон и многодиапазонные типы PostgreSQL поддерживаются для диалектов psycopg2, psycopg и asyncpg.

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

Например, пример полностью типизированной модели, использующей тип данных TSRANGE:

from datetime import datetime

from sqlalchemy.dialects.postgresql import Range
from sqlalchemy.dialects.postgresql import TSRANGE
from sqlalchemy.orm import DeclarativeBase
from sqlalchemy.orm import Mapped
from sqlalchemy.orm import mapped_column


class Base(DeclarativeBase):
    pass


class RoomBooking(Base):
    __tablename__ = "room_booking"

    id: Mapped[int] = mapped_column(primary_key=True)
    room: Mapped[str]
    during: Mapped[Range[datetime]] = mapped_column(TSRANGE)

Для представления данных для столбца during выше, тип Range - это простой класс данных, который будет представлять границы диапазона. Ниже показан INSERT строки в вышеприведенную таблицу room_booking:

from sqlalchemy import create_engine
from sqlalchemy.orm import Session

engine = create_engine("postgresql+psycopg://scott:tiger@pg14/dbname")

Base.metadata.create_all(engine)

with Session(engine) as session:
    booking = RoomBooking(
        room="101", during=Range(datetime(2013, 3, 23), datetime(2013, 3, 25))
    )
    session.add(booking)
    session.commit()

Выбор из любого столбца диапазона также возвращает Range объектов, как указано:

from sqlalchemy import select

with Session(engine) as session:
    for row in session.execute(select(RoomBooking.during)):
        print(row)

Ниже перечислены доступные типы данных диапазона:

• INT4RANGE

• INT8RANGE

• NUMRANGE

• DATERANGE

• TSRANGE

• TSTZRANGE

class sqlalchemy.dialects.postgresql.Range¶

Представляет собой диапазон PostgreSQL.

Например:

r = Range(10, 50, bounds="()")

Стиль вызова похож на стиль вызова psycopg и psycopg2, отчасти для того, чтобы облегчить миграцию с предыдущих версий SQLAlchemy, которые использовали эти объекты напрямую.

Параметры:

• lower – Значение нижней границы, или Нет

• upper – Верхнее граничное значение, или Нет

• bounds – только ключевое слово, необязательное строковое значение, которое является одним из "()", "[)", "(]", "[]". По умолчанию это значение равно "[)".

• empty – только ключевое слово, необязательный bool, указывающий, что это «пустой» диапазон

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

Members

__eq__(), adjacent_to(), contained_by(), contains(), difference(), intersection(), is_empty, isempty, lower, lower_inc, lower_inf, not_extend_left_of(), not_extend_right_of(), overlaps(), strictly_left_of(), strictly_right_of(), union(), upper, upper_inc, upper_inf

**Классный сиг

класс sqlalchemy.dialects.postgresql.Range (typing.Generic)

method sqlalchemy.dialects.postgresql.Range.__eq__(other: Any) → bool¶

Сравните этот диапазон с другим с учетом инклюзивности границ, возвращая True, если они равны.

method sqlalchemy.dialects.postgresql.Range.adjacent_to(other: Range[_T]) → bool¶

Определите, является ли этот диапазон смежным с другим.

method sqlalchemy.dialects.postgresql.Range.contained_by(other: Range[_T]) → bool¶

Определите, является ли этот диапазон содержащимся в other.

method sqlalchemy.dialects.postgresql.Range.contains(value: Union[_T, Range[_T]]) → bool¶

Определите, содержит ли данный диапазон значение.

method sqlalchemy.dialects.postgresql.Range.difference(other: Range[_T]) → Range[_T]¶

Вычислите разницу между этим диапазоном и другим.

Это вызывает исключение ValueError, если два диапазона являются «дизъюнктивными», то есть не смежными и не перекрывающимися.

method sqlalchemy.dialects.postgresql.Range.intersection(other: Range[_T]) → Range[_T]¶

Вычислите пересечение этого диапазона с другим.

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

attribute sqlalchemy.dialects.postgresql.Range.is_empty¶

Синоним атрибута „empty“.

attribute sqlalchemy.dialects.postgresql.Range.isempty¶

Синоним атрибута „empty“.

attribute sqlalchemy.dialects.postgresql.Range.lower: Optional[_T]¶

нижняя граница

attribute sqlalchemy.dialects.postgresql.Range.lower_inc¶

Возвращает True, если нижняя граница является инклюзивной.

attribute sqlalchemy.dialects.postgresql.Range.lower_inf¶

Возвращает True, если этот диапазон непуст и нижняя граница бесконечна.

method sqlalchemy.dialects.postgresql.Range.not_extend_left_of(other: Range[_T]) → bool¶

Определите, не распространяется ли это слева от other.

method sqlalchemy.dialects.postgresql.Range.not_extend_right_of(other: Range[_T]) → bool¶

Определите, не распространяется ли это на право другой.

method sqlalchemy.dialects.postgresql.Range.overlaps(other: Range[_T]) → bool¶

Определите, пересекается ли этот диапазон с другим.

method sqlalchemy.dialects.postgresql.Range.strictly_left_of(other: Range[_T]) → bool¶

Определите, находится ли этот диапазон полностью слева от other.

method sqlalchemy.dialects.postgresql.Range.strictly_right_of(other: Range[_T]) → bool¶

Определите, находится ли этот диапазон полностью справа от other.

method sqlalchemy.dialects.postgresql.Range.union(other: Range[_T]) → Range[_T]¶

Вычислите объединение этого диапазона с другим.

Это вызывает исключение ValueError, если два диапазона являются «дизъюнктивными», то есть не смежными и не перекрывающимися.

attribute sqlalchemy.dialects.postgresql.Range.upper: Optional[_T]¶

верхняя граница

attribute sqlalchemy.dialects.postgresql.Range.upper_inc¶

Возвращает True, если верхняя граница является инклюзивной.

attribute sqlalchemy.dialects.postgresql.Range.upper_inf¶

Возвращает True, если этот диапазон непустой и верхняя граница бесконечна.

from datetime import datetime
from typing import List

from sqlalchemy.dialects.postgresql import Range
from sqlalchemy.dialects.postgresql import TSMULTIRANGE
from sqlalchemy.orm import DeclarativeBase
from sqlalchemy.orm import Mapped
from sqlalchemy.orm import mapped_column


class Base(DeclarativeBase):
    pass


class EventCalendar(Base):
    __tablename__ = "event_calendar"

    id: Mapped[int] = mapped_column(primary_key=True)
    event_name: Mapped[str]
    in_session_periods: Mapped[List[Range[datetime]]] = mapped_column(TSMULTIRANGE)

from sqlalchemy import create_engine
from sqlalchemy import select
from sqlalchemy.orm import Session

engine = create_engine("postgresql+psycopg://scott:tiger@pg14/test")

Base.metadata.create_all(engine)

with Session(engine) as session:
    calendar = EventCalendar(
        event_name="SQLAlchemy Tutorial Sessions",
        in_session_periods=[
            Range(datetime(2013, 3, 23), datetime(2013, 3, 25)),
            Range(datetime(2013, 4, 12), datetime(2013, 4, 15)),
            Range(datetime(2013, 5, 9), datetime(2013, 5, 12)),
        ],
    )
    session.add(calendar)
    session.commit()

    for multirange in session.scalars(select(EventCalendar.in_session_periods)):
        for range_ in multirange:
            print(f"Start: {range_.lower}  End: {range_.upper}")

Типы данных PostgreSQL¶

Как и во всех диалектах SQLAlchemy, все типы UPPERCASE, которые, как известно, действительны в PostgreSQL, импортируются из диалекта верхнего уровня, независимо от того, происходят ли они из sqlalchemy.types или из локального диалекта:

from sqlalchemy.dialects.postgresql import (
    ARRAY,
    BIGINT,
    BIT,
    BOOLEAN,
    BYTEA,
    CHAR,
    CIDR,
    CITEXT,
    DATE,
    DOUBLE_PRECISION,
    ENUM,
    FLOAT,
    HSTORE,
    INET,
    INTEGER,
    INTERVAL,
    JSON,
    JSONB,
    MACADDR,
    MACADDR8,
    MONEY,
    NUMERIC,
    OID,
    REAL,
    SMALLINT,
    TEXT,
    TIME,
    TIMESTAMP,
    UUID,
    VARCHAR,
    INT4RANGE,
    INT8RANGE,
    NUMRANGE,
    DATERANGE,
    TSRANGE,
    TSTZRANGE,
    REGCONFIG,
    REGCLASS,
    TSQUERY,
    TSVECTOR,
)

Ниже перечислены типы, специфичные для PostgreSQL или имеющие специфичные для PostgreSQL аргументы построения:

class sqlalchemy.dialects.postgresql.AbstractRange¶

База для типов RANGE в PostgreSQL.

См.также

PostgreSQL range functions

Members

adjacent_to(), contained_by(), contains(), difference(), intersection(), not_extend_left_of(), not_extend_right_of(), overlaps(), strictly_left_of(), strictly_right_of(), union()

**Классный сиг

класс sqlalchemy.dialects.postgresql.AbstractRange (sqlalchemy.types.TypeEngine)

class comparator_factory¶

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

**Классный сиг

класс sqlalchemy.dialects.postgresql.AbstractRange.comparator_factory (sqlalchemy.types.Comparator)

method sqlalchemy.dialects.postgresql.AbstractRange.comparator_factory.adjacent_to(other: Any) → ColumnElement[bool]¶

Булево выражение. Возвращает true, если диапазон в столбце является смежным с диапазоном в операнде.

method sqlalchemy.dialects.postgresql.AbstractRange.comparator_factory.contained_by(other: Any) → ColumnElement[bool]¶

Булево выражение. Возвращает true, если столбец содержится в правом операнде.

method sqlalchemy.dialects.postgresql.AbstractRange.comparator_factory.contains(other: Any, **kw: Any) → ColumnElement[bool]¶

Булево выражение. Возвращает true, если правый операнд, который может быть элементом или диапазоном, содержится в столбце.

kwargs может быть ig

method sqlalchemy.dialects.postgresql.AbstractRange.comparator_factory.difference(other: Any) → ColumnElement[bool]¶

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

method sqlalchemy.dialects.postgresql.AbstractRange.comparator_factory.intersection(other: Any) → ColumnElement[Range[_T]]¶

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

method sqlalchemy.dialects.postgresql.AbstractRange.comparator_factory.not_extend_left_of(other: Any) → ColumnElement[bool]¶

Булево выражение. Возвращает true, если диапазон в столбце не простирается влево от диапазона в операнде.

method sqlalchemy.dialects.postgresql.AbstractRange.comparator_factory.not_extend_right_of(other: Any) → ColumnElement[bool]¶

Булево выражение. Возвращает true, если диапазон в столбце не простирается вправо от диапазона в операнде.

method sqlalchemy.dialects.postgresql.AbstractRange.comparator_factory.overlaps(other: Any) → ColumnElement[bool]¶

Булево выражение. Возвращает true, если колонка перекрывает (имеет общие точки с) правый операнд.

method sqlalchemy.dialects.postgresql.AbstractRange.comparator_factory.strictly_left_of(other: Any) → ColumnElement[bool]¶

Булево выражение. Возвращает true, если столбец находится строго слева от правого операнда.

method sqlalchemy.dialects.postgresql.AbstractRange.comparator_factory.strictly_right_of(other: Any) → ColumnElement[bool]¶

Булево выражение. Возвращает true, если столбец находится строго справа от правого операнда.

method sqlalchemy.dialects.postgresql.AbstractRange.comparator_factory.union(other: Any) → ColumnElement[bool]¶

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

class sqlalchemy.dialects.postgresql.AbstractMultiRange¶

база для типов PostgreSQL MULTIRANGE

**Классный сиг

класс sqlalchemy.dialects.postgresql.AbstractMultiRange (sqlalchemy.dialects.postgresql.ranges.AbstractRange)

class sqlalchemy.dialects.postgresql.ARRAY¶

Тип PostgreSQL ARRAY.

Тип ARRAY строится так же, как и основной тип ARRAY; требуется тип-член, и рекомендуется указать число измерений, если тип будет использоваться для более чем одного измерения:

from sqlalchemy.dialects import postgresql

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

Тип ARRAY предоставляет все операции, определенные для основного типа ARRAY, включая поддержку «размеров», индексированный доступ и простое сопоставление, такое как Comparator.any() и Comparator.all(). Класс ARRAY также предоставляет специфические для PostgreSQL методы для операций сдерживания, включая Comparator.contains() Comparator.contained_by() и Comparator.overlap(), например:

mytable.c.data.contains([1, 2])

Тип ARRAY может поддерживаться не во всех PostgreSQL DBAPI; в настоящее время известно, что он работает только в psycopg2.

Кроме того, тип ARRAY не работает непосредственно в сочетании с типом ENUM. Для обходного пути смотрите специальный тип Использование ENUM с ARRAY.

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

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

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

class SomeOrmClass(Base):
    # ...

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

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

В качестве альтернативы можно назначить

См.также

ARRAY - базовый тип массива

array - выдает буквальное значение массива.

Members

contained_by(), contains(), overlap(), __init__()

**Классный сиг

класс sqlalchemy.dialects.postgresql.ARRAY (sqlalchemy.types.ARRAY)

class Comparator¶

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

Обратите внимание, что эти операции дополняют операции, предоставляемые базовым классом Comparator, включая Comparator.any() и Comparator.all().

**Классный сиг

класс sqlalchemy.dialects.postgresql.ARRAY.Comparator (sqlalchemy.types.Comparator)

method sqlalchemy.dialects.postgresql.ARRAY.Comparator.contained_by(other)¶

Булево выражение. Проверяет, являются ли элементы правильным подмножеством элементов выражения массива аргументов.

method sqlalchemy.dialects.postgresql.ARRAY.Comparator.contains(other, **kwargs)¶

Булево выражение. Проверяет, являются ли элементы супермножеством элементов выражения массива аргументов.

kwargs может быть ig

method sqlalchemy.dialects.postgresql.ARRAY.Comparator.overlap(other)¶

Булево выражение. Проверка наличия у массива общих элементов с выражением массива аргументов.

method sqlalchemy.dialects.postgresql.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 – Укажите, следует ли преобразовывать возвращаемые результаты в кортежи из списков. DBAPI, такие как psycopg2, по умолчанию возвращают списки. Если возвращаются кортежи, результаты можно хэшировать.

• dimensions – если нет, то ARRAY будет иметь фиксированное число размеров. Это приведет к тому, что DDL, создаваемый для этого ARRAY, будет включать точное количество скобочных предложений [], а также оптимизирует производительность типа в целом. Обратите внимание, что массивы PG всегда неявно «безразмерные», то есть они могут хранить любое количество размеров независимо от того, как они были объявлены.

• zero_indexes=False – когда True, значения индексов будут преобразованы между нулевыми индексами Python и единичными индексами PostgreSQL, например, значение единицы будет добавлено ко всем значениям индексов перед передачей в базу данных.

class sqlalchemy.dialects.postgresql.BIT¶

**Классный сиг

класс sqlalchemy.dialects.postgresql.BIT (sqlalchemy.types.TypeEngine)

class sqlalchemy.dialects.postgresql.BYTEA¶

Members

__init__()

**Классный сиг

класс sqlalchemy.dialects.postgresql.BYTEA (sqlalchemy.types.LargeBinary)

method sqlalchemy.dialects.postgresql.BYTEA.__init__(length: Optional[int] = None)¶

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

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

Параметры:

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

class sqlalchemy.dialects.postgresql.CIDR¶

**Классный сиг

класс sqlalchemy.dialects.postgresql.CIDR (sqlalchemy.types.TypeEngine)

class sqlalchemy.dialects.postgresql.CITEXT¶

Укажите тип PostgreSQL CITEXT.

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

Members

__init__()

**Классный сиг

класс sqlalchemy.dialects.postgresql.CITEXT (sqlalchemy.types.TEXT)

method sqlalchemy.dialects.postgresql.CITEXT.__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.dialects.postgresql.DOMAIN¶

Представляет тип DOMAIN PostgreSQL.

Домен - это, по сути, тип данных с необязательными ограничениями, которые ограничивают допустимый набор значений. Например:

PositiveInt = DOMAIN(
    "pos_int", Integer, check="VALUE > 0", not_null=True
)

UsPostalCode = DOMAIN(
    "us_postal_code",
    Text,
    check="VALUE ~ '^\d{5}$' OR VALUE ~ '^\d{5}-\d{4}$'"
)

Дополнительные сведения см. в PostgreSQL documentation

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

Members

__init__(), create(), drop()

**Классный сиг

класс sqlalchemy.dialects.postgresql.DOMAIN (sqlalchemy.dialects.postgresql.named_types.NamedType, sqlalchemy.types.SchemaType)

method sqlalchemy.dialects.postgresql.DOMAIN.__init__(name: str, data_type: _TypeEngineArgument[Any], *, collation: Optional[str] = None, default: Optional[Union[str, elements.TextClause]] = None, constraint_name: Optional[str] = None, not_null: Optional[bool] = None, check: Optional[str] = None, create_type: bool = True, **kw: Any)¶

Создайте ДОМАЙН.

Параметры:

• name – имя домена

• data_type – Тип данных, лежащий в основе домена. Он может включать спецификаторы массивов.

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

• default – Пункт DEFAULT задает значение по умолчанию для столбцов типа данных домена. Значение по умолчанию должно быть строкой или значением text(). Если значение по умолчанию не указано, то значением по умолчанию будет нулевое значение.

• constraint_name – Необязательное имя для ограничения. Если не указано, бэкенд генерирует имя.

• not_null – Значениям этого домена запрещено быть нулевыми. По умолчанию домену разрешено быть нулевым. Если это не указано, то не будет выдаваться оговорка о недействительности.

• check – Пункт CHECK задает ограничение целостности или тест, которому должны удовлетворять значения домена. Ограничение должно быть выражением, дающим булевский результат, которое может использовать ключевое слово VALUE для обозначения проверяемого значения. В отличие от PostgreSQL, в SQLAlchemy в настоящее время допускается только одно предложение проверки.

• schema – необязательное имя схемы

• metadata – необязательный объект MetaData, с которым этот DOMAIN будет непосредственно связан

• create_type – По умолчанию имеет значение True. Указывает, что CREATE TYPE должно быть выдано, после дополнительной проверки на наличие типа, при создании родительской таблицы; и дополнительно, что DROP TYPE будет вызвано, когда таблица будет уничтожена.

method sqlalchemy.dialects.postgresql.DOMAIN.create(bind, checkfirst=True, **kw)¶

наследуется от NamedType.create() метода NamedType

Выдавать CREATE DDL для этого типа.

Параметры:

• bind – подключаемый Engine, Connection или аналогичный объект для эмиссии SQL.

• checkfirst – если True, то перед созданием сначала будет выполнен запрос к каталогу PG, чтобы убедиться, что тип еще не существует.

method sqlalchemy.dialects.postgresql.DOMAIN.drop(bind, checkfirst=True, **kw)¶

наследуется от NamedType.drop() метода NamedType

Выдавать DROP DDL для этого типа.

Параметры:

• bind – подключаемый Engine, Connection или аналогичный объект для эмиссии SQL.

• checkfirst – если True, сначала будет выполнен запрос к каталогу PG, чтобы проверить, существует ли тип на самом деле, прежде чем отбросить его.

class sqlalchemy.dialects.postgresql.DOUBLE_PRECISION

Тип SQL DOUBLE PRECISION.

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

См.также

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

**Классный сиг

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

method sqlalchemy.dialects.postgresql.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. Чтобы создать базу данных ag

• asdecimal – тот же флаг, что и у Numeric, но по умолчанию имеет значение False. Обратите внимание, что установка этого флага в значение True приводит к преобразованию с плавающей точкой.

• decimal_return_scale – Масштаб по умолчанию, используемый при преобразовании значений с плавающей точкой в десятичные числа Python. Значения с плавающей точкой обычно намного длиннее из-за неточности десятичных дробей, а большинство типов баз данных с плавающей точкой не имеют понятия «масштаб», поэтому по умолчанию тип float ищет первые десять десятичных знаков при преобразовании. Указание этого значения отменяет эту длину. Обратите внимание, что типы MySQL float, которые включают «масштаб», будут использовать «масштаб» по умолчанию для decimal_return_scale, если не указано иное.