版本:1.1.0b2 |发布日期:2016年7月1日

SQLAlchemy 1.1文档

列和数据类型

SQLAlchemy提供了对大多数常见数据库数据类型的抽象,以及一种用于指定自己的自定义数据类型的机制。

类型对象的方法和属性很少直接使用。Type对象被提供给Table定义,在数据库驱动程序返回错误类型的场合下,可以作为类型提示提供给functions

>>> users = Table('users', metadata,
...               Column('id', Integer, primary_key=True)
...               Column('login', String(32))
...              )

SQLAlchemy will use the Integer and String(32) type information when issuing a CREATE TABLE statement and will use it again when reading back rows SELECTed from the database. Functions that accept a type (such as Column()) will typically accept a type class or instance; Integer is equivalent to Integer() with no construction arguments in this case.

泛型类型

泛型类型指定一个可以读取,写入和存储特定类型的Python数据的列。发出CREATE TABLE语句时,SQLAlchemy将选择目标数据库上可用的最佳数据库列类型。要完全控制在CREATE TABLE中发出的列类型,例如VARCHAR,请参阅`SQL Standard Types`_和本章的其他部分。

class sqlalchemy.types。 BigInteger

基础:sqlalchemy.types.Integer

一个更大的int整数的类型。

通常在DDL中生成一个BIGINT,否则就像Python一边正常的Integer一样。

class sqlalchemy.types.Boolean(create_constraint=True, name=None, _create_events=True)

基础:sqlalchemy.types.TypeEnginesqlalchemy.types.SchemaType

一个bool数据类型。

布尔值通常在DDL端使用BOOLEAN或SMALLINT,而在Python端则使用TrueFalse

__ init __ create_constraint = Truename = None_create_events = True ) T5> ¶ T6>

构造一个布尔值。

参数:
  • create_constraint - 默认为True。如果布尔值是以int / smallint的形式生成的,那么还要在表格上创建一个确保1或0值的CHECK约束。
  • name – if a CHECK constraint is generated, specify the name of the constraint.
class sqlalchemy.types。 日期

基础:sqlalchemy.types._DateAffinitysqlalchemy.types.TypeEngine

一个用于datetime.date()对象的类型。

class sqlalchemy.types.DateTime(timezone=False)

基础:sqlalchemy.types._DateAffinitysqlalchemy.types.TypeEngine

用于datetime.datetime()对象的类型。

日期和时间类型从Python datetime模块返回对象。大多数DBAPI都支持datetime模块,除了SQLite之外。对于SQLite,日期和时间类型被存储为字符串,然后在返回行时将其转换回日期时间对象。

__初始化__ T0> ( T1> 时区=假 T2> ) T3> ¶ T4>

构建一个新的DateTime

参数: timezone - 布尔值。如果为True,并由后端支持,则会产生“TIMESTAMP WITH TIMEZONE”。对于不支持时区感知时间戳的后端,不起作用。
class sqlalchemy.types。 Enum * enums**千瓦 T5> ) T6> ¶ T7>

基础:sqlalchemy.types.Stringsqlalchemy.types.SchemaType

通用枚举类型。

Enum类型提供了该列所限制的一组可能的字符串值。

如果可用的话,Enum类型将使用后端的本地“ENUM”类型;否则,它使用一个VARCHAR数据类型并产生一个CHECK约束。可以使用Enum.native_enum标志禁止使用后端本机枚举类型,并且可以使用Enum.create_constraint标志来配置CHECK约束的生成。

Enum类型还提供对输入值和数据库返回值的Python验证。对于任何不在给定的可能值列表中的Python值,都会引发LookupError

在版本1.1中改变:现在,Enum类型提供输入值的Python验证以及数据库返回的数据。

枚举值的来源可能是字符串值列表,或者是符合PEP-435标准的枚举类。对于Enum数据类型,这个类只需要提供一个__members__方法。

当使用枚举类时,枚举对象既用于输入又用于输出,而不是像普通字符串枚举类型那样使用字符串:

import enum
class MyEnum(enum.Enum):
    one = "one"
    two = "two"
    three = "three"


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

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

版本1.1中的新功能: - 支持PEP-435风格的枚举类。

也可以看看

ENUM - PostgreSQL-specific type, which has additional functionality.

__init__(*enums, **kw)

构造一个枚举。

不适用于特定后端的关键字参数将被该后端忽略。

参数:
  • * enums -

    或者只是一个符合PEP-435的枚举类型或一个或多个字符串或枚举枚举标签。如果存在unicode标签,则convert_unicode标志是自动启用的。

    版本1.1中的新功能:可以传递一个PEP-435风格的枚举类。

  • convert_unicode – Enable unicode-aware bind parameter and result-set processing for this Enum’s data. 这是根据unicode标签字符串的存在自动设置的。
  • create_constraint -

    默认为True。在创建非本机枚举类型时,还要根据有效值在数据库上构建一个CHECK约束。

    版本1.1中的新增功能: - 添加了Enum.create_constraint,它提供了禁止为非本机枚举类型生成CHECK约束的选项。

  • metadata – Associate this type directly with a MetaData object. 对于作为独立模式构造(Postgresql)存在于目标数据库上的类型,将在create_all()drop_all()操作中创建并删除此类型。如果该类型不与任何MetaData对象相关联,则它将自己与其使用的每个Table相关联,并且将在创建任何这些单独表时创建,检查之后是否存在。但是,只有在为该Table对象的元数据调用drop_all()时,才会删除该类型。
  • name – The name of this type. 这是Postgresql和任何未来支持的需要明确指定类型的数据库或明确指定的约束来生成类型和/或使用它的表所必需的。如果使用PEP-435枚举类,则默认使用其名称(转换为小写)。
  • native_enum – Use the database’s native ENUM type when available. 默认为True。False时,对所有后端使用VARCHAR +检查约束。
  • 模式 -

    此类型的架构名称。对于作为独立模式构造(Postgresql)存在于目标数据库上的类型,此参数指定存在类型的命名模式。

    注意

    Enum类型的schema不默认使用在Table上建立的schema如果需要这种行为,请将inherit_schema标志设置为True

  • quote – Set explicit quoting preferences for the type’s name.
  • inherit_schema – When True, the “schema” from the owning Table will be copied to the “schema” attribute of this Enum, replacing whatever value was passed for the schema attribute. 这在使用Table.tometadata()操作时也会生效。
  • validate_strings -

    当为真时,无效的字符串值将被验证并且不被允许通过。

    版本1.1.0b2中的新功能

create(bind=None, checkfirst=False)
inherited from the create() method of SchemaType

为此类型发行创建ddl(如果适用)。

drop(bind=None, checkfirst=False)
inherited from the drop() method of SchemaType

为此类型发行DROP ddl(如果适用)。

class sqlalchemy.types.Float(precision=None, asdecimal=False, decimal_return_scale=None, **kwargs)

基础:sqlalchemy.types.Numeric

表示浮点类型的类型,例如FLOATREAL

除非Float.asdecimal标志设置为True,否则这个类型默认返回Python float对象,在这种情况下,它们被强制转换为decimal.Decimal

注意

Float类型被设计为接收来自明确已知为浮点类型的数据库类型的数据(例如,FLOATREAL,其他)而不是十进制类型(例如DECIMALNUMERIC,其他)。If the database column on the server is in fact a Numeric type, such as DECIMAL or NUMERIC, use the Numeric type or a subclass, otherwise numeric coercion between float/Decimal may or may not function as expected.

__init__(precision=None, asdecimal=False, decimal_return_scale=None, **kwargs)

构建一个浮动。

参数:
  • precision – the numeric precision for use in DDL CREATE TABLE.
  • asdecimal – the same flag as that of Numeric, but defaults to False. 请注意,将此标志设置为True会导致浮点转换。
  • decimal_return_scale -

    从浮点数转换为Python小数时使用的默认缩放比例。由于十进制的不准确性,浮点值通常会长得多,而且大多数浮点数据库类型没有“scale”的概念,所以默认情况下float类型在转换时会查找前十个小数位。指定此值将覆盖该长度。请注意,如果未指定,那么包含“scale”的MySQL浮点类型将使用“scale”作为decimal_return_scale的默认值。

    版本0.9.0中新增。

  • ** kwargs - 不建议使用。这里的其他参数被默认的Float类型忽略。对于支持额外参数的特定于数据库的浮点数,请参阅该方言的文档以获取详细信息,例如sqlalchemy.dialects.mysql.FLOAT
class sqlalchemy.types。 整数

基础:sqlalchemy.types._DateAffinitysqlalchemy.types.TypeEngine

一个用于int整数的类型。

class sqlalchemy.types.Interval(native=True, second_precision=None, day_precision=None)

基础:sqlalchemy.types._DateAffinitysqlalchemy.types.TypeDecorator

一个用于datetime.timedelta()对象的类型。

Interval类型处理datetime.timedelta对象。在PostgreSQL中,使用本地的INTERVAL类型;对于其他人来说,价值被存储为相对于“时代”(1970年1月1日)的日期。

请注意,Interval类型目前不在本机不支持间隔类型的平台上提供日期算术运算。这样的操作通常需要将表达式的两侧(例如,首先将两侧转换为整数时间值)转换为当前手动过程(例如通过func)。

__ init __ native = Truesecond_precision = Noneday_precision = None ) T5> ¶ T6>

构造一个间隔对象。

参数:
  • native – when True, use the actual INTERVAL type provided by the database, if supported (currently Postgresql, Oracle). 否则,无论如何将间隔数据表示为历元值。
  • second_precision – For native interval types which support a “fractional seconds precision” parameter, i.e. Oracle and Postgresql
  • day_precision – for native interval types which support a “day precision” parameter, i.e. Oracle.
coerce_compared_value opvalue

请参阅TypeEngine.coerce_compared_value()了解说明。

IMPL T0> ¶ T1>

DateTime的别名

class sqlalchemy.types.LargeBinary(length=None)

基础:sqlalchemy.types._Binary

大型二进制字节数据的类型。

The LargeBinary type corresponds to a large and/or unlengthed binary type for the target platform, such as BLOB on MySQL and BYTEA for Postgresql. 它还处理DBAPI的必要转换。

__初始化__ T0> ( T1> 长度=无 T2> ) T3> ¶ T4>

构建一个LargeBinary类型。

参数:length – optional, a length for the column for use in DDL statements, for those binary types that accept a length, such as the MySQL BLOB type.
class sqlalchemy.types.MatchType(create_constraint=True, name=None, _create_events=True)

基础:sqlalchemy.types.Boolean

指MATCH运算符的返回类型。

As the ColumnOperators.match() is probably the most open-ended operator in generic SQLAlchemy Core, we can’t assume the return type at SQL evaluation time, as MySQL returns a floating point, not a boolean, and other backends might do something different. 所以这个类型作为一个占位符,目前是继承Boolean该类型允许方言根据需要注入结果处理功能,而MySQL将返回浮点值。

版本1.0.0中的新功能

class sqlalchemy.types.Numeric(precision=None, scale=None, decimal_return_scale=None, asdecimal=True)

基础:sqlalchemy.types._DateAffinitysqlalchemy.types.TypeEngine

一种用于固定精度数字的类型,如NUMERICDECIMAL

除非Numeric.asdecimal标志设置为False,否则这个类型默认返回Python decimal.Decimal对象,在这种情况下,它们被强制转换为Python float

注意

Numeric类型被设计为从明确知道是十进制类型的数据库类型(例如DECIMALNUMERIC等)接收数据。而不是浮点类型(例如FLOAT, REAL, others). If the database column on the server is in fact a floating-point type type, such as FLOAT or REAL, use the Float type or a subclass, otherwise numeric coercion between float/Decimal may or may not function as expected.

注意

Python decimal.Decimal类通常运行缓慢; cPython 3.3现在已经切换到本地使用cdecimal库。对于较老的Python版本,可以将cdecimal库修补到任何将完全替换decimal库的应用程序中,但是这需要在全局范围内应用,并且在任何其他模块被导入,如下所示:

import sys
import cdecimal
sys.modules["decimal"] = cdecimal

Note that the cdecimal and decimal libraries are not compatible with each other, so patching cdecimal at the global level is the only way it can be used effectively with various DBAPIs that hardcode to import the decimal library.

__init__(precision=None, scale=None, decimal_return_scale=None, asdecimal=True)

构建一个数字。

参数:
  • precision – the numeric precision for use in DDL CREATE TABLE.
  • scale – the numeric scale for use in DDL CREATE TABLE.
  • asdecimal - 默认为True。返回值是否应该作为Python十进制对象或浮点数发送。不同的DBAPI根据数据类型发送一个或另一个 - 数字类型将确保返回值是DBAPI中的一个或另一个始终如一。
  • decimal_return_scale -

    从浮点数转换为Python小数时使用的默认缩放比例。由于十进制的不准确性,浮点值通常会长得多,而且大多数浮点数据库类型没有“scale”的概念,所以默认情况下float类型在转换时会查找前十个小数位。指定此值将覆盖该长度。包含明确的“.scale”值的类型,比如base Numeric以及MySQL浮点类型,将使用“.scale”的值作为decimal_return_scale的默认值,否则指定。

    版本0.9.0中新增。

在使用Numeric类型时,应注意确保asdecimal设置适用于正在使用的DBAPI - 当Numeric应用从Decimal-> float或float-> Decimal的转换时,此转换会发生所有结果列的额外性能开销。

原生返回Decimal的DBAPI(例如psycopg2)将具有更好的准确性和更高的性能,设置为True,因为本地转换为Decimal减少了浮点问题的数量,本身不需要进一步转换。However, another DBAPI which returns floats natively will incur an additional conversion overhead, and is still subject to floating point data loss - in which case asdecimal=False will at least remove the extra conversion overhead.

class sqlalchemy.types.PickleType(protocol=2, pickler=None, comparator=None)

基础:sqlalchemy.types.TypeDecorator

包含使用pickle序列化的Python对象。

PickleType建立在二进制类型之上,用于将Python的pickle.dumps()应用于传入对象,pickle.loads()允许任何可选择的Python对象存储为序列化的二进制字段。

要允许ORM更改事件传播与PickleType关联的元素,请参阅Mutation Tracking

__init__(protocol=2, pickler=None, comparator=None)

构建一个PickleType。

参数:
  • 协议 - 默认为pickle.HIGHEST_PROTOCOL
  • pickler – defaults to cPickle.pickle or pickle.pickle if cPickle is not available. 可以是与pickle兼容的任何对象dumps ``loads方法。
  • comparator – a 2-arg callable predicate used to compare values of this type. 如果保留为None,则使用Python“equals”运算符来比较值。
IMPL T0> ¶ T1>

LargeBinary的别名

class sqlalchemy.types。 SchemaType name = None= Nonemetadata = Noneinherit_schema = Falsequote =无_create_events = True ) T10> ¶ T11>

基础:sqlalchemy.sql.expression.SchemaEventTarget

将某个类型标记为可能需要使用架构级别的DDL。

支持必须显式创建/删除的类型(即PG ENUM类型)以及由表或模式级别约束,触发器和其他规则所赞扬的类型。

SchemaType classes can also be targets for the DDLEvents.before_parent_attach() and DDLEvents.after_parent_attach() events, where the events fire off surrounding the association of the type object with a parent Column.

也可以看看

Enum

Boolean

adapt(impltype, **kw)
结合 T0> ¶ T1>
复制 T0> ( T1> **千瓦 T2> ) T3> ¶ T4>
create(bind=None, checkfirst=False)

为此类型发行创建ddl(如果适用)。

drop(bind=None, checkfirst=False)

为此类型发行DROP ddl(如果适用)。

class sqlalchemy.types。 SmallInteger

基础:sqlalchemy.types.Integer

一个更小的int整数的类型。

通常在DDL中生成一个SMALLINT,否则就像在Python一边正常的Integer一样。

class sqlalchemy.types.String(length=None, collation=None, convert_unicode=False, unicode_error=None, _warn_on_bytestring=False)

基础:sqlalchemy.types.Concatenablesqlalchemy.types.TypeEngine

所有字符串和字符类型的基础。

在SQL中,对应于VARCHAR。也可以采用Python unicode对象,并在绑定参数中对数据库的编码进行编码(结果集反过来)。

当在CREATE TABLE语句中使用String类型时,通常需要长度字段,因为VARCHAR在大多数数据库上需要长度。

__init__(length=None, collation=None, convert_unicode=False, unicode_error=None, _warn_on_bytestring=False)

创建一个字符串保存类型。

参数:
  • length – optional, a length for the column for use in DDL and CAST expressions. 如果没有CREATE TABLE将被发布,可以安全地省略。某些数据库可能需要用于DDL的length,并且在CREATE TABLE DDL时会引发异常如果包含没有长度的VARCHAR,则发布。值是否被解释为字节或字符是数据库特定的。
  • 整理 -

    可选,用于DDL和CAST表达式的列级别排序规则。呈现使用SQLite,MySQL和Postgresql支持的COLLATE关键字。例如。:

    >>> from sqlalchemy import cast, select, String
    >>> print select([cast('some string', String(collation='utf8'))])
    SELECT CAST(:param_1 AS VARCHAR COLLATE utf8) AS anon_1

    0.8版新增:增加了对所有字符串类型的COLLATE支持。

  • convert_unicode -

    设置为True时,String类型将假定输入将作为Python unicode对象传递,结果以Python unicode对象。If the DBAPI in use does not support Python unicode (which is fewer and fewer these days), SQLAlchemy will encode/decode the value, using the value of the encoding parameter passed to create_engine() as the encoding.

    当使用本地支持Python unicode对象的DBAPI时,通常不需要设置此标志。For columns that are explicitly intended to store non-ASCII data, the Unicode or UnicodeText types should be used regardless, which feature the same behavior of convert_unicode but also indicate an underlying column type that directly supports unicode, such as NVARCHAR.

    For the extremely rare case that Python unicode is to be encoded/decoded by SQLAlchemy on a backend that does natively support Python unicode, the value force can be passed here which will cause SQLAlchemy’s encode/decode services to be used unconditionally.

  • unicode_error - 可选,用于处理Unicode转换错误的方法。行为就像标准库的string.decode()函数的errors关键字参数。此标志要求将convert_unicode设置为force - 否则,SQLAlchemy不能保证处理unicode转换的任务。请注意,此标志为已经返回unicode对象的后端(大多数DBAPI所做的)的行取回操作增加了显着的性能开销。这个标志只能作为从不同的或损坏的编码列读取字符串的最后手段。
class sqlalchemy.types.Text(length=None, collation=None, convert_unicode=False, unicode_error=None, _warn_on_bytestring=False)

基础:sqlalchemy.types.String

一个可变大小的字符串类型。

在SQL中,通常对应于CLOB或TEXT。也可以采用Python unicode对象,并在绑定参数中对数据库的编码进行编码(结果集反过来)。一般来说,TEXT对象没有长度;而一些数据库在这里会接受一个长度的参数,它会被别人拒绝。

class sqlalchemy.types.Time(timezone=False)

基础:sqlalchemy.types._DateAffinitysqlalchemy.types.TypeEngine

datetime.time()对象的类型。

class sqlalchemy.types。 Unicode length = None* * kwargs T5> ) T6> ¶ T7>

基础:sqlalchemy.types.String

一个可变长度的Unicode字符串类型。

The Unicode type is a String subclass that assumes input and output as Python unicode data, and in that regard is equivalent to the usage of the convert_unicode flag with the String type. 但是,与plain String不同,它也意味着显式支持非ASCII数据的基础列类型,例如Oracle和SQL Server上的NVARCHARThis can impact the output of CREATE TABLE statements and CAST functions at the dialect level, and can also affect the handling of bound parameters in some specific DBAPI scenarios.

The encoding used by the Unicode type is usually determined by the DBAPI itself; most modern DBAPIs feature support for Python unicode objects as bound values and result set values, and the encoding should be configured as detailed in the notes for the target DBAPI in the Dialects section.

对于不支持或未配置为直接容纳Python unicode对象的DBAPI,SQLAlchemy将在DBAPI之外进行编码和解码。这种情况下的编码由传递给create_engine()encoding标志决定。

当使用Unicode类型时,仅适用于传递Python unicode对象,而不是str如果在Python 2下传递一个普通的str,则会发出警告。如果您注意到您的应用程序发出了这些警告,但您不确定它们的来源,请参阅http://docs.python.org/library/warnings上的Python warnings过滤器。 .html可以用来将这些警告转化为例外,它们将说明一个堆栈跟踪:

import warnings
warnings.simplefilter('error')

对于希望将纯字节串和Python unicode对象同等传递给Unicode类型的应用程序,必须先将字节串解码为unicode。Coercing Encoded Strings to Unicode的配方说明了这是如何完成的。

也可以看看:

UnicodeText - 与Unicode不相符的文本对应。
__init__(length=None, **kwargs)

创建一个Unicode对象。

参数与String相同,除了convert_unicode默认为True

class sqlalchemy.types。 UnicodeText length = None* * kwargs T5> ) T6> ¶ T7>

基础:sqlalchemy.types.Text

无限长的Unicode字符串类型。

有关此对象的Unicode特性的详细信息,请参阅Unicode

Unicode一样,使用UnicodeText类型意味着在后端使用了一个支持unicode的类型,例如NCLOBNTEXT

__init__(length=None, **kwargs)

创建一个Unicode转换文本类型。

参数与Text的参数相同,但convert_unicode默认为True

SQL标准和多个供应商类型

这种类型的类型是指作为SQL标准的一部分的类型,或者可能在数据库后端的子集中找到的类型。Unlike the “generic” types, the SQL standard/multi-vendor types have no guarantee of working on all backends, and will only work on those backends that explicitly support them by name. 也就是说,类型将始终使用CREATE TABLE命令在DDL中发出确切的名称。

class sqlalchemy.types。 ARRAY item_typeas_tuple = False dimensions = None,zero_indexes = False

基础:sqlalchemy.types.Indexablesqlalchemy.types.Concatenablesqlalchemy.types.TypeEngine

表示一个SQL数组类型。

注意

这种类型是所有ARRAY操作的基础。但是,目前只有Postgresql后端支持SQLAlchemy中的SQL数组。建议在使用PostgreSQL的ARRAY类型时直接使用postgresql.ARRAY类型,因为它提供了特定于该后端的其他运算符。

types.ARRAY是Core的一部分,支持各种SQL标准函数,如显式涉及数组的array_agg然而,除PostgreSQL后端和可能的一些第三方方言外,没有其他的SQLAlchemy内置方言支持这种类型。

一个types.ARRAY类型是根据元素的“类型”构造的:

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

上面的类型表示一个N维数组,意味着支持的后端(如Postgresql)将自动解释具有任意数量的维度的值。为了生成一个传入一维整数数组的INSERT构造:

connection.execute(
        mytable.insert(),
        data=[1,2,3]
)

types.ARRAY类型可以给定固定数量的维度来构造:

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

发送多个维度是可选的,但建议如果数据类型要表示多个维度的数组。这个数字用于:

  • 当向数据库发送类型声明本身时,例如INTEGER[][]

  • 将Python值转换为数据库值时,反之亦然一个Unicode对象的ARRAY使用此数字来高效地访问数组结构中的字符串值,而不需要依靠每行类型检查

  • 当与Python getitem访问器一起使用时,维数用于定义[]运算符应返回的类型的类型。对于具有两个维度的INTEGER的ARRAY:

    >>> expr = table.c.column[5]  # returns ARRAY(Integer, dimensions=1)
    >>> expr = expr[6]  # returns Integer

对于一维数组,一个没有维度参数的types.ARRAY实例通常会假设一维行为。

类型types.ARRAY的SQL表达式支持“索引”和“切片”行为。Python []运算符在这里正常工作,给定整数索引或切片。数组默认为基于1的索引。运算符生成二进制表达式结构,这将为SELECT语句生成适当的SQL:

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

以及使用Update.values()方法时的UPDATE语句:

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

types.ARRAY类型还为运算符types.ARRAY.Comparator.any()types.ARRAY.Comparator.all()PostgreSQL特定版本的types.ARRAY也提供了额外的操作符。

版本1.1.0新增

也可以看看

postgresql.ARRAY

class Comparator expr

基础:sqlalchemy.types.Comparatorsqlalchemy.types.Comparator

定义types.ARRAY的比较操作。

这种类型的方言特定形式提供了更多的操作符。请参阅postgresql.ARRAY.Comparator

all otheroperator = None t5 >

返回其他 运算符 所有 (数组)子句。

参数的地方被切换,因为ALL要求数组表达式在右侧。

例如。:

from sqlalchemy.sql import operators

conn.execute(
    select([table.c.data]).where(
            table.c.data.all(7, operator=operators.lt)
        )
)
参数:
  • 其他 - 要比较的表达式
  • operator – an operator object from the sqlalchemy.sql.operators package, defaults to operators.eq().
其他运营商=无 t5 >

返回其他 运算符 ANY (数组)子句。

参数的地方被切换,因为ANY要求数组表达式在右边。

例如。:

from sqlalchemy.sql import operators

conn.execute(
    select([table.c.data]).where(
            table.c.data.any(7, operator=operators.lt)
        )
)
参数:
  • 其他 - 要比较的表达式
  • operator – an operator object from the sqlalchemy.sql.operators package, defaults to operators.eq().
ARRAY tt> item_typeas_tuple = False尺寸=无zero_indexes = False

构建一个types.ARRAY

例如。:

Column('myarray', ARRAY(Integer))

参数是:

参数:
  • item_type – The data type of items of this array. 请注意,这里的维度是不相关的,因此像INTEGER[][]这样的多维数组被构造为ARRAY(Integer),而不是ARRAY(ARRAY(Integer))等等。
  • as_tuple=False – Specify whether return results should be converted to tuples from lists. 这个参数通常不需要,因为Python列表对应于一个SQL数组。
  • dimensions – if non-None, the ARRAY will assume a fixed number of dimensions. 这会影响数组在数据库中的声明方式,如何解释Python和结果值,以及与“getitem”运算符一起工作的表达式行为。有关更多详细信息,请参阅types.ARRAY中的说明。
  • zero_indexes=False – when True, index values will be converted between Python zero-based and SQL one-based indexes, e.g. a value of one will be added to all index values before passing to the database.
ARRAY。 T0> comparator_factory T1> ¶ T2>

Comparator的别名

ARRAY。 zero_indexes = False

如果为True,则Python基于零的索引应该被解释为基于SQL表达式一方。

class sqlalchemy.types。 BIGINT

基础:sqlalchemy.types.BigInteger

SQL BIGINT类型。

class sqlalchemy.types。 BINARY / T5> ¶ T6>

基础:sqlalchemy.types._Binary

SQL BINARY类型。

class sqlalchemy.types.BLOB(length=None)

基础:sqlalchemy.types.LargeBinary

SQL BLOB类型。

class sqlalchemy.types.BOOLEAN(create_constraint=True, name=None, _create_events=True)

基础:sqlalchemy.types.Boolean

SQL BOOLEAN类型。

class sqlalchemy.types.CHAR(length=None, collation=None, convert_unicode=False, unicode_error=None, _warn_on_bytestring=False)

基础:sqlalchemy.types.String

SQL CHAR类型。

class sqlalchemy.types.CLOB(length=None, collation=None, convert_unicode=False, unicode_error=None, _warn_on_bytestring=False)

基础:sqlalchemy.types.Text

CLOB类型。

这种类型可以在Oracle和Informix中找到。

class sqlalchemy.types。 DATE

基础:sqlalchemy.types.Date

SQL DATE类型。

class sqlalchemy.types.DATETIME(timezone=False)

基础:sqlalchemy.types.DateTime

SQL DATETIME类型。

class sqlalchemy.types.DECIMAL(precision=None, scale=None, decimal_return_scale=None, asdecimal=True)

基础:sqlalchemy.types.Numeric

SQL DECIMAL类型。

class sqlalchemy.types.FLOAT(precision=None, asdecimal=False, decimal_return_scale=None, **kwargs)

基础:sqlalchemy.types.Float

SQL FLOAT类型。

sqlalchemy.types。 T0> INT T1> ¶ T2>

INTEGER的别名

class sqlalchemy.types。 JSON none_as_null = False / T5> ¶ T6>

基础:sqlalchemy.types.Indexablesqlalchemy.types.TypeEngine

表示一个SQL JSON类型。

注意

types.JSON作为特定于供应商的JSON类型的外观提供。由于它支持JSON SQL操作,因此它只能在具有实际JSON类型的后端(当前Postgresql以及某些版本的MySQL)上工作。

types.JSON是Core的一部分,支持原生JSON数据类型日益普及。

types.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"}
    )

基础types.JSON提供了这两个操作:

  • 键控索引操作:

    data_table.c.data['some key']
  • 整数索引操作:

    data_table.c.data[3]
  • 路径索引操作:

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

额外的操作可以从types.JSON特定于方言的版本,如postgresql.JSONpostgresql.JSONB更多的操作员,而不仅仅是基本类型

索引操作默认返回一个默认类型为JSON的表达式对象,以便在结果类型上调用更多的面向JSON的指令。

当与SQLAlchemy ORM一起使用时,JSON类型不检测结构的就地突变。为了检测这些,必须使用sqlalchemy.ext.mutable扩展名。这种扩展将允许对数据结构进行“原地”更改,以产生将由工作单元检测到的事件。请参阅HSTORE中的示例,了解一个涉及字典的简单示例。

在使用NULL值时,JSON类型建议使用两个特定的常量来区分求值为SQL NULL的列,例如没有值,与"null"要插入或选择一个值为SQL NULL的值,请使用常量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"The Python value None may be used in conjunction with either JSON.NULL and null() in order to indicate NULL values, but care must be taken as to the value of the JSON.none_as_null in these cases.

版本1.1中的新功能

class Comparator expr

基础:sqlalchemy.types.Comparatorsqlalchemy.types.Comparator

定义types.JSON的比较操作。

class JSON。 JSONIndexType

基础:sqlalchemy.types.TypeEngine

JSON索引值的数据类型的占位符。

这允许执行时处理JSON索引值以获得特殊的语法。

class JSON。 JSONPathType

基础:sqlalchemy.types.TypeEngine

JSON路径操作的占位符类型。

这允许将基于路径的索引值执行时处理成特定的SQL语法。

JSON tt> NULL =符号('JSON_NULL')

描述NULL的json值。

该值用于强制使用"null"的JSON值作为值。根据JSON.none_as_null标志的设置,Python None的值将被识别为SQL NULL或JSON "null"无论此设置如何,都可以使用JSON.NULL常量来解析为JSON "null"这与sql.null()结构形成对比,该结构始终解析为SQL NULL。例如。:

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

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

session.add_all([obj1, obj2])
session.commit()
JSON。 T0> __初始化__ T1> ( T2> none_as_null =假 T3> ) T4> ¶ T5 >

构造一个types.JSON类型。

参数: none_as_null = False -

如果为True,则将None值保留为SQL NULL值,而不是null的JSON编码。请注意,如果此标志为False,则仍然可以使用null()构造来保留NULL值:

from sqlalchemy import null
conn.execute(table.insert(), data=null())

也可以看看

types.JSON.NULL

JSON。 T0> comparator_factory T1> ¶ T2>

Comparator的别名

class sqlalchemy.types。 INTEGER

基础:sqlalchemy.types.Integer

SQL INT或INTEGER类型。

class sqlalchemy.types。 NCHAR length = None* * kwargs T5> ) T6> ¶ T7>

基础:sqlalchemy.types.Unicode

SQL NCHAR类型。

class sqlalchemy.types。 NVARCHAR length = None* * kwargs T5> ) T6> ¶ T7>

基础:sqlalchemy.types.Unicode

SQL NVARCHAR类型。

class sqlalchemy.types.NUMERIC(precision=None, scale=None, decimal_return_scale=None, asdecimal=True)

基础:sqlalchemy.types.Numeric

SQL NUMERIC类型。

class sqlalchemy.types.REAL(precision=None, asdecimal=False, decimal_return_scale=None, **kwargs)

基础:sqlalchemy.types.Float

SQL REAL类型。

class sqlalchemy.types。 SMALLINT

基础:sqlalchemy.types.SmallInteger

SQL SMALLINT类型。

class sqlalchemy.types.TEXT(length=None, collation=None, convert_unicode=False, unicode_error=None, _warn_on_bytestring=False)

基础:sqlalchemy.types.Text

SQL TEXT类型。

class sqlalchemy.types.TIME(timezone=False)

基础:sqlalchemy.types.Time

SQL TIME类型。

class sqlalchemy.types.TIMESTAMP(timezone=False)

基础:sqlalchemy.types.DateTime

SQL TIMESTAMP类型。

class sqlalchemy.types.VARBINARY(length=None)

基础:sqlalchemy.types._Binary

SQL VARBINARY类型。

class sqlalchemy.types.VARCHAR(length=None, collation=None, convert_unicode=False, unicode_error=None, _warn_on_bytestring=False)

基础:sqlalchemy.types.String

SQL VARCHAR类型。

供应商特定类型

数据库特定类型也可用于从每个数据库的方言模块导入。请参阅您感兴趣的数据库的Dialects参考。

例如,MySQL有一个BIGINT类型,而PostgreSQL有一个INET类型。要使用这些,请明确从模块中导入它们:

from sqlalchemy.dialects import mysql

table = Table('foo', metadata,
    Column('id', mysql.BIGINT),
    Column('enumerates', mysql.ENUM('a', 'b', 'c'))
)

或者一些PostgreSQL类型:

from sqlalchemy.dialects import postgresql

table = Table('foo', metadata,
    Column('ipaddress', postgresql.INET),
    Column('elements', postgresql.ARRAY(String))
)

每个方言在__ all __集合中都提供了该后端支持的全部类型名称,所以简单的import *或类似的将导入所有支持的类型,

from sqlalchemy.dialects.postgresql import *

t = Table('mytable', metadata,
           Column('id', INTEGER, primary_key=True),
           Column('name', VARCHAR(300)),
           Column('inetaddr', INET)
)

如上所述,INTEGER和VARCHAR类型最终来自sqlalchemy.types,INET特定于Postgresql方言。

一些方言级别类型与SQL标准类型具有相同的名称,但也提供了其他参数。例如,MySQL实现了包括附加参数(如collat​​ioncharset)在内的所有字符和字符串类型:

from sqlalchemy.dialects.mysql import VARCHAR, TEXT

table = Table('foo', meta,
    Column('col1', VARCHAR(200, collation='binary')),
    Column('col2', TEXT(charset='latin1'))
)