SqlAlchemy 2.0 中文文档（四十九）（2）

SqlAlchemy 2.0 中文文档（四十九）（1）https://developer.aliyun.com/article/1563026

MySQL SQL 构造

class sqlalchemy.dialects.mysql.match

生成一个 MATCH (X, Y) AGAINST ('TEXT') 子句。

例如：

from sqlalchemy import desc
from sqlalchemy.dialects.mysql import match
match_expr = match(
    users_table.c.firstname,
    users_table.c.lastname,
    against="Firstname Lastname",
)
stmt = (
    select(users_table)
    .where(match_expr.in_boolean_mode())
    .order_by(desc(match_expr))
)

将生成类似于 SQL 的代码：

SELECT id, firstname, lastname
FROM user
WHERE MATCH(firstname, lastname) AGAINST (:param_1 IN BOOLEAN MODE)
ORDER BY MATCH(firstname, lastname) AGAINST (:param_2) DESC

match() 函数是所有 SQL 表达式可用的 ColumnElement.match() 方法的独立版本，与使用 ColumnElement.match() 时一样，但允许传递多个列。

参数：

• cols – 要匹配的列表达式
  
• against – 要比较的表达式
  
• in_boolean_mode – 布尔值，将“布尔模式”设置为 true
  
• in_natural_language_mode – 布尔值，将“自然语言”设置为 true
  
• with_query_expansion – 布尔值，将“查询扩展”设置为 true
  

从版本 1.4.19 开始。

另请参阅

ColumnElement.match()

成员

in_boolean_mode(), in_natural_language_mode(), inherit_cache, with_query_expansion()

类签名

类 sqlalchemy.dialects.mysql.match (sqlalchemy.sql.expression.Generative, sqlalchemy.sql.expression.BinaryExpression)。

method in_boolean_mode() → Self

对 MATCH 表达式应用“IN BOOLEAN MODE”修饰符。

返回：

一个新的 match 实例，应用了修改。

method in_natural_language_mode() → Self

对 MATCH 表达式应用“IN NATURAL LANGUAGE MODE”修饰符。

返回：

一个新的 match 实例，应用了修改。

attribute inherit_cache: bool | None = True

指示此 HasCacheKey 实例是否应该使用其直接超类使用的缓存密钥生成方案。

此属性默认为 None，表示构造尚未考虑其是否适合参与缓存；这在功能上等同于将值设置为 False，但还会发出警告。

如果 SQL 与对象对应的属性不基于该类本身的属性而变化，并且不是基于其超类，则可以在特定类上设置此标志为True。

另请参阅

启用自定义构造的缓存支持 - 设置第三方或用户定义的 SQL 构造的 HasCacheKey.inherit_cache 属性的一般指南。

method with_query_expansion() → Self

对 MATCH 表达式应用 “WITH QUERY EXPANSION” 修饰符。

返回：

一个具有应用修改的新 match 实例。

MySQL 数据类型

与所有 SQLAlchemy 方言一样，已知与 MySQL 兼容的所有大写类型都可以从顶级方言导入：

from sqlalchemy.dialects.mysql import (
    BIGINT,
    BINARY,
    BIT,
    BLOB,
    BOOLEAN,
    CHAR,
    DATE,
    DATETIME,
    DECIMAL,
    DECIMAL,
    DOUBLE,
    ENUM,
    FLOAT,
    INTEGER,
    LONGBLOB,
    LONGTEXT,
    MEDIUMBLOB,
    MEDIUMINT,
    MEDIUMTEXT,
    NCHAR,
    NUMERIC,
    NVARCHAR,
    REAL,
    SET,
    SMALLINT,
    TEXT,
    TIME,
    TIMESTAMP,
    TINYBLOB,
    TINYINT,
    TINYTEXT,
    VARBINARY,
    VARCHAR,
    YEAR,
)

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

class sqlalchemy.dialects.mysql.BIGINT

MySQL 的 BIGINTEGER 类型。

成员

init()

类签名

类 sqlalchemy.dialects.mysql.BIGINT（sqlalchemy.dialects.mysql.types._IntegerType，sqlalchemy.types.BIGINT）

method __init__(display_width=None, **kw)

构造一个 BIGINTEGER。

参数：

• display_width – 可选项，此数字的最大显示宽度。
  
• unsigned – 一个布尔值，可选项。
  
• zerofill – 可选项。如果为 true，则值将作为左填充零的字符串存储。请注意，这不会影响底层数据库 API 返回的值，它们仍然是数字。
  

class sqlalchemy.dialects.mysql.BINARY

SQL 的 BINARY 类型。

类签名

类 sqlalchemy.dialects.mysql.BINARY（sqlalchemy.types._Binary）

class sqlalchemy.dialects.mysql.BIT

MySQL 的 BIT 类型。

此类型适用于 MySQL 5.0.3 或更高版本的 MyISAM，以及 5.0.5 或更高版本的 MyISAM，MEMORY，InnoDB 和 BDB。对于较旧的版本，请使用 MSTinyInteger() 类型。

成员

init()

类签名

类 sqlalchemy.dialects.mysql.BIT（sqlalchemy.types.TypeEngine）

method __init__(length=None)

构造一个 BIT。

参数：

length – 可选项，位数。

class sqlalchemy.dialects.mysql.BLOB

SQL 的 BLOB 类型。

类签名

类 sqlalchemy.dialects.mysql.BLOB（sqlalchemy.types.LargeBinary）

method __init__(length: int | None = None)

继承自 LargeBinary 的 sqlalchemy.types.LargeBinary.__init__ 方法

构造一个 LargeBinary 类型。

参数：

length – 可选项，在 DDL 语句中用于列的长度，对于那些接受长度的二进制类型，比如 MySQL 的 BLOB 类型。

class sqlalchemy.dialects.mysql.BOOLEAN

SQL 的 BOOLEAN 类型。

类签名

类 sqlalchemy.dialects.mysql.BOOLEAN（sqlalchemy.types.Boolean）

method __init__(create_constraint: bool = False, name: str | None = None, _create_events: bool = True, _adapted_from: SchemaType | None = None)

继承自 Boolean 的 sqlalchemy.types.Boolean.__init__ 方法

构造一个布尔值。

参数：

• create_constraint –
  默认为 False。如果布尔值生成为 int/smallint，则还在表上创建一个 CHECK 约束，以确保值为 1 或 0。
  注意
  强烈建议 CHECK 约束具有显式名称，以支持模式管理问题。这可以通过设置 Boolean.name 参数或设置适当的命名约定来实现；有关背景信息，请参阅配置约束命名约定。
  从版本 1.4 开始更改：- 此标志现在默认为 False，意味着对非本地枚举类型不生成 CHECK 约束。
  
• name – 如果生成 CHECK 约束，则指定约束的名称。
  

class sqlalchemy.dialects.mysql.CHAR

MySQL CHAR 类型，用于固定长度字符数据。

成员

init()

类签名

类 sqlalchemy.dialects.mysql.CHAR (sqlalchemy.dialects.mysql.types._StringType, sqlalchemy.types.CHAR)

method __init__(length=None, **kwargs)

构造一个 CHAR。

参数：

• length – 最大数据长度，以字符为单位。
  
• binary – 可选项，使用国家字符集的默认二进制排序。这不影响存储的数据类型，对于二进制数据，请使用 BINARY 类型。
  
• collation – 可选项，请求特定的排序规则。必须与国家字符集兼容。
  

class sqlalchemy.dialects.mysql.DATE

SQL DATE 类型。

类签名

类 sqlalchemy.dialects.mysql.DATE (sqlalchemy.types.Date)

class sqlalchemy.dialects.mysql.DATETIME

MySQL DATETIME 类型。

成员

init()

类签名

类 sqlalchemy.dialects.mysql.DATETIME (sqlalchemy.types.DATETIME)

method __init__(timezone=False, fsp=None)

构造一个 MySQL DATETIME 类型。

参数：

• timezone – MySQL 方言不使用。
  
• fsp –
  小数秒精度值。MySQL 5.6.4 支持存储小数秒；在为 DATETIME 类型生成 DDL 时将使用此参数。
  注意
  对于小数秒的 DBAPI 驱动程序支持可能有限；当前支持包括 MySQL Connector/Python。
  

class sqlalchemy.dialects.mysql.DECIMAL

MySQL DECIMAL 类型。

成员

init()

类签名

类 sqlalchemy.dialects.mysql.DECIMAL (sqlalchemy.dialects.mysql.types._NumericType, sqlalchemy.types.DECIMAL)

method __init__(precision=None, scale=None, asdecimal=True, **kw)

构造 DECIMAL。

参数：

• precision – 此数字中的总位数。如果 scale 和 precision 都为 None，则值存储到服务器允许的限制。
  
• scale – 小数点后的位数。
  
• unsigned – 一个布尔值，可选的。
  
• zerofill – 可选的。 如果为真，则值将作为左填充零的字符串存储。 请注意，这不影响底层数据库 API 返回的值，后者仍然是数字。
  

class sqlalchemy.dialects.mysql.DOUBLE

MySQL DOUBLE 类型。

类签名

类 sqlalchemy.dialects.mysql.DOUBLE (sqlalchemy.dialects.mysql.types._FloatType, sqlalchemy.types.DOUBLE)

method __init__(precision=None, scale=None, asdecimal=True, **kw)

构造一个 DOUBLE。

注意

DOUBLE 类型默认将浮点数转换为 Decimal，使用默认为 10 位的截断。 指定 scale=n 或 decimal_return_scale=n 以更改此比例，或指定 asdecimal=False 以直接将值返回为 Python 浮点数。

参数：

• precision – 此数字中的总位数。 如果比例和精度都是无，则值将存储到服务器允许的限制。
  
• scale – 小数点后的位数。
  
• unsigned – 一个布尔值，可选的。
  
• zerofill – 可选的。 如果为真，则值将作为左填充零的字符串存储。 请注意，这不影响底层数据库 API 返回的值，后者仍然是数字。
  

class sqlalchemy.dialects.mysql.ENUM

MySQL ENUM 类型。

成员

init()

类签名

类 sqlalchemy.dialects.mysql.ENUM (sqlalchemy.types.NativeForEmulated, sqlalchemy.types.Enum, sqlalchemy.dialects.mysql.types._StringType)

method __init__(*enums, **kw)

构造一个 ENUM。

例如：

Column('myenum', ENUM("foo", "bar", "baz"))

参数：

• enums –
  此 ENUM 的有效值范围。 在枚举中的值不带引号，生成模式时将被转义并用单引号括起来。 此对象还可以是符合 PEP-435 的枚举类型。
  
• strict –
  此标志不起作用。
  版本中更改：MySQL ENUM 类型以及基本 Enum 类型现在验证所有 Python 数据值。
  
• charset – 可选的，用于此字符串值的列级字符集。 优先于 ‘ascii’ 或 ‘unicode’ 简写。
  
• collation – 可选的，用于此字符串值的列级排序。 优先于 ‘binary’ 简写。
  
• ascii – 默认为 False：latin1 字符集的简写，生成模式中的 ASCII。
  
• unicode – 默认为 False：ucs2 字符集的简写，生成模式中的 UNICODE。
  
• binary – 默认为 False：简写，选择与列的字符集匹配的二进制排序类型。 在模式中生成 BINARY。 这不影响存储的数据类型，只影响字符数据的排序。
  

class sqlalchemy.dialects.mysql.FLOAT

MySQL FLOAT 类型。

成员

init()

类签名

类sqlalchemy.dialects.mysql.FLOAT（sqlalchemy.dialects.mysql.types._FloatType，sqlalchemy.types.FLOAT)。

method __init__(precision=None, scale=None, asdecimal=False, **kw)

构造一个 FLOAT。

参数：

• precision – 此数字中的总位数。如果 scale 和 precision 都为 None，则将值存储到服务器允许的限制。
  
• scale – 小数点后的数字位数。
  
• unsigned – 一个布尔值，可选。
  
• zerofill – 可选。如果为 true，则值将作为左填充零的字符串存储。请注意，这不会影响底层数据库 API 返回的值，这些值仍然是数值型的。
  

class sqlalchemy.dialects.mysql.INTEGER

MySQL 的 INTEGER 类型。

成员

init()

类签名

类sqlalchemy.dialects.mysql.INTEGER（sqlalchemy.dialects.mysql.types._IntegerType，sqlalchemy.types.INTEGER）。

method __init__(display_width=None, **kw)

构造一个 INTEGER。

参数：

• display_width – 可选，此数字的最大显示宽度。
  
• unsigned – 一个布尔值，可选。
  
• zerofill – 可选。如果为 true，则值将作为左填充零的字符串存储。请注意，这不会影响底层数据库 API 返回的值，这些值仍然是数值型的。
  

class sqlalchemy.dialects.mysql.JSON

MySQL 的 JSON 类型。

从 5.7 版本开始，MySQL 支持 JSON。从 10.2 版本开始，MariaDB 支持 JSON（作为 LONGTEXT 的别名）。

JSON在针对 MySQL 或 MariaDB 后端使用基本的JSON数据类型时会自动使用。

另请参阅

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

JSON类型支持将 JSON 值持久化，以及通过适应操作在数据库级别呈现JSON_EXTRACT函数所提供的核心索引操作。

类签名

类sqlalchemy.dialects.mysql.JSON（sqlalchemy.types.JSON）。

class sqlalchemy.dialects.mysql.LONGBLOB

MySQL 的 LONGBLOB 类型，用于二进制数据长达 2³² 字节。

类签名

类sqlalchemy.dialects.mysql.LONGBLOB（sqlalchemy.types._Binary）。

class sqlalchemy.dialects.mysql.LONGTEXT

MySQL 的 LONGTEXT 类型，用于存储编码长达 2³² 字节的字符。

成员

init()

类签名

class sqlalchemy.dialects.mysql.LONGTEXT (sqlalchemy.dialects.mysql.types._StringType)

method __init__(**kwargs)

构建一个 LONGTEXT。

参数：

• charset – 可选，该字符串值的列级字符集。优先于 ‘ascii’ 或 ‘unicode’ 简写。
  
• collation – 可选，该字符串值的列级排序规则。优先于 ‘binary’ 简写。
  
• ascii – 默认为 False：latin1 字符集的简写，在模式中生成 ASCII。
  
• unicode – 默认为 False：ucs2 字符集的简写，在模式中生成 UNICODE。
  
• national – 可选。如果为真，则使用服务器配置的国家字符集。
  
• binary – 默认为 False：简写，选择与列字符集匹配的二进制排序规则类型。在模式中生成 BINARY。这不影响存储的数据类型，只影响字符数据的排序规则。
  

class sqlalchemy.dialects.mysql.MEDIUMBLOB

MySQL MEDIUMBLOB 类型，用于最多 2²⁴ 字节的二进制数据。

类签名

class sqlalchemy.dialects.mysql.MEDIUMBLOB (sqlalchemy.types._Binary)

class sqlalchemy.dialects.mysql.MEDIUMINT

MySQL MEDIUMINTEGER 类型。

成员

init()

类签名

class sqlalchemy.dialects.mysql.MEDIUMINT (sqlalchemy.dialects.mysql.types._IntegerType)

method __init__(display_width=None, **kw)

构建一个 MEDIUMINTEGER

参数：

• display_width – 可选，此数字的最大显示宽度。
  
• unsigned – 一个布尔值，可选。
  
• zerofill – 可选。如果为真，则将值存储为左填充的带零字符串。请注意，这不会影响底层数据库 API 返回的值，这些值仍然是数字。
  

class sqlalchemy.dialects.mysql.MEDIUMTEXT

MySQL MEDIUMTEXT 类型，用于最多编码 2²⁴ 字节的字符存储。

成员

init()

类签名

class sqlalchemy.dialects.mysql.MEDIUMTEXT (sqlalchemy.dialects.mysql.types._StringType)

method __init__(**kwargs)

构建一个 MEDIUMTEXT。

参数：

• charset – 可选，该字符串值的列级字符集。优先于 ‘ascii’ 或 ‘unicode’ 简写。
  
• collation – 可选，该字符串值的列级排序规则。优先于 ‘binary’ 简写。
  
• ascii – 默认为 False：latin1 字符集的简写，在模式中生成 ASCII。
  
• unicode – 默认为 False：ucs2 字符集的简写，在模式中生成 UNICODE。
  
• national – 可选。如果为真，则使用服务器配置的国家字符集。
  
• binary – 默认为 False：简写，选择与列字符集匹配的二进制排序规则类型。在模式中生成 BINARY。这不影响存储的数据类型，只影响字符数据的排序规则。
  

class sqlalchemy.dialects.mysql.NCHAR

MySQL NCHAR 类型。

对于服务器配置的国家字符集中的固定长度字符数据。

成员

init()

类签名

类 sqlalchemy.dialects.mysql.NCHAR (sqlalchemy.dialects.mysql.types._StringType, sqlalchemy.types.NCHAR)

method __init__(length=None, **kwargs)

构造一个 NCHAR。

参数：

• length – 最大数据长度，以字符为单位。
  
• binary – 可选的，使用默认的二进制排序规则进行国家字符集。这不影响存储的数据类型，对于二进制数据，请使用 BINARY 类型。
  
• collation – 可选的，请求特定的排序规则。必须与国家字符集兼容。
  

class sqlalchemy.dialects.mysql.NUMERIC

MySQL NUMERIC 类型。

成员

init()

类签名

类 sqlalchemy.dialects.mysql.NUMERIC (sqlalchemy.dialects.mysql.types._NumericType, sqlalchemy.types.NUMERIC)

method __init__(precision=None, scale=None, asdecimal=True, **kw)

构造一个 NUMERIC。

参数：

• precision – 此数字中的总位数。如果比例和精度都为 None，则将值存储到服务器允许的限制。
  
• scale – 小数点后的位数。
  
• unsigned – 一个布尔值，可选的。
  
• zerofill – 可选的。如果为真，则值将存储为左边用零填充的字符串。请注意，这不会影响底层数据库 API 返回的值，该值仍为数字。
  

class sqlalchemy.dialects.mysql.NVARCHAR

MySQL NVARCHAR 类型。

对于服务器配置的国家字符集中的可变长度字符数据。

成员

init()

类签名

类 sqlalchemy.dialects.mysql.NVARCHAR (sqlalchemy.dialects.mysql.types._StringType, sqlalchemy.types.NVARCHAR)

method __init__(length=None, **kwargs)

构造一个 NVARCHAR。

参数：

• length – 最大数据长度，以字符为单位。
  
• binary – 可选的，使用默认的二进制排序规则进行国家字符集。这不影响存储的数据类型，对于二进制数据，请使用 BINARY 类型。
  
• collation – 可选的，请求特定的排序规则。必须与国家字符集兼容。
  

class sqlalchemy.dialects.mysql.REAL

MySQL REAL 类型。

成员

init()

类签名

类 sqlalchemy.dialects.mysql.REAL (sqlalchemy.dialects.mysql.types._FloatType, sqlalchemy.types.REAL)

method __init__(precision=None, scale=None, asdecimal=True, **kw)

构造一个 REAL。

注意

默认情况下，REAL类型从浮点数转换为 Decimal，使用默认为 10 位的截断。指定scale=n或decimal_return_scale=n以更改此比例，或者asdecimal=False以直接将值返回为 Python 浮点数。

参数：

• precision – 此数字中的总位数。如果比例和精度都为 None，则值将存储到服务器允许的限制。
  
• scale – 小数点后的位数。
  
• unsigned – 一个布尔值，可选。
  
• zerofill – 可选。如果为 true，则值将存储为左侧填充零的字符串。请注意，这不会影响底层数据库 API 返回的值，它们仍然是数值。
  

class sqlalchemy.dialects.mysql.SET

MySQL SET 类型。

成员

init()

类签名

类sqlalchemy.dialects.mysql.SET (sqlalchemy.dialects.mysql.types._StringType)

method __init__(*values, **kw)

构造一个 SET。

例如：

Column('myset', SET("foo", "bar", "baz"))

在这种情况下，潜在值的列表是必需的，因为此集合将用于为表生成 DDL，或者如果设置了SET.retrieve_as_bitwise标志。

参数：

• values – 此 SET 的有效值范围。这些值不带引号，生成模式时将被转义并用单引号括起。
  
• convert_unicode – 与String.convert_unicode相同的标志。
  
• collation – 与String.collation相同
  
• charset – 与VARCHAR.charset相同。
  
• ascii – 与VARCHAR.ascii相同。
  
• unicode – 与VARCHAR.unicode相同。
  
• binary – 与VARCHAR.binary相同。
  
• retrieve_as_bitwise –
  如果为 True，则集合类型的数据将使用整数值持久化和选择，其中集合被强制转换为持久化的位掩码。MySQL 允许这种模式，它的优势在于能够明确存储值，例如空字符串''。数据类型将在 SELECT 语句中显示为表达式col + 0，以便将值强制转换为结果集中的整数值。如果希望持久化可以存储空字符串''作为值的集合，则需要此标志。
  警告
  在使用SET.retrieve_as_bitwise时，必须确保集合值的列表与 MySQL 数据库中的完全相同的顺序。
  

class sqlalchemy.dialects.mysql.SMALLINT

MySQL SMALLINTEGER 类型。

成员

init()的初始化方法。

类签名

类sqlalchemy.dialects.mysql.SMALLINT（sqlalchemy.dialects.mysql.types._IntegerType，sqlalchemy.types.SMALLINT）

method __init__(display_width=None, **kw)

构造一个 SMALLINTEGER。

参数：

• display_width – 可选，此数字的最大显示宽度。
  
• unsigned – 一个布尔值，可选。
  
• zerofill – 可选。如果为 true，值将以左侧填充零的字符串形式存储。请注意，这不会影响底层数据库 API 返回的值，其仍然是数值。
  

class sqlalchemy.dialects.mysql.TEXT

MySQL TEXT 类型，用于编码最多 2¹⁶ 字节的字符存储。

类签名

类sqlalchemy.dialects.mysql.TEXT（sqlalchemy.dialects.mysql.types._StringType，sqlalchemy.types.TEXT）

method __init__(length=None, **kw)

构造一个 TEXT。

参数：

• length – 可选，如果提供，服务器可以通过替换足以存储length字节字符的最小 TEXT 类型来优化存储。
  
• charset – 可选，用于此字符串值的列级字符集。优先于‘ascii’或‘unicode’简写。
  
• collation – 可选，用于此字符串值的列级排序。优先于‘binary’简写。
  
• ascii – 默认为 False：latin1字符集的简写，生成模式中的 ASCII。
  
• unicode – 默认为 False：ucs2字符集的简写，生成模式中的 UNICODE。
  
• national – 可选。如果为 true，则使用服务器配置的国家字符集。
  
• binary – 默认为 False：简写，选择与列的字符集匹配的二进制排序类型。在模式中生成 BINARY。这不会影响存储的数据类型，只会影响字符数据的排序。
  

class sqlalchemy.dialects.mysql.TIME

MySQL TIME 类型。

成员

init()的初始化方法。

类签名

类sqlalchemy.dialects.mysql.TIME（sqlalchemy.types.TIME）

method __init__(timezone=False, fsp=None)

构造一个 MySQL TIME 类型。

参数：

• timezone – MySQL 方言不使用。
  
• fsp –
  分数秒精度值。MySQL 5.6 支持存储分数秒；在为 TIME 类型发出 DDL 时将使用此参数。
  注意
  DBAPI 驱动程序对分数秒的支持可能有限；当前支持包括 MySQL Connector/Python。
  

class sqlalchemy.dialects.mysql.TIMESTAMP

MySQL TIMESTAMP 类型。

成员

init()的初始化方法。

类签名

类 sqlalchemy.dialects.mysql.TIMESTAMP (sqlalchemy.types.TIMESTAMP)

method __init__(timezone=False, fsp=None)

构造一个 MySQL TIMESTAMP 类型。

参数：

• timezone – MySQL 方言不使用。
  
• fsp –
  小数秒精度值。MySQL 5.6.4 支持存储小数秒；在为 TIMESTAMP 类型发出 DDL 时将使用此参数。
  注意
  DBAPI 驱动程序对小数秒的支持可能有限；当前支持包括 MySQL Connector/Python。
  

class sqlalchemy.dialects.mysql.TINYBLOB

MySQL TINYBLOB 类型，用于最多 2⁸ 字节的二进制数据。

类签名

类 sqlalchemy.dialects.mysql.TINYBLOB (sqlalchemy.types._Binary)

class sqlalchemy.dialects.mysql.TINYINT

MySQL TINYINT 类型。

成员

init()

类签名

类 sqlalchemy.dialects.mysql.TINYINT (sqlalchemy.dialects.mysql.types._IntegerType)

method __init__(display_width=None, **kw)

构造一个 TINYINT。

参数：

• display_width – 可选，此数字的最大显示宽度。
  
• unsigned – 一个布尔值，可选。
  
• zerofill – 可选。如果为 true，则值将作为左填充零的字符串存储。请注意，这不影响底层数据库 API 返回的值，其仍然是数值。
  

class sqlalchemy.dialects.mysql.TINYTEXT

MySQL TINYTEXT 类型，用于编码最多 2⁸ 字节的字符存储。

成员

init()

类签名

类 sqlalchemy.dialects.mysql.TINYTEXT (sqlalchemy.dialects.mysql.types._StringType)

method __init__(**kwargs)

构造一个 TINYTEXT。

参数：

• charset – 可选，此字符串值的列级字符集。优先于 ‘ascii’ 或 ‘unicode’ 简写。
  
• collation – 可选，此字符串值的列级排序规则。优先于 ‘binary’ 简写。
  
• ascii – 默认为 False：latin1 字符集的简写，在模式中生成 ASCII。
  
• unicode – 默认为 False：ucs2 字符集的简写，在模式中生成 UNICODE。
  
• national – 可选。如果为 true，则使用服务器配置的国家字符集。
  
• binary – 默认为 False：简写，选择与列的字符集匹配的二进制排序类型。在模式中生成 BINARY。这不影响存储的数据类型，只影响字符数据的排序。
  

class sqlalchemy.dialects.mysql.VARBINARY

SQL VARBINARY 类型。

类签名

类 sqlalchemy.dialects.mysql.VARBINARY (sqlalchemy.types._Binary)

class sqlalchemy.dialects.mysql.VARCHAR

MySQL VARCHAR 类型，用于可变长度字符数据。

成员

init()

类签名

类sqlalchemy.dialects.mysql.VARCHAR（sqlalchemy.dialects.mysql.types._StringType，sqlalchemy.types.VARCHAR）

method __init__(length=None, **kwargs)

构造一个 VARCHAR。

参数：

• charset – 可选，用于此字符串值的列级字符集。优先于‘ascii’或‘unicode’简写。
  
• collation – 可选，用于此字符串值的列级排序。优先于‘binary’简写。
  
• ascii – 默认为 False：latin1字符集的简写，模式中生成 ASCII。
  
• unicode – 默认为 False：ucs2字符集的简写，模式中生成 UNICODE。
  
• national – 可选。如果为 true，则使用服务器配置的国家字符集。
  
• binary – 默认为 False：简写，选择与列的字符集匹配的二进制排序类型。在模式中生成 BINARY。这不影响存储的数据类型，只影响字符数据的排序。
  

class sqlalchemy.dialects.mysql.YEAR

MySQL YEAR 类型，用于存储 1901-2155 年的单字节。

类签名

类sqlalchemy.dialects.mysql.YEAR（sqlalchemy.types.TypeEngine）

MySQL DML 构造

function sqlalchemy.dialects.mysql.insert(table: _DMLTableArgument) → Insert

构造一个 MySQL/MariaDB 特定变体Insert构造。

sqlalchemy.dialects.mysql.insert()函数创建一个sqlalchemy.dialects.mysql.Insert。这个类基于方言不可知的Insert构造，可以使用 SQLAlchemy Core 中的insert()函数构造。

Insert构造包括额外的方法Insert.on_duplicate_key_update()。

class sqlalchemy.dialects.mysql.Insert

MySQL 特定的 INSERT 实现。

添加了针对 MySQL 特定语法的方法，例如 ON DUPLICATE KEY UPDATE。

使用 sqlalchemy.dialects.mysql.insert() 函数创建 Insert 对象。

版本 1.2 中的新功能。

成员

inherit_cache, inserted, on_duplicate_key_update()

类签名

class sqlalchemy.dialects.mysql.Insert (sqlalchemy.sql.expression.Insert)

attribute inherit_cache: bool | None = False

指示此 HasCacheKey 实例是否应使用其直接超类使用的缓存密钥生成方案。

该属性默认为 None，表示构造尚未考虑是否适合参与缓存; 这在功能上等同于将值设置为 False，除了还会发出警告。

如果与对象对应的 SQL 不基于此类的本地属性而更改，并且不基于其超类，则可以在特定类上将此标志设置为 True。

另请参见

为自定义构造启用缓存支持 - 设置第三方或用户定义的 SQL 构造的 HasCacheKey.inherit_cache 属性的一般指南。

attribute inserted

为 ON DUPLICATE KEY UPDATE 语句提供“inserted”命名空间

MySQL 的 ON DUPLICATE KEY UPDATE 子句允许引用将要插入的行，通过一个称为 VALUES() 的特殊函数。 此属性提供了此行中的所有列，以便它们可在 ON DUPLICATE KEY UPDATE 子句中的 VALUES() 函数内部引用。 属性被命名为 .inserted，以避免与现有的 Insert.values() 方法冲突。

提示

Insert.inserted 属性是 ColumnCollection 的实例，其提供了与 访问表和列中描述的 Table.c 集合相同的接口。使用此集合，普通名称可以像属性一样访问（例如 stmt.inserted.some_column），但特殊名称和字典方法名称应使用索引访问，例如 stmt.inserted["column name"] 或 stmt.inserted["values"]。有关更多示例，请参阅 ColumnCollection 的文档字符串。

请参阅

插入…在重复键更新（Upsert）时 - 使用 Insert.inserted 的示例

method on_duplicate_key_update(*args: Mapping[Any, Any] | List[Tuple[str, Any]] | ColumnCollection[Any, Any], **kw: Any) → Self

指定 ON DUPLICATE KEY UPDATE 子句。

参数：

**kw – 与 UPDATE 值关联的列键。这些值可以是任何 SQL 表达式或支持的字面 Python 值。

警告

此字典不考虑 Python 指定的默认 UPDATE 值或生成函数，例如使用 Column.onupdate 指定的值。这些值不会被用于 ON DUPLICATE KEY UPDATE 类型的 UPDATE，除非在此手动指定值。

参数：

*args –

作为传递键/值参数的替代方案，可以将字典或 2 元组列表作为单个位置参数传递。

传递单个字典等效于关键字参数形式：

insert().on_duplicate_key_update({"name": "some name"})

传递 2 元组列表表示 UPDATE 子句中的参数分配应按发送的顺序排序，类似于参数有序更新中总体描述的 Update 构造：

insert().on_duplicate_key_update(
    [("name", "some name"), ("value", "some value")])

版本 1.3 中的更改：参数可以指定为字典或 2 元组列表；后一种形式提供了参数排序。

版本 1.2 中的新功能。

请参阅

插入…在重复键更新（Upsert）时

mysqlclient（MySQL-Python 的分支）

通过 mysqlclient（MySQL-Python 的维护分支）驱动程序支持 MySQL / MariaDB 数据库。

DBAPI

mysqlclient（MySQL-Python 的维护分支）的文档和下载信息（如果适用）可在此处找到：pypi.org/project/mysqlclient/

连接

连接字符串：

mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>

驱动程序状态

mysqlclient DBAPI 是不再维护的 MySQL-Python DBAPI 的一个维护的分支。mysqlclient 支持 Python 2 和 Python 3，并且非常稳定。

Unicode

有关当前关于 Unicode 处理的建议，请参阅 Unicode。### SSL 连接

mysqlclient 和 PyMySQL DBAPIs 接受一个额外的字典，其键为“ssl”，可以使用 create_engine.connect_args 字典来指定：

engine = create_engine(
    "mysql+mysqldb://scott:tiger@192.168.0.134/test",
    connect_args={
        "ssl": {
            "ca": "/home/gord/client-ssl/ca.pem",
            "cert": "/home/gord/client-ssl/client-cert.pem",
            "key": "/home/gord/client-ssl/client-key.pem"
        }
    }
)

为了方便起见，以下键也可以内联指定在 URL 中，它们将被自动解释为“ssl”字典： “ssl_ca”、“ssl_cert”、“ssl_key”、“ssl_capath”、“ssl_cipher”、“ssl_check_hostname”。示例如下：

connection_uri = (
    "mysql+mysqldb://scott:tiger@192.168.0.134/test"
    "?ssl_ca=/home/gord/client-ssl/ca.pem"
    "&ssl_cert=/home/gord/client-ssl/client-cert.pem"
    "&ssl_key=/home/gord/client-ssl/client-key.pem"
)

另请参阅

在 PyMySQL 方言中的 SSL 连接

使用 MySQLdb 与 Google Cloud SQL

Google Cloud SQL 现在建议使用 MySQLdb 方言。使用如下 URL 进行连接：

mysql+mysqldb://root@/<dbname>?unix_socket=/cloudsql/<projectid>:<instancename>

服务器端游标

mysqldb 方言支持服务器端游标。请参阅 服务器端游标。## PyMySQL

通过 PyMySQL 驱动程序支持 MySQL / MariaDB 数据库。

DBAPI

PyMySQL 的文档和下载信息（如果适用）可在以下链接获取：pymysql.readthedocs.io/

连接

连接字符串：

mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]

Unicode

有关当前关于 Unicode 处理的建议，请参阅 Unicode。

SSL 连接

PyMySQL DBAPI 接受与 MySQLdb 相同的 SSL 参数，描述如 SSL 连接。请参阅该部分以获取其他示例。

如果服务器使用自动生成的自签名证书或与主机名不匹配（从客户端看），则在 PyMySQL 中也可能需要指示 ssl_check_hostname=false：

connection_uri = (
    "mysql+pymysql://scott:tiger@192.168.0.134/test"
    "?ssl_ca=/home/gord/client-ssl/ca.pem"
    "&ssl_cert=/home/gord/client-ssl/client-cert.pem"
    "&ssl_key=/home/gord/client-ssl/client-key.pem"
    "&ssl_check_hostname=false"
)

MySQL-Python 兼容性

pymysql DBAPI 是 MySQL-python（MySQLdb）驱动程序的纯 Python 移植版本，目标是 100%  的兼容性。大多数针对 MySQL-python 的行为说明也适用于 pymysql 驱动程序。## MariaDB-Connector

通过 MariaDB Connector/Python 驱动程序支持 MySQL / MariaDB 数据库。

DBAPI

MariaDB Connector/Python 的文档和下载信息（如果适用）可在以下链接获取：pypi.org/project/mariadb/

连接

连接字符串：

mariadb+mariadbconnector://<user>:<password>@<host>[:<port>]/<dbname>

驱动程序状态

MariaDB Connector/Python 允许 Python 程序使用与 Python DB API  2.0（PEP-249）兼容的 API 访问 MariaDB 和 MySQL 数据库。它是用 C 编写的，使用 MariaDB  Connector/C 客户端库进行客户端服务器通信。

注意 mariadb:// 连接 URI 的默认驱动程序仍然是 mysqldb。要使用此驱动程序，需要使用 mariadb+mariadbconnector://。## MySQL-Connector

通过 MySQL Connector/Python 驱动程序支持 MySQL / MariaDB 数据库。

SqlAlchemy 2.0 中文文档（四十九）（3）https://developer.aliyun.com/article/1563029