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

• pg8000

• asyncpg

• psycopg2cffi

• py-postgresql

• pygresql

序列/序列/标识¶

PostgreSQL支持序列，SQLAlchemy使用这些作为为基于整数的主键列创建新主键值的默认方法。创建表时，SQLAlchemy将发出 SERIAL 基于整数的主键列的数据类型，它生成与该列对应的序列和服务器端默认值。

要指定用于生成主键的特定命名序列，请使用 Sequence() 结构：

Table('sometable', metadata,
        Column('id', Integer, Sequence('some_id_seq'), primary_key=True)
    )

当sqlAlchemy发出单个insert语句时，为了满足“last insert identifier”可用的约定，在insert语句中添加了一个返回子句，指定在语句完成后应返回主键列。返回功能仅在使用PostgreSQL 8.2或更高版本时发生。作为回退方法，序列，无论是通过 SERIAL ，是预先独立执行的，返回的值将在随后的插入中使用。注意，当 insert() 使用“ExecuteMany”语义执行构造，不应用“Last Inserted Identifier”功能；不会发出返回子句，在这种情况下也不会预先执行序列。

若要强制使用默认返回，请指定标志 implicit_returning=False 到 create_engine() .

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.execution_options 参数 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",
    execution_options={
        "isolation_level": "REPEATABLE READ"
    }
)

使用每个连接执行选项进行设置：

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

的有效值 isolation_level 大多数PostgreSQL方言包括：

• READ COMMITTED

• READ UNCOMMITTED

• REPEATABLE READ

• SERIALIZABLE

• AUTOCOMMIT

设置只读/可延迟¶

大多数PostgreSQL方言支持设置事务的“只读”和“可延迟”特性，这是对隔离级别设置的补充。通过传递 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”。

在连接上设置备用搜索路径¶

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

食谱之所以复杂，是因为使用了 .autocommit DBAPI属性是这样的，因此当 SET SESSION search_path 指令时，它将在任何事务的作用域之外调用，因此当DBAPI连接具有回滚时不会恢复。

远程模式表自省和PostgreSQL搜索路径¶

TL；DR； 保持 search_path 变量设置为默认值 public 命名模式 其他 比 public 明确在 Table 定义。

PostgreSQL方言可以反映任何模式中的表。这个 Table.schema 参数，或者也可以选择 MetaData.reflect.schema 参数确定将在哪个架构中搜索表。“倒影” Table 对象在所有情况下都将保留此属性 .schema 属性。但是，对于这些表， Table 对象通过外键约束引用，则必须决定 .schema 如果该远程架构名称也是当前 PostgreSQL search path 。

默认情况下，PostgreSQL方言模仿PostgreSQL自己鼓励的行为。 pg_get_constraintdef() 内置程序。此函数返回特定外键约束的示例定义，当该名称也在PostgreSQL模式搜索路径中时，省略该定义中引用的架构名称。下面的交互说明了这种行为：

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://scott:tiger@localhost/test")
>>> with engine.connect() as conn:
...     conn.execute(text("SET search_path TO test_schema, public"))
...     meta = MetaData()
...     referring = Table('referring', meta,
...                       autoload_with=conn)
...
<sqlalchemy.engine.result.CursorResult object at 0x101612ed0>

上述流程将交付给 MetaData.tables 收集 referred 表命名 没有 模式：

>>> meta.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"))
...     meta = MetaData()
...     referring = Table('referring', meta,
...                       autoload_with=conn,
...                       postgresql_ignore_search_path=True)
...
<sqlalchemy.engine.result.CursorResult object at 0x1016126d0>

我们现在就要 test_schema.referred 存储为架构限定：：

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

注意 在所有情况下 “默认”模式始终反映为 None . PostgreSQL上的“默认”模式是PostgreSQL返回的模式。 current_schema() 功能。在典型的PostgreSQL安装中，这是 public . 所以一个表引用了 public （即默认）模式将始终具有 .schema 属性设置为 None .

INSERT/UPDATE...RETURNING¶

方言支持第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())

冲突时插入（向上插入）¶

从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)
INSERT INTO my_table (id, data) VALUES (%(id)s, %(data)s)
ON CONFLICT (id) DO NOTHING
>>> do_update_stmt = insert_stmt.on_conflict_do_update(
...     constraint='pk_my_table',
...     set_=dict(data='updated value')
... )
>>> print(do_update_stmt)
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)
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)
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)
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)
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)
INSERT INTO my_table (id, data) VALUES (%(id)s, %(data)s)
ON CONFLICT DO NOTHING

全文搜索¶

SQLAlChemy使PostgreSQL变得可用 @@ 运算符通过 ColumnElement.match() 方法对任何文本列表达式执行。

在PostgreSQL方言中，如下所示的表达式：

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

将发送到数据库：：

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

各种其他PostgreSQL文本搜索功能，例如 to_tsquery() ， to_tsvector() ，以及 plainto_tsquery() 通过显式使用标准SQLAlChemy func 构造。

例如：：

select(func.to_tsvector('fat cats ate rats').match('cat & rat'))

发射相当于：

SELECT to_tsvector('fat cats ate rats') @@ to_tsquery('cat & rat')

这个 TSVECTOR 类型不能提供显式强制转换：：

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

PostgreSQL中的全文搜索受以下组合的影响：PostgreSQL设置 default_text_search_config , the regconfig 用于构建GIN/GIST索引，以及 regconfig 在查询期间可选传入。

当对已经预先计算了GIN或GIST索引（在全文搜索中很常见）的列执行全文搜索时，可能需要显式传递特定的PostgreSQL regconfig 值以确保查询规划器使用索引，并且不会根据需要重新计算列。

为了提供这种明确的查询计划，或者使用不同的搜索策略，可以使用 match 方法接受 postgresql_regconfig 关键字参数：

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

发射相当于：

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

你也可以通过 'regconfig' 价值 to_tsvector() 作为初始参数的命令：

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

生成等价于以下内容的语句：

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

建议您使用 EXPLAIN ANALYZE... PostgreSQL中的工具，以确保使用sqlAlchemy生成的查询充分利用了为全文搜索创建的任何索引。

仅从…¶

方言支持PostgreSQL的唯一关键字，只针对继承层次结构中的特定表。这可用于生产 SELECT ... FROM ONLY, UPDATE ONLY ..., and 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索引反射¶

每当使用UNIQUE约束构造时，PostgreSQL数据库都会隐式创建一个UNIQUE索引。使用检查表格时 Inspector ，即 Inspector.get_indexes() 以及 Inspector.get_unique_constraints() 将清楚地报告这两个结构；在索引的情况下，键 duplicates_constraint 如果检测到它在镜像约束，则它将出现在索引条目中。使用执行反射时 Table(..., autoload_with=engine) ，唯一索引为 not 返回的时间 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(bind)¶

类签名

class sqlalchemy.dialects.postgresql.base.PGInspector (sqlalchemy.engine.reflection.Inspector)

method sqlalchemy.dialects.postgresql.base.PGInspector.get_enums(schema=None)¶

返回枚举对象列表。

每个成员都是包含以下字段的字典：

• name-枚举的名称

• schema-枚举的架构名称。

• 可见-布尔值，无论此枚举在默认搜索路径中是否可见。

• 标签-应用于枚举的字符串标签列表。

参数

schema¶ -- 架构名称。如果没有，则使用默认架构（通常为“public”）。也可以设置为“*”以指示所有架构的加载枚举。

1.0.0 新版功能.

method sqlalchemy.dialects.postgresql.base.PGInspector.get_foreign_table_names(schema=None)¶

返回外部表名列表。

行为类似于 Inspector.get_table_names() ，但列表仅限于报告 relkind 价值 f .

1.0.0 新版功能.

method sqlalchemy.dialects.postgresql.base.PGInspector.get_table_oid(table_name, schema=None)¶

返回给定表名的OID。

method sqlalchemy.dialects.postgresql.base.PGInspector.get_view_names(schema=None, include=('plain', 'materialized'))¶

返回所有视图名称 schema .

参数

• schema¶ -- 可选，从非默认架构中检索名称。对于特殊报价，使用 quoted_name .

• include¶ -- 指定要返回的视图类型。作为字符串值（对于单个类型）或元组（对于任意数量的类型）传递。默认为 ('plain', 'materialized') . …添加的版本：1.1

PostgreSQL表选项¶

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", ...))
  
  .. versionadded:: 1.0.0

• PARTITION BY ：：

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

表值、表值函数和列值函数、行和元组对象¶

PostgreSQL大量使用现代SQL形式，如表值函数、表和行作为值。这些构造通常用作PostgreSQL对复杂数据类型(如JSON、数组和其他数据类型)支持的一部分。SQLAlChemy的SQL表达式语言具有对大多数表值和行值表单的本机支持。

>>> 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)
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)
SELECT row_to_json(a) AS row_to_json_1
FROM a

数组类型¶

PostgreSQL方言支持数组，既支持多维列类型，也支持数组文字：

• ARRAY -数组数据类型

• array 数组文字

• array_agg() -数组agg sql函数

• aggregate_order_by -pg的order by aggregate函数语法助手。

JSON类型¶

PostgreSQL方言支持JSON和JSONB数据类型，包括psycopg2的本地支持和对PostgreSQL所有特殊运算符的支持：

• JSON

• JSONB

HStury型¶

支持PostgreSQL hstore类型和hstore文本：

• HSTORE -hstore数据类型

• hstore -hstore文本

枚举类型¶

PostgreSQL有一个独立可创建的类型结构，用于实现枚举类型。这种方法在sqlacalchemy方面引入了显著的复杂性，即何时应该创建和删除此类型。类型对象也是一个独立的可反射实体。应参考以下章节：

• ENUM -对枚举的DDL和键入支持。

• PGInspector.get_enums() -检索当前枚举类型的列表

• ENUM.create() ， ENUM.drop() -用于枚举的单个创建和删除命令。

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数据类型和自定义SQL结构¶

与所有的sqlAlchemy方言一样，已知对postgresql有效的所有大写类型都可以从顶级方言导入，无论它们是否源自 sqlalchemy.types 或者来自当地方言：

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

特定于PostgreSQL或具有特定于PostgreSQL的构造参数的类型如下：

class sqlalchemy.dialects.postgresql.aggregate_order_by(target, *order_by)¶

按表达式表示PostgreSQL聚合顺序。

例如。：：

from sqlalchemy.dialects.postgresql import aggregate_order_by
expr = func.array_agg(aggregate_order_by(table.c.a, table.c.b.desc()))
stmt = select(expr)

表示表达式：

SELECT array_agg(a ORDER BY b DESC) FROM table;

类似：：

expr = func.string_agg(
    table.c.a,
    aggregate_order_by(literal_column("','"), table.c.a)
)
stmt = select(expr)

代表：

SELECT string_agg(a, ',' ORDER BY a) FROM table;

1.1 新版功能.

在 1.2.13 版更改: -order by参数可以是多个术语

参见

array_agg

类签名

class sqlalchemy.dialects.postgresql.aggregate_order_by (sqlalchemy.sql.expression.ColumnElement)

class sqlalchemy.dialects.postgresql.array(clauses, **kw)¶

PostgreSQL数组文本。

这用于在SQL表达式中生成数组文本，例如：

from sqlalchemy.dialects.postgresql import array
from sqlalchemy.dialects import postgresql
from sqlalchemy import select, func

stmt = select(array([1,2]) + array([3,4,5]))

print(stmt.compile(dialect=postgresql.dialect()))

生成SQL:：

SELECT ARRAY[%(param_1)s, %(param_2)s] ||
    ARRAY[%(param_3)s, %(param_4)s, %(param_5)s]) AS anon_1

的实例 array 将始终具有数据类型 ARRAY . 数组的“内部”类型是根据当前值推断的，除非 type_ 传递关键字参数：：

array(['foo', 'bar'], type_=CHAR)

多维数组是通过嵌套生成的 array 构造。最后一个维度 ARRAY 类型是通过递归地添加内部维度来计算的 ARRAY 类型：

stmt = select(
    array([
        array([1, 2]), array([3, 4]), array([column('q'), column('x')])
    ])
)
print(stmt.compile(dialect=postgresql.dialect()))

生产：：

SELECT ARRAY[ARRAY[%(param_1)s, %(param_2)s],
ARRAY[%(param_3)s, %(param_4)s], ARRAY[q, x]] AS anon_1

1.3.6 新版功能: 增加了对多维数组文本的支持

参见

ARRAY

类签名

class sqlalchemy.dialects.postgresql.array (sqlalchemy.sql.expression.ClauseList, sqlalchemy.sql.expression.ColumnElement)

class sqlalchemy.dialects.postgresql.ARRAY(item_type, as_tuple=False, dimensions=None, zero_indexes=False)¶

PostgreSQL数组类型。

在 1.1 版更改: 这个 ARRAY 类型现在是核心的子类 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 DBAPIS上的类型；目前已知它仅在PSycopg2上工作。

另外， ARRAY 类型不直接与 ENUM 类型。有关解决方法，请参见 将枚举与数组一起使用 .

参见

ARRAY -基数组类型

array -生成文本数组值。

类签名

class sqlalchemy.dialects.postgresql.ARRAY (sqlalchemy.types.ARRAY)

class Comparator(expr)¶

为定义比较操作 ARRAY .

请注意，这些操作是对基地提供的操作的补充 Comparator 类，包括 Comparator.any() 和 Comparator.all() .

类签名

class 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，但它是API一致性所必需的。

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

布尔表达式。测试数组是否具有与参数数组表达式相同的元素。

method sqlalchemy.dialects.postgresql.ARRAY.__init__(item_type, as_tuple=False, dimensions=None, zero_indexes=False)¶

构造数组。

例如。：：

Column('myarray', ARRAY(Integer))

论点是：

参数

• item_type¶ -- 此数组项的数据类型。注意维数在这里是不相关的，所以多维数组 INTEGER[][] ，构造为 ARRAY(Integer) ，而不是 ARRAY(ARRAY(Integer)) 或者这样。

• as_tuple=False¶ -- 指定是否应将返回结果从列表转换为元组。默认情况下，dbapis（如psycopg2）返回列表。当返回元组时，结果是可哈希的。

• dimensions¶ -- 如果非“无”，则数组将采用固定数量的维度。这将导致为此数组发出的DDL包含括号子句的确切数目。 [] 同时也将优化该类型的整体性能。请注意，pg数组总是隐式地“无维度”，这意味着无论如何声明，它们都可以存储任意数量的维度。

• zero_indexes=False¶ -- 如果为true，则索引值将在基于python零的索引和基于postgresql一的索引之间转换，例如，在传递到数据库之前，将向所有索引值添加一个值。…添加的版本：0.9.5

function sqlalchemy.dialects.postgresql.array_agg(*arg, **kw)¶

PostgreSQL特定形式的 array_agg ，确保返回类型为 ARRAY 而不是平原 ARRAY ，除非 type_ 通过。

1.1 新版功能.

function sqlalchemy.dialects.postgresql.Any(other, arrexpr, operator=<built-in function eq>)¶

数组级别的同义词 Comparator.any() 方法。有关详细信息，请参阅该方法。

function sqlalchemy.dialects.postgresql.All(other, arrexpr, operator=<built-in function eq>)¶

数组级别的同义词 Comparator.all() 方法。有关详细信息，请参阅该方法。

class sqlalchemy.dialects.postgresql.BIT(length=None, varying=False)¶

类签名

class sqlalchemy.dialects.postgresql.BIT (sqlalchemy.types.TypeEngine)

class sqlalchemy.dialects.postgresql.BYTEA(length=None)¶

类签名

class sqlalchemy.dialects.postgresql.BYTEA (sqlalchemy.types.LargeBinary)

method sqlalchemy.dialects.postgresql.BYTEA.__init__(length=None)¶

inherited from the sqlalchemy.types.LargeBinary.__init__ method of LargeBinary

构造一个大二进制类型。

参数

length¶ -- 可选，用于ddl语句中的列的长度，用于接受长度的二进制类型，例如mysql blob类型。

class sqlalchemy.dialects.postgresql.CIDR¶

类签名

class sqlalchemy.dialects.postgresql.CIDR (sqlalchemy.types.TypeEngine)

class sqlalchemy.dialects.postgresql.DOUBLE_PRECISION(precision=None, asdecimal=False, decimal_return_scale=None)¶

类签名

class sqlalchemy.dialects.postgresql.DOUBLE_PRECISION (sqlalchemy.types.Float)

method sqlalchemy.dialects.postgresql.DOUBLE_PRECISION.__init__(precision=None, asdecimal=False, decimal_return_scale=None)¶

inherited from the sqlalchemy.types.Float.__init__ method of Float

构造一个浮点。

参数

• precision¶ -- 用于DDL的数字精度 CREATE TABLE .

• asdecimal¶ -- 与…相同的标志 Numeric ，但默认为 False . 请注意，将此标志设置为 True 导致浮点转换。

• decimal_return_scale¶ -- 从浮点转换为python小数时使用的默认小数位数。由于小数点不准确，浮点值通常要长得多，而且大多数浮点数据库类型没有“小数位数”的概念，因此默认情况下，浮点类型在转换时查找前十位小数。指定此值将覆盖该长度。注意，如果没有另外指定，mysql float类型（包括“scale”）将使用“scale”作为decimal_return_scale的默认值。…版本已添加：：0.9.0

class sqlalchemy.dialects.postgresql.ENUM(*enums, **kw)¶

PostgreSQL枚举类型。

这是 Enum 包括对PG的支持 CREATE TYPE 和 DROP TYPE .

当内置类型 Enum 使用和 Enum.native_enum 标志的默认值为true，PostgreSQL后端将使用 ENUM 键入作为实现，因此将使用特殊的创建/删除规则。

枚举的创建/删除行为必然是复杂的，因为枚举类型与父表之间的关系很糟糕，因为它可能只由一个表“拥有”，也可能在多个表之间共享。

使用时 Enum 或 ENUM 以“内联”方式， CREATE TYPE 和 DROP TYPE 发出的时间与 Table.create() 和 Table.drop() 方法被调用：：

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

table.create(engine)  # will emit CREATE ENUM and CREATE TABLE
table.drop(engine)  # will emit DROP TABLE and DROP ENUM

要在多个表之间使用通用的枚举类型，最佳做法是声明 Enum 或 ENUM 独立，并将其与 MetaData 对象本身：

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

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

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

使用此模式时，必须在创建的单个表的级别上小心。在不指定的情况下发出创建表 checkfirst=True 仍会导致问题：

t1.create(engine) # will fail: no such type 'myenum'

如果我们指定 checkfirst=True ，单个表级创建操作将检查 ENUM 如果不存在则创建：

# will check if enum exists, and emit CREATE TYPE if not
t1.create(engine, checkfirst=True)

使用元数据级枚举类型时，如果调用元数据范围的create/drop，则始终创建并删除该类型：：

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

也可以直接创建和删除类型：

my_enum.create(engine)
my_enum.drop(engine)

在 1.0.0 版更改: 邮报 ENUM 类型现在在创建/删除方面的行为更加严格。将仅在元数据级别（而不是表级别）创建和删除元数据级别枚举类型，但 table.create(checkfirst=True) . 这个 table.drop() 调用现在将为表级枚举类型发出一个DROP类型。

类签名

class sqlalchemy.dialects.postgresql.ENUM (sqlalchemy.types.NativeForEmulated, sqlalchemy.types.Enum)

method sqlalchemy.dialects.postgresql.ENUM.__init__(*enums, **kw)¶

构建一个 ENUM .

参数与 Enum ，也包括以下参数。

参数

create_type¶ -- 默认为true。表明 CREATE TYPE 在有选择地检查类型是否存在后，在创建父表时应发出；此外， DROP TYPE 在删除表时调用。什么时候？ False ，将不执行任何检查 CREATE TYPE 或 DROP TYPE 发出，除非 ENUM.create() 或 ENUM.drop() 直接调用。设置为 False 在不访问实际数据库的情况下调用SQL文件的创建方案时非常有用 ENUM.create() 和 ENUM.drop() 方法可用于向目标绑定发出SQL。

method sqlalchemy.dialects.postgresql.ENUM.create(bind=None, checkfirst=True)¶

发出 CREATE TYPE 为此 ENUM .

如果底层方言不支持PostgreSQL创建类型，则不执行任何操作。

参数

• bind¶ -- 可连接的 Engine ， Connection 或类似对象以发出SQL。

• checkfirst¶ -- 如果 True ，在创建之前，将首先对pg目录执行查询，以查看类型是否已经不存在。

method sqlalchemy.dialects.postgresql.ENUM.drop(bind=None, checkfirst=True)¶

发出 DROP TYPE 为此 ENUM .

如果底层方言不支持PostgreSQL Drop类型，则不执行任何操作。

参数

• bind¶ -- 可连接的 Engine ， Connection 或类似对象以发出SQL。

• checkfirst¶ -- 如果 True ，将首先对pg目录执行查询，以在删除之前查看类型是否实际存在。

class sqlalchemy.dialects.postgresql.HSTORE(text_type=None)¶

表示PostgreSQL hstore类型。

这个 HSTORE 类型存储包含字符串的字典，例如：

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

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

HSTORE 提供广泛的操作，包括：

• 索引操作：

  data_table.c.data['some key'] == 'some value'

• 遏制行动：

  data_table.c.data.has_key('some key')
  
  data_table.c.data.has_all(['one', 'two', 'three'])

• 级联：

  data_table.c.data + {"k1": "v1"}

有关特殊方法的完整列表，请参见 comparator_factory .

对于与SQLAlchemy ORM一起使用，可能需要将 HSTORE 具有 MutableDict 词典现在是 sqlalchemy.ext.mutable 延伸。此扩展将允许对字典进行“就地”更改，例如在当前字典中添加新键或替换/删除现有键，以生成工作单元检测到的事件：

from sqlalchemy.ext.mutable import MutableDict

class MyClass(Base):
    __tablename__ = 'data_table'

    id = Column(Integer, primary_key=True)
    data = Column(MutableDict.as_mutable(HSTORE))

my_object = session.query(MyClass).one()

# in-place mutation, requires Mutable extension
# in order for the ORM to detect
my_object.data['some_key'] = 'some value'

session.commit()

当 sqlalchemy.ext.mutable 如果不使用扩展名，则不会向ORM发出对现有字典内容的任何更改的警报，除非将字典值重新分配给hstore属性本身，从而生成更改事件。

参见

hstore -呈现PostgreSQL hstore() 功能。

类签名

class sqlalchemy.dialects.postgresql.HSTORE (sqlalchemy.types.Indexable, sqlalchemy.types.Concatenable, sqlalchemy.types.TypeEngine)

class Comparator(expr)¶

为定义比较操作 HSTORE .

类签名

class sqlalchemy.dialects.postgresql.HSTORE.Comparator (sqlalchemy.types.Comparator, sqlalchemy.types.Comparator)

method sqlalchemy.dialects.postgresql.HSTORE.Comparator.array()¶

文本数组表达式。返回交替键和值的数组。

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

布尔表达式。测试键是否是参数jsonb表达式键的适当子集。

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

布尔表达式。测试键（或数组）是否是参数jsonb表达式的键的超集/包含键。

此操作员可能会忽略kwargs，但它是API一致性所必需的。

method sqlalchemy.dialects.postgresql.HSTORE.Comparator.defined(key)¶

布尔表达式。测试键是否存在非空值。注意，键可能是一个sqla表达式。

method sqlalchemy.dialects.postgresql.HSTORE.Comparator.delete(key)¶

hstore表达式。返回已删除给定密钥的hstore的内容。注意，键可能是一个sqla表达式。

method sqlalchemy.dialects.postgresql.HSTORE.Comparator.has_all(other)¶

布尔表达式。测试jsonb中是否存在所有密钥

method sqlalchemy.dialects.postgresql.HSTORE.Comparator.has_any(other)¶

布尔表达式。测试JSONB中是否存在任何密钥

method sqlalchemy.dialects.postgresql.HSTORE.Comparator.has_key(other)¶

布尔表达式。测试是否存在密钥。注意，键可能是一个sqla表达式。

method sqlalchemy.dialects.postgresql.HSTORE.Comparator.keys()¶

文本数组表达式。返回键数组。

method sqlalchemy.dialects.postgresql.HSTORE.Comparator.matrix()¶

文本数组表达式。返回数组 [价值键] 对。

method sqlalchemy.dialects.postgresql.HSTORE.Comparator.slice(array)¶

hstore表达式。返回由键数组定义的hstore的子集。

method sqlalchemy.dialects.postgresql.HSTORE.Comparator.vals()¶

文本数组表达式。返回值数组。

method sqlalchemy.dialects.postgresql.HSTORE.__init__(text_type=None)¶

构建新的 HSTORE .

参数

text_type¶ -- 应用于索引值的类型。默认为 Text . …添加的版本：1.1.0

method sqlalchemy.dialects.postgresql.HSTORE.bind_processor(dialect)¶

返回用于处理绑定值的转换函数。

返回一个callable，该callable将接收一个bind参数值作为唯一的位置参数，并返回一个要发送到db-api的值。

如果不需要处理，则该方法应返回 None .

参数

dialect¶ -- 方言实例正在使用中。

attribute sqlalchemy.dialects.postgresql.HSTORE.comparator_factory¶

alias of sqlalchemy.dialects.postgresql.hstore.HSTORE.Comparator

method sqlalchemy.dialects.postgresql.HSTORE.result_processor(dialect, coltype)¶

返回用于处理结果行值的转换函数。

返回一个可调用的，它将接收作为唯一位置参数的结果行列值，并返回一个值以返回给用户。

如果不需要处理，则该方法应返回 None .

参数

• dialect¶ -- 方言实例正在使用中。

• coltype¶ -- 在cursor.description中接收到dbapi coltype参数。

class sqlalchemy.dialects.postgresql.hstore(*args, **kwargs)¶

使用PostgreSQL在SQL表达式中构造一个hstore值 hstore() 功能。

这个 hstore 函数接受PostgreSQL文档中描述的一个或两个参数。

例如。：：

from sqlalchemy.dialects.postgresql import array, hstore

select(hstore('key1', 'value1'))

select(
    hstore(
        array(['key1', 'key2', 'key3']),
        array(['value1', 'value2', 'value3'])
    )
)

参见

HSTORE -《PostgreSQL》 HSTORE 数据类型。

类签名

class sqlalchemy.dialects.postgresql.hstore (sqlalchemy.sql.functions.GenericFunction)

attribute sqlalchemy.dialects.postgresql.hstore.type¶

alias of sqlalchemy.dialects.postgresql.hstore.HSTORE

class sqlalchemy.dialects.postgresql.INET¶

类签名

class sqlalchemy.dialects.postgresql.INET (sqlalchemy.types.TypeEngine)

class sqlalchemy.dialects.postgresql.INTERVAL(precision=None, fields=None)¶

PostgreSQL间隔类型。

类签名

class sqlalchemy.dialects.postgresql.INTERVAL (sqlalchemy.types.NativeForEmulated, sqlalchemy.types._AbstractInterval)

method sqlalchemy.dialects.postgresql.INTERVAL.__init__(precision=None, fields=None)¶

构造一个间隔。

参数

• precision¶ -- 可选整数精度值

• fields¶ -- 字符串字段说明符。允许限制字段的存储，例如 "YEAR" ， "MONTH" ， "DAY TO HOUR" 等。添加的版本：1.2

class sqlalchemy.dialects.postgresql.JSON(none_as_null=False, astext_type=None)¶

表示PostgreSQL JSON类型。

JSON 每当基地 JSON 数据类型用于PostgreSQL后端，但是 JSON datatype不为PostgreSQL特定的比较方法提供Python访问器，例如 Comparator.astext() ；另外，使用PostgreSQL JSONB , the JSONB 应显式使用数据类型。

参见

JSON -通用跨平台JSON数据类型的主要文档。

PostgreSQL版本提供的运算符 JSON 包括：

• 索引操作 -> 操作员）：

  data_table.c.data['some key']
  
  data_table.c.data[5]

• 返回文本的索引操作 ->> 操作员）：

  data_table.c.data['some key'].astext == 'some value'

  请注意，等效功能可通过 Comparator.as_string 访问器。

• 带cast的索引操作（相当于 CAST(col ->> ['some key'] AS <type>) ）：

  data_table.c.data['some key'].astext.cast(Integer) == 5

  请注意，等效功能可通过 Comparator.as_integer 以及类似的访问器。

• 路径索引操作 #> 操作员）：

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

• 路径索引操作返回文本 #>> 操作员）：

  data_table.c.data[('key_1', 'key_2', 5, ..., 'key_n')].astext == 'some value'

在 1.1 版更改: 这个 ColumnElement.cast() JSON对象上的运算符现在要求 Comparator.astext 如果强制转换仅从文本字符串起作用，则显式调用修饰符。

索引操作返回类型默认为的表达式对象 JSON 默认情况下，这样可以对结果类型调用更多面向JSON的指令。

自定义序列化程序和反序列化程序是在方言级别指定的，即使用 create_engine() . 原因是，当使用psycopg2时，DBAPI只允许在每个光标或每个连接级别使用序列化程序。例如。：：

engine = create_engine("postgresql://scott:tiger@localhost/test",
                        json_serializer=my_serialize_fn,
                        json_deserializer=my_deserialize_fn
                )

当使用psycopg2方言时，json_反序列化程序使用 psycopg2.extras.register_default_json .

参见

JSON -核心级JSON类型

JSONB

在 1.1 版更改: JSON 现在是PostgreSQL特有的新的专门化 JSON 类型。

类签名

class sqlalchemy.dialects.postgresql.JSON (sqlalchemy.types.JSON)

class Comparator(expr)¶

为定义比较操作 JSON .

类签名

class sqlalchemy.dialects.postgresql.JSON.Comparator (sqlalchemy.types.Comparator)

attribute sqlalchemy.dialects.postgresql.JSON.Comparator.astext¶

在索引表达式上，在SQL中呈现时使用“astext”（例如“->>”）转换。

例如。：：

select(data_table.c.data['some key'].astext)

参见

ColumnElement.cast()

method sqlalchemy.dialects.postgresql.JSON.__init__(none_as_null=False, astext_type=None)¶

构建一个 JSON 类型。

参数

• none_as_null¶ -- 如果为真，则保持该值 None 作为SQL空值，而不是 null . 请注意，当此标志为false时， null() 构造仍可以用于持久化空值：：from sqlAlchemy import null conn.execute（table.insert（），data=null（））。。版本已更改：：0.9.8-已添加 none_as_null 和 null() 现在支持以保持空值。…参阅： JSON.NULL

• astext_type¶ -- 用于的类型 Comparator.astext 索引属性上的访问器。默认为 Text . …添加的版本：1.1

attribute sqlalchemy.dialects.postgresql.JSON.comparator_factory¶

alias of sqlalchemy.dialects.postgresql.json.JSON.Comparator