MySQL¶

Support for the MySQL database.

数据库接口支持

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

支持的版本和功能

从4.1版到现代版本,SQLAlchemy支持MySQL。但是,对于主要的丢失的SQL特性,没有采取英雄式的措施来解决——例如,如果您的服务器版本不支持子选择,那么它们也不会在SQLAlchemy中工作。

有关任何给定服务器版本中支持的功能的详细信息,请参阅官方mysql文档。

连接超时和断开

MySQL有一个自动的连接关闭行为,用于固定时间空闲的连接,默认为8小时。要避免出现此问题,请使用 create_engine.pool_recycle 选项,确保连接在池中存在固定秒数时将被丢弃并替换为新连接:

engine = create_engine('mysql+mysqldb://...', pool_recycle=3600)

为了更全面地检测池连接的断开连接,包括适应服务器重启和网络问题,可以采用预ping方法。见 处理断开连接 对于目前的方法。

参见

处理断开连接 -了解处理超时连接和数据库重新启动的几种技术。

创建包含存储引擎的表参数

mysql的create table语法包含大量的特殊选项,包括 ENGINECHARSETMAX_ROWSROW_FORMATINSERT_METHOD 以及更多。要适应这些参数的呈现,请指定表单 mysql_argument_name="value" . 例如,指定带有 ENGINE 属于 InnoDBCHARSET 属于 utf8mb4KEY_BLOCK_SIZE 属于 1024 ::

Table('mytable', metadata,
      Column('data', String(32)),
      mysql_engine='InnoDB',
      mysql_charset='utf8mb4',
      mysql_key_block_size="1024"
     )

MySQL方言通常会传输指定为 mysql_keyword_name 将呈现为 KEYWORD_NAMECREATE TABLE 语句。这些名称中的一小部分将用空格而不是下划线呈现;为了支持这一点,MySQL方言了解这些特定的名称,其中包括 DATA DIRECTORY (例如) mysql_data_directoryCHARACTER SET (例如) mysql_character_setINDEX DIRECTORY (例如) mysql_index_directory

最常见的论点是 mysql_engine ,表示表的存储引擎。在历史上,MySQL服务器安装默认为 MyISAM 对于该值,尽管较新版本可能默认为 InnoDB . 这个 InnoDB 引擎通常优先用于支持事务和外键。

A Table 在mysql数据库中创建,存储引擎为 MyISAM 基本上是非事务性的,这意味着引用此表的任何插入/更新/删除语句都将作为自动提交调用。它也不支持外键约束;而 CREATE TABLE 语句在使用 MyISAM 存储引擎将丢弃这些参数。反射这样的表也不会产生外键约束信息。

对于完全原子事务以及对外键约束的支持,所有参与 CREATE TABLE 语句必须指定一个事务引擎,在大多数情况下, InnoDB .

参见

The InnoDB Storage Engine -在MySQL网站上。

区分大小写和表反射

基于底层操作系统的特定细节,MySQL对区分大小写的标识符名称的支持不一致。然而,已经观察到,无论存在什么区分大小写的行为,外键声明中的表的名称都是 总是 从数据库接收的所有小写字母,使其无法准确反映相关表使用混合大小写标识符名称的模式。

因此,强烈建议将表名声明为所有小写,包括在SQLAlchemy内以及在mysql数据库本身上,特别是在要使用数据库反射功能的情况下。

事务隔离级别

所有MySQL方言都支持通过方言特定参数设置事务隔离级别。 create_engine.isolation_level 被接受 create_engine() 以及 Connection.execution_options.isolation_level 传递给的参数 Connection.execution_options() . 此功能通过发出命令来工作 SET SESSION TRANSACTION ISOLATION LEVEL <level> 对于每个新连接。对于特殊的自动提交隔离级别,使用DBAPI特定的技术。

要设置隔离级别,请使用 create_engine() ::

engine = create_engine(
                "mysql://scott:tiger@localhost/test",
                isolation_level="READ UNCOMMITTED"
            )

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

connection = engine.connect()
connection = connection.execution_options(
    isolation_level="READ COMMITTED"
)

的有效值 isolation_level 包括:

特殊 AUTOCOMMIT 值利用特定dbapis提供的各种“autocommit”属性,目前由mysqldb、mysql client、mysql connector python和pymysql支持。使用它,mysql连接的值将返回true。 SELECT @@autocommit; .

1.1 新版功能: -增加了对自动提交隔离级别的支持。

自动增量行为

创建表时,SQLAlchemy将自动设置 AUTO_INCREMENT 论第一 Integer 未标记为外键的主键列::

>>> t = Table('mytable', metadata,
...   Column('mytable_id', Integer, primary_key=True)
... )
>>> t.create()
CREATE TABLE mytable (
        id INTEGER NOT NULL AUTO_INCREMENT,
        PRIMARY KEY (id)
)

可以通过传递禁用此行为 Falseautoincrement 的参数 Column . 此标志还可用于对某些存储引擎启用多列键中的辅助列的自动增量:

Table('mytable', metadata,
      Column('gid', Integer, primary_key=True, autoincrement=False),
      Column('id', Integer, primary_key=True)
     )

服务器端光标

服务器端光标支持mysqldb和pymysql方言。从MySQL的角度来看,这意味着 MySQLdb.cursors.SSCursorpymysql.cursors.SSCursor 类在构建将接收结果的光标时使用。调用此功能的最典型方法是通过 Connection.execution_options.stream_results 连接执行选项。通过传递,还可以无条件地为所有select语句启用服务器端游标。 server_side_cursors=Truecreate_engine() .

1.1.4 新版功能: -添加了服务器端光标支持。

统一码

字符集选择

大多数mysql dbapis都提供了为连接设置客户机字符集的选项。通常使用 charset URL中的参数,例如:

e = create_engine(
    "mysql+pymysql://scott:tiger@localhost/test?charset=utf8mb4")

这个字符集是 客户端字符集 用于连接。一些mysql dbapis会将其默认为 latin1 有些人会利用 default-character-set 设置在 my.cnf 也要归档。对于特定的行为,应该参考正在使用的DBAPI的文档。

传统上用于Unicode的编码是 'utf8' . 但是,对于forward上的MySQL5.5.3版本,一种新的特定于MySQL的编码 'utf8mb4' 已经引入,从MySQL8.0开始,如果是普通的,服务器将发出警告 utf8 在任何服务器端指令中指定,替换为 utf8mb3 . 这种新编码的基本原理是由于MySQL的传统UTF-8编码只支持最多三个字节而不是四个字节的代码点。因此,当与一个mysql数据库通信时,如果数据库和客户机DBAPI都支持这个新的字符集,那么这个新的字符集是首选的,如:

e = create_engine(
    "mysql+pymysql://scott:tiger@localhost/test?charset=utf8mb4")

所有现代DBAPI都应该支持 utf8mb4 字符集

为了使用 utf8mb4 使用旧版创建的架构的编码 utf8 ,可能需要更改MySQL架构和/或服务器配置。

参见

The utf8mb4 Character Set -在mysql文档中

处理二进制数据警告和Unicode

MySQL 5.6、5.7及更高版本(撰写本文时不是Mariadb)现在在尝试将二进制数据传递到数据库时发出警告,而当二进制数据本身对该编码无效时,字符集编码也已就位:

default.py:509: Warning: (1300, "Invalid utf8mb4 character string:
'F9876A'")
  cursor.execute(statement, parameters)

此警告是由于MySQL客户端库试图将二进制字符串解释为Unicode对象,即使数据类型如 LargeBinary 正在使用中。要解决此问题,SQL语句要求二进制“character set introducer”出现在呈现为以下形式的任何非空值之前:

INSERT INTO table (data) VALUES (_binary %s)

这些字符集介绍器是由DBAPI驱动程序提供的,假定使用mysqlclient或pymysql(建议使用这两种方法)。添加查询字符串参数 binary_prefix=true 到修复此警告的URL::

# mysqlclient
engine = create_engine(
    "mysql+mysqldb://scott:tiger@localhost/test?charset=utf8mb4&binary_prefix=true")

# PyMySQL
engine = create_engine(
    "mysql+pymysql://scott:tiger@localhost/test?charset=utf8mb4&binary_prefix=true")

这个 binary_prefix 其他MySQL驱动程序可能支持标志,也可能不支持标志。

SQLAlchemy本身无法呈现此 _binary 前缀可靠,因为它不与空值一起工作,空值有效,可以作为绑定参数发送。当mysql驱动程序将参数直接呈现到SQL字符串中时,它是传递这个额外关键字的最有效的地方。

参见

Character set introducers -在MySQL网站上

ANSI引用样式

MySQL有两种标识符“引用样式”,一种使用反勾号,另一种使用引号,例如 `some_identifier “VS”。 "some_identifier" . 所有mysql方言都通过检查 sql_mode 当一个连接与一个特定的 Engine . 这种引用样式在呈现表名和列名以及反映现有数据库结构时发挥作用。这种检测是完全自动的,使用任何一种引用样式都不需要特殊的配置。

MySQL SQL扩展

许多MySQL SQL扩展都是通过SQLAlchemy的通用函数和运算符支持来处理的:

table.select(table.c.password==func.md5('plaintext'))
table.select(table.c.username.op('regexp')('^[a-d]'))

当然,任何有效的mysql语句也可以作为字符串执行。

目前,对SQL的mysql扩展提供了一些有限的直接支持。

在重复密钥更新时插入…(向上插入)

mysql允许通过 ON DUPLICATE KEY UPDATE 条款 INSERT 语句。只有当候选行与表中现有的主键或唯一键不匹配时,才会插入该行;否则,将执行更新。该语句允许分别指定要插入的值和要更新的值。

SQLAlchemy提供 ON DUPLICATE KEY UPDATE 通过特定于MySQL的支持 mysql.dml.insert() 函数,提供生成方法 on_duplicate_key_update() ::

from sqlalchemy.dialects.mysql import insert

insert_stmt = insert(my_table).values(
    id='some_existing_id',
    data='inserted value')

on_duplicate_key_stmt = insert_stmt.on_duplicate_key_update(
    data=insert_stmt.inserted.data,
    status='U'
)

conn.execute(on_duplicate_key_stmt)

与postgresql的“on conflict”短语不同,“on duplicate key update”短语将始终与任何主键或唯一键匹配,并且在匹配的情况下始终执行更新;它没有引发错误或跳过执行更新的选项。

ON DUPLICATE KEY UPDATE 用于执行已存在行的更新,使用新值和建议插入的值的任意组合。这些值通常使用传递给 on_duplicate_key_update() 给定的列键值(通常是列的名称,除非它指定 Column.key )作为键和文本或SQL表达式作为值::

on_duplicate_key_stmt = insert_stmt.on_duplicate_key_update(
    data="some data",
    updated_at=func.current_timestamp(),
)

以类似于 UpdateBase.values() ,可接受其他参数形式,包括单个字典:

on_duplicate_key_stmt = insert_stmt.on_duplicate_key_update(
    {"data": "some data", "updated_at": func.current_timestamp()},
)

以及一个2元组列表,它将以类似于中描述的方式自动提供参数顺序更新语句。 参数顺序更新 . 不像 Update 对象,不需要特殊标志来指定意图,因为参数形式是此上下文明确的::

on_duplicate_key_stmt = insert_stmt.on_duplicate_key_update(
    [
        ("data", "some data"),
        ("updated_at", func.current_timestamp()),
    ],
)

在 1.3 版更改: 在mysql中支持参数有序更新子句,进行重复的密钥更新

警告

这个 Insert.on_duplicate_key_update() 方法做 not 考虑到python端的默认更新值或生成函数,例如使用 Column.onupdate . 除非在参数中显式指定了这些值,否则不会对on-duplicate key样式的更新执行这些值。

为了引用建议的插入行,特殊别名 inserted 在上作为属性提供 mysql.dml.Insert 对象;此对象是 ColumnCollection 其中包含目标表的所有列:

from sqlalchemy.dialects.mysql import insert

stmt = insert(my_table).values(
    id='some_id',
    data='inserted value',
    author='jlh')
do_update_stmt = stmt.on_duplicate_key_update(
    data="updated value",
    author=stmt.inserted.author
)
conn.execute(do_update_stmt)

呈现时,“插入的”命名空间将生成表达式 VALUES(<columnname>) .

1.2 新版功能: 在重复的key update子句上添加了对mysql的支持

行数支持

SQLAlchemy标准化DBAPI cursor.rowcount 属性是“更新或删除匹配的行数”语句的常规定义。这与大多数mysql dbapi驱动程序的默认设置相矛盾,即“实际修改/删除的行数”。因此,sqlAlchemy mysql方言总是添加 constants.CLIENT.FOUND_ROWS 连接时,标记或与目标方言等效的内容。此设置当前已硬编码。

铸造支架

MySQL在4.0.2版中记录了Cast操作符。使用sqlAlchemy时 cast() 函数中,基于服务器版本检测,SQLAlchemy在此版本之前不会在MySQL上呈现强制转换令牌,而是直接呈现内部表达式。

在早期的MySQL版本post-4.0.2上,CAST可能仍然不理想,因为它直到4.1.1才添加所有数据类型支持。如果应用程序属于此狭窄区域,则可以使用 自定义SQL构造和编译扩展 系统,按照以下方法:

from sqlalchemy.sql.expression import Cast
from sqlalchemy.ext.compiler import compiles

@compiles(Cast, 'mysql')
def _check_mysql_version(element, compiler, **kw):
    if compiler.dialect.server_version_info < (4, 1, 0):
        return compiler.process(element.clause, **kw)
    else:
        return compiler.visit_cast(element, **kw)

上面的函数只需要在应用程序中声明一次,它将重写 cast() 构造以在完全呈现强制转换之前检查版本4.1.0;否则将直接呈现构造的内部元素。

MySQL特定索引选项

mysql特定扩展到 Index 结构可用。

索引长度

MySQL提供了一个创建具有一定长度的索引项的选项,其中“长度”是指每个值中的字符或字节数,这些字符或字节将成为索引的一部分。SQLAlchemy通过 mysql_length 参数::

Index('my_index', my_table.c.data, mysql_length=10)

Index('a_b_idx', my_table.c.a, my_table.c.b, mysql_length={'a': 4,
                                                           'b': 9})

前缀长度以字符表示(非二进制字符串类型),以字节表示(二进制字符串类型)。传递给关键字参数的值 must 要么是一个整数(因此,为索引的所有列指定相同的前缀长度值),要么是一个dict,其中键是列名,值是对应列的前缀长度值。如果索引的列是char、varchar、text、binary、varbinary和blob,则mysql只允许该列的长度。

索引前缀

MySQL存储引擎允许您在创建索引时指定索引前缀。SQLAlchemy通过 mysql_prefix 参数对 Index ::

Index('my_index', my_table.c.data, mysql_prefix='FULLTEXT')

传递给关键字参数的值将简单地传递给基础的创建索引,因此 must 成为MySQL存储引擎的有效索引前缀。

1.1.5 新版功能.

参见

CREATE INDEX -MySQL文档

索引类型

某些MySQL存储引擎允许您在创建索引或主键约束时指定索引类型。SQLAlchemy通过 mysql_using 参数对 Index ::

Index('my_index', my_table.c.data, mysql_using='hash')

以及 mysql_using 参数对 PrimaryKeyConstraint ::

PrimaryKeyConstraint("data", mysql_using='hash')

传递给关键字参数的值将简单地传递给基础的create index或primary key子句,因此 must 成为MySQL存储引擎的有效索引类型。

有关更多信息,请访问:

http://dev.mysql.com/doc/refman/5.0/en/create-index.html

http://dev.mysql.com/doc/refman/5.0/en/create-table.html

索引解析器

在MySQL中创建全文索引还支持“with parser”选项。这可以使用关键字参数 mysql_with_parser ::

Index(
    'my_index', my_table.c.data,
    mysql_prefix='FULLTEXT', mysql_with_parser="ngram")

1.3 新版功能.

MySQL外键

MySQL对于外键的行为有一些重要的警告。

要避免的外键参数

MySQL不支持外键参数“deferrable”、“initially”或“match”。使用 deferrableinitially 关键字参数 ForeignKeyConstraintForeignKey 将具有这些关键字在DDL表达式中呈现的效果,这将在MySQL上引发错误。为了在MySQL后端忽略这些关键字的同时在外键上使用它们,请使用自定义编译规则:

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

@compiles(ForeignKeyConstraint, "mysql")
def process(element, compiler, **kw):
    element.deferrable = element.initially = None
    return compiler.visit_foreign_key_constraint(element, **kw)

在 0.9.0 版更改: -mysql后端不再悄悄地忽略 deferrableinitially 的关键字参数 ForeignKeyConstraintForeignKey .

“match”关键字实际上更阴险,并且被sqlAlchemy和mysql后端明确禁止。这个参数被MySQL悄悄地忽略了,但是除此之外,对更新和删除选项的影响也被后端忽略了。因此,Match不应该与MySQL后端一起使用;与Deferrable的情况一样,最初可以使用自定义编译规则在DDL定义时更正MySQL ForeignKeyConstraint。

0.9.0 新版功能: -MySQL后端将引发 CompileErrormatch 关键字用于 ForeignKeyConstraintForeignKey .

外键约束的反射

并非所有的MySQL存储引擎都支持外键。当使用非常常见的 MyISAM MySQL存储引擎中,由表反射加载的信息将不包含外键。对于这些表,您可以提供 ForeignKeyConstraint 反射时间:

Table('mytable', metadata,
      ForeignKeyConstraint(['other_id'], ['othertable.other_id']),
      autoload=True
     )

MySQL唯一约束和反射

SQLAlchemy支持 Index 用标志构造 unique=True ,指示唯一索引,以及 UniqueConstraint 构造,表示唯一约束。当发出ddl来创建这些约束时,mysql支持这两个对象/语法。但是,MySQL没有与唯一索引分离的唯一约束构造;也就是说,MySQL上的“唯一”约束等同于创建“唯一索引”。

当反映这些结构时, Inspector.get_indexes() 以及 Inspector.get_unique_constraints() 方法将 both 返回MySQL中唯一索引的条目。但是,当使用 Table(..., autoload=True) , the UniqueConstraint 构造是 not 完全反射的部分 Table 在任何情况下构造;此构造始终由 Indexunique=True 设置存在于 Table.indexes 收集。

时间戳列和空

MySQL在历史上强制指定timestamp数据类型的列隐式包含当前时间戳的默认值,即使未声明此值,并且另外将该列设置为非空,与所有其他数据类型的行为相反:

mysql> CREATE TABLE ts_test (
    -> a INTEGER,
    -> b INTEGER NOT NULL,
    -> c TIMESTAMP,
    -> d TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    -> e TIMESTAMP NULL);
Query OK, 0 rows affected (0.03 sec)

mysql> SHOW CREATE TABLE ts_test;
+---------+-----------------------------------------------------
| Table   | Create Table
+---------+-----------------------------------------------------
| ts_test | CREATE TABLE `ts_test` (
  `a` int(11) DEFAULT NULL,
  `b` int(11) NOT NULL,
  `c` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  `d` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `e` timestamp NULL DEFAULT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1

上面,我们看到一个整型列默认为空,除非它被指定为非空。但是当列的类型为timestamp时,会生成一个隐式的默认值current_timestamp,这也会强制该列为非空列,即使我们没有这样指定它。

mysql的这种行为可以在mysql端使用 explicit_defaults_for_timestamp mysql 5.6中引入的配置标志。启用此服务器设置后,时间戳列在默认值和可空性方面的行为与MySQL端的任何其他数据类型类似。

但是,为了适应绝大多数没有指定这个新标志的MySQL数据库,sqlAlchemy使用任何没有指定的时间戳列显式地发出“空”说明符。 nullable=False . 以便容纳指定 explicit_defaults_for_timestamp ,对于确实指定了 nullable=False . 以下示例说明:

from sqlalchemy import MetaData, Integer, Table, Column, text
from sqlalchemy.dialects.mysql import TIMESTAMP

m = MetaData()
t = Table('ts_test', m,
        Column('a', Integer),
        Column('b', Integer, nullable=False),
        Column('c', TIMESTAMP),
        Column('d', TIMESTAMP, nullable=False)
    )


from sqlalchemy import create_engine
e = create_engine("mysql://scott:tiger@localhost/test", echo=True)
m.create_all(e)

输出:

CREATE TABLE ts_test (
    a INTEGER,
    b INTEGER NOT NULL,
    c TIMESTAMP NULL,
    d TIMESTAMP NOT NULL
)

在 1.0.0 版更改: -sqlAlchemy现在在所有情况下都为时间戳列呈现空值或非空值,以适应 explicit_defaults_for_timestamp . 在此版本之前,它不会为时间戳列呈现“not null”,即 nullable=False .

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(display_width=None, **kw)

基地: sqlalchemy.dialects.mysql.types._IntegerTypesqlalchemy.types.BIGINT

MySQL BigInteger类型。

__init__(display_width=None, **kw)

构造一个biginteger。

参数
  • display_width -- 可选,此数字的最大显示宽度。

  • unsigned -- 布尔值,可选。

  • zerofill -- 可选的。如果为真,则值将存储为用零填充的字符串。请注意,这不会影响基础数据库API返回的值,这些值仍然是数字。

class sqlalchemy.dialects.mysql.BINARY(length=None)

基地: sqlalchemy.types._Binary

SQL二进制类型。

__init__(length=None)

继承 __init__() 方法 _Binary

初始化自身。请参阅帮助(键入(self))以获得准确的签名。

class sqlalchemy.dialects.mysql.BIT(length=None)

基地: sqlalchemy.types.TypeEngine

MySQL位类型。

此类型适用于mysql 5.0.3或更高版本,适用于myisam、memory、innodb和bdb的版本为5.0.5或更高版本。对于旧版本,请使用mstinyinteger()类型。

__init__(length=None)

做一点。

参数

length -- 可选,位数。

class sqlalchemy.dialects.mysql.BLOB(length=None)

基地: sqlalchemy.types.LargeBinary

SQL blob类型。

__init__(length=None)

继承 __init__() 方法 LargeBinary

构造一个大二进制类型。

参数

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

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

基地: sqlalchemy.types.Boolean

SQL布尔类型。

__init__(create_constraint=True, name=None, _create_events=True)

继承 __init__() 方法 Boolean

构造一个布尔值。

参数
  • create_constraint -- 默认为true。如果布尔值生成为int/smallint,则还应在表上创建一个检查约束,以确保1或0作为值。

  • name -- 如果生成了检查约束,请指定约束的名称。

class sqlalchemy.dialects.mysql.CHAR(length=None, **kwargs)

基地: sqlalchemy.dialects.mysql.types._StringTypesqlalchemy.types.CHAR

mysql char类型,用于固定长度的字符数据。

__init__(length=None, **kwargs)

构造一个字符。

参数
  • length -- 最大数据长度,以字符为单位。

  • binary -- 可选,使用国家字符集的默认二进制排序规则。这不会影响存储的数据类型,请为二进制数据使用二进制类型。

  • collation -- 可选,请求特定的排序规则。必须与国家字符集兼容。

class sqlalchemy.dialects.mysql.DATE

基地: sqlalchemy.types.Date

SQL日期类型。

__init__

继承 __init__ 属性 object

初始化自身。请参阅帮助(键入(self))以获得准确的签名。

class sqlalchemy.dialects.mysql.DATETIME(timezone=False, fsp=None)

基地: sqlalchemy.types.DATETIME

MySQL日期时间类型。

__init__(timezone=False, fsp=None)

构造一个mysql日期时间类型。

参数
  • timezone -- MySQL方言未使用。

  • fsp -- 小数秒精度值。MySQL5.6.4支持小数秒的存储;当为日期时间类型发出DDL时,将使用此参数。…注意:dbapi驱动程序对小数秒的支持可能有限;当前支持包括mysql connector/python。

class sqlalchemy.dialects.mysql.DECIMAL(precision=None, scale=None, asdecimal=True, **kw)

基地: sqlalchemy.dialects.mysql.types._NumericTypesqlalchemy.types.DECIMAL

mysql decimal类型。

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

构造小数。

参数
  • precision -- 此数字的总位数。如果scale和precision都为none,则值存储在服务器允许的限制内。

  • scale -- 小数点后的位数。

  • unsigned -- 布尔值,可选。

  • zerofill -- 可选的。如果为真,则值将存储为用零填充的字符串。请注意,这不会影响基础数据库API返回的值,这些值仍然是数字。

class sqlalchemy.dialects.mysql.DOUBLE(precision=None, scale=None, asdecimal=True, **kw)

基地: sqlalchemy.dialects.mysql.types._FloatType

MySQL双类型。

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

构造一个DOUBLE。

注解

这个 DOUBLE 默认情况下,类型使用默认为10位的截断从浮点转换为十进制。指定任一 scale=ndecimal_return_scale=n 为了改变这个比例,或者 asdecimal=False 以python浮点形式直接返回值。

参数
  • precision -- 此数字的总位数。如果scale和precision都为none,则值存储在服务器允许的限制内。

  • scale -- 小数点后的位数。

  • unsigned -- 布尔值,可选。

  • zerofill -- 可选的。如果为真,则值将存储为用零填充的字符串。请注意,这不会影响基础数据库API返回的值,这些值仍然是数字。

class sqlalchemy.dialects.mysql.ENUM(*enums, **kw)

基地: sqlalchemy.types.NativeForEmulatedsqlalchemy.types.Enumsqlalchemy.dialects.mysql.enumerated._EnumeratedValues

MySQL枚举类型。

__init__(*enums, **kw)

构造枚举。

例如。::

Column('myenum', ENUM("foo", "bar", "baz"))
参数
  • enums -- 此枚举的有效值范围。当根据引用标志生成模式时,将引用值(见下文)。此对象也可以是符合PEP-435的枚举类型。…版本添加:1.1添加了对符合PEP-435的枚举类型的支持。

  • strict -- 此标志无效。…versionChanged::mysql枚举类型和基本枚举类型现在验证所有python数据值。

  • charset -- 可选,此字符串值的列级字符集。优先于“ascii”或“unicode”缩写。

  • collation -- 可选,此字符串值的列级排序规则。优先于“binary”速记。

  • ascii -- 默认值为false: latin1 字符集,在模式中生成ASCII。

  • unicode -- 默认值为false: ucs2 字符集,在模式中生成Unicode。

  • binary -- 默认值为false:short-hand,选择与列的字符集匹配的二进制排序规则类型。在架构中生成二进制。这不影响存储的数据类型,只影响字符数据的排序规则。

  • quoting -- 默认为“auto”:自动确定枚举值引用。如果所有枚举值都被相同的引号字符包围,则使用“带引号”模式。否则,请使用“无引号”模式。引号:枚举中的值已被引用,它们将在生成架构时直接使用-此用法已被弃用。unquoted':枚举中的值没有被引用,在生成架构时,它们将被转义并用单引号包围。此类型的早期版本始终要求提供手动引用的值;将来的版本将始终为您引用字符串文本。这是一个过渡选项。

class sqlalchemy.dialects.mysql.FLOAT(precision=None, scale=None, asdecimal=False, **kw)

基地: sqlalchemy.dialects.mysql.types._FloatTypesqlalchemy.types.FLOAT

mysql float类型。

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

构造一个浮点。

参数
  • precision -- 此数字的总位数。如果scale和precision都为none,则值存储在服务器允许的限制内。

  • scale -- 小数点后的位数。

  • unsigned -- 布尔值,可选。

  • zerofill -- 可选的。如果为真,则值将存储为用零填充的字符串。请注意,这不会影响基础数据库API返回的值,这些值仍然是数字。

class sqlalchemy.dialects.mysql.INTEGER(display_width=None, **kw)

基地: sqlalchemy.dialects.mysql.types._IntegerTypesqlalchemy.types.INTEGER

MySQL整数类型。

__init__(display_width=None, **kw)

构造一个整数。

参数
  • display_width -- 可选,此数字的最大显示宽度。

  • unsigned -- 布尔值,可选。

  • zerofill -- 可选的。如果为真,则值将存储为用零填充的字符串。请注意,这不会影响基础数据库API返回的值,这些值仍然是数字。

class sqlalchemy.dialects.mysql.JSON(none_as_null=False)

基地: sqlalchemy.types.JSON

mysql json类型。

从5.7版开始,MySQL支持JSON。注意,Mariadb有 not 在编写本文时支持JSON。

这个 mysql.JSON 类型支持JSON值的持久性以及由提供的核心索引操作 types.JSON 数据类型,通过调整操作来呈现 JSON_EXTRACT 数据库级别的函数。

1.1 新版功能.

class sqlalchemy.dialects.mysql.LONGBLOB(length=None)

基地: sqlalchemy.types._Binary

mysql longblob类型,用于2^32字节的二进制数据。

__init__(length=None)

继承 __init__() 方法 _Binary

初始化自身。请参阅帮助(键入(self))以获得准确的签名。

class sqlalchemy.dialects.mysql.LONGTEXT(**kwargs)

基地: sqlalchemy.dialects.mysql.types._StringType

MySQL Longtext类型,用于最多2^32个字符的文本。

__init__(**kwargs)

构建一个长文本。

参数
  • charset -- 可选,此字符串值的列级字符集。优先于“ascii”或“unicode”缩写。

  • collation -- 可选,此字符串值的列级排序规则。优先于“binary”速记。

  • ascii -- 默认值为false: latin1 字符集,在模式中生成ASCII。

  • unicode -- 默认值为false: ucs2 字符集,在模式中生成Unicode。

  • national -- 可选的。如果为真,请使用服务器配置的国家字符集。

  • binary -- 默认值为false:short-hand,选择与列的字符集匹配的二进制排序规则类型。在架构中生成二进制。这不影响存储的数据类型,只影响字符数据的排序规则。

class sqlalchemy.dialects.mysql.MEDIUMBLOB(length=None)

基地: sqlalchemy.types._Binary

mysql mediumblob类型,用于二进制数据,最大2^24字节。

__init__(length=None)

继承 __init__() 方法 _Binary

初始化自身。请参阅帮助(键入(self))以获得准确的签名。

class sqlalchemy.dialects.mysql.MEDIUMINT(display_width=None, **kw)

基地: sqlalchemy.dialects.mysql.types._IntegerType

MySQL Mediuminteger类型。

__init__(display_width=None, **kw)

构造一个MEDIUMINTEGER

参数
  • display_width -- 可选,此数字的最大显示宽度。

  • unsigned -- 布尔值,可选。

  • zerofill -- 可选的。如果为真,则值将存储为用零填充的字符串。请注意,这不会影响基础数据库API返回的值,这些值仍然是数字。

class sqlalchemy.dialects.mysql.MEDIUMTEXT(**kwargs)

基地: sqlalchemy.dialects.mysql.types._StringType

mysql mediumtext类型,用于最多2^24个字符的文本。

__init__(**kwargs)

构建一个媒体文本。

参数
  • charset -- 可选,此字符串值的列级字符集。优先于“ascii”或“unicode”缩写。

  • collation -- 可选,此字符串值的列级排序规则。优先于“binary”速记。

  • ascii -- 默认值为false: latin1 字符集,在模式中生成ASCII。

  • unicode -- 默认值为false: ucs2 字符集,在模式中生成Unicode。

  • national -- 可选的。如果为真,请使用服务器配置的国家字符集。

  • binary -- 默认值为false:short-hand,选择与列的字符集匹配的二进制排序规则类型。在架构中生成二进制。这不影响存储的数据类型,只影响字符数据的排序规则。

class sqlalchemy.dialects.mysql.NCHAR(length=None, **kwargs)

基地: sqlalchemy.dialects.mysql.types._StringTypesqlalchemy.types.NCHAR

mysql nchar类型。

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

__init__(length=None, **kwargs)

构造一个NChar。

参数
  • length -- 最大数据长度,以字符为单位。

  • binary -- 可选,使用国家字符集的默认二进制排序规则。这不会影响存储的数据类型,请为二进制数据使用二进制类型。

  • collation -- 可选,请求特定的排序规则。必须与国家字符集兼容。

class sqlalchemy.dialects.mysql.NUMERIC(precision=None, scale=None, asdecimal=True, **kw)

基地: sqlalchemy.dialects.mysql.types._NumericTypesqlalchemy.types.NUMERIC

MySQL数字类型。

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

构造一个数字。

参数
  • precision -- 此数字的总位数。如果scale和precision都为none,则值存储在服务器允许的限制内。

  • scale -- 小数点后的位数。

  • unsigned -- 布尔值,可选。

  • zerofill -- 可选的。如果为真,则值将存储为用零填充的字符串。请注意,这不会影响基础数据库API返回的值,这些值仍然是数字。

class sqlalchemy.dialects.mysql.NVARCHAR(length=None, **kwargs)

基地: sqlalchemy.dialects.mysql.types._StringTypesqlalchemy.types.NVARCHAR

mysql nvarchar类型。

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

__init__(length=None, **kwargs)

构造nvarchar。

参数
  • length -- 最大数据长度,以字符为单位。

  • binary -- 可选,使用国家字符集的默认二进制排序规则。这不会影响存储的数据类型,请为二进制数据使用二进制类型。

  • collation -- 可选,请求特定的排序规则。必须与国家字符集兼容。

class sqlalchemy.dialects.mysql.REAL(precision=None, scale=None, asdecimal=True, **kw)

基地: sqlalchemy.dialects.mysql.types._FloatTypesqlalchemy.types.REAL

mysql实型。

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

构建一个真实的。

注解

这个 REAL 默认情况下,类型使用默认为10位的截断从浮点转换为十进制。指定任一 scale=ndecimal_return_scale=n 为了改变这个比例,或者 asdecimal=False 以python浮点形式直接返回值。

参数
  • precision -- 此数字的总位数。如果scale和precision都为none,则值存储在服务器允许的限制内。

  • scale -- 小数点后的位数。

  • unsigned -- 布尔值,可选。

  • zerofill -- 可选的。如果为真,则值将存储为用零填充的字符串。请注意,这不会影响基础数据库API返回的值,这些值仍然是数字。

class sqlalchemy.dialects.mysql.SET(*values, **kw)

基地: sqlalchemy.dialects.mysql.enumerated._EnumeratedValues

MySQL设置类型。

__init__(*values, **kw)

构造一个集合。

例如。::

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

如果此集合将用于为表生成DDL,或者如果 SET.retrieve_as_bitwise 标志设置为真。

参数
  • values -- 此集合的有效值范围。

  • convert_unicode -- 与…相同的标志 String.convert_unicode .

  • collation -- 与之相同 String.collation

  • charset -- 与之相同 VARCHAR.charset .

  • ascii -- 与之相同 VARCHAR.ascii .

  • unicode -- 与之相同 VARCHAR.unicode .

  • binary -- 与之相同 VARCHAR.binary .

  • quoting -- 默认为“自动”:自动确定设定值引用。如果所有值都被相同的引用字符包围,则使用“带引号”模式。否则,请使用“未引用”模式。引号:枚举中的值已被引用,它们将在生成架构时直接使用-此用法已被弃用。unquoted':枚举中的值没有被引用,它们在生成架构时将被转义并用单引号包围。此类型的早期版本始终要求提供手动引用的值;将来的版本将始终为您引用字符串文本。这是一个过渡选项。…添加的版本:0.9.0

  • retrieve_as_bitwise -- 如果为true,则将使用整数值持久化和选择集合类型的数据,其中集合被强制为按位掩码进行持久化。MySQL允许这种模式,其优点是能够明确地存储值,例如空白字符串。 '' . 数据类型将显示为表达式 col + 0 在select语句中,以便将值强制转换为结果集中的整数值。如果希望保留可以存储空白字符串的集合,则需要此标志。 '' 作为一个值。…警告::使用时 mysql.SET.retrieve_as_bitwise ,设置值列表必须用 完全相同的顺序 就像mysql数据库中存在的那样。…版本已添加::1.0.0

class sqlalchemy.dialects.mysql.SMALLINT(display_width=None, **kw)

基地: sqlalchemy.dialects.mysql.types._IntegerTypesqlalchemy.types.SMALLINT

mysql smallinteger类型。

__init__(display_width=None, **kw)

构造一个smallinteger。

参数
  • display_width -- 可选,此数字的最大显示宽度。

  • unsigned -- 布尔值,可选。

  • zerofill -- 可选的。如果为真,则值将存储为用零填充的字符串。请注意,这不会影响基础数据库API返回的值,这些值仍然是数字。

class sqlalchemy.dialects.mysql.TEXT(length=None, **kw)

基地: sqlalchemy.dialects.mysql.types._StringTypesqlalchemy.types.TEXT

mysql文本类型,用于最多2^16个字符的文本。

__init__(length=None, **kw)

构造文本。

参数
  • length -- 可选,如果提供,服务器可以通过替换足够存储的最小文本类型来优化存储 length 字符。

  • charset -- 可选,此字符串值的列级字符集。优先于“ascii”或“unicode”缩写。

  • collation -- 可选,此字符串值的列级排序规则。优先于“binary”速记。

  • ascii -- 默认值为false: latin1 字符集,在模式中生成ASCII。

  • unicode -- 默认值为false: ucs2 字符集,在模式中生成Unicode。

  • national -- 可选的。如果为真,请使用服务器配置的国家字符集。

  • binary -- 默认值为false:short-hand,选择与列的字符集匹配的二进制排序规则类型。在架构中生成二进制。这不影响存储的数据类型,只影响字符数据的排序规则。

class sqlalchemy.dialects.mysql.TIME(timezone=False, fsp=None)

基地: sqlalchemy.types.TIME

MySQL时间类型。

__init__(timezone=False, fsp=None)

构造一个mysql时间类型。

参数
  • timezone -- MySQL方言未使用。

  • fsp -- 小数秒精度值。MySQL5.6支持分数秒的存储;当为时间类型发出DDL时,将使用此参数。…注意:dbapi驱动程序对小数秒的支持可能会受到限制;当前的支持包括mysql connector/python。

class sqlalchemy.dialects.mysql.TIMESTAMP(timezone=False, fsp=None)

基地: sqlalchemy.types.TIMESTAMP

MySQL时间戳类型。

__init__(timezone=False, fsp=None)

构造MySQL时间戳类型。

参数
  • timezone -- MySQL方言未使用。

  • fsp -- 小数秒精度值。MySQL5.6.4支持小数秒的存储;当为时间戳类型发出DDL时,将使用此参数。…注意:dbapi驱动程序对小数秒的支持可能会受到限制;当前的支持包括mysql connector/python。

class sqlalchemy.dialects.mysql.TINYBLOB(length=None)

基地: sqlalchemy.types._Binary

mysql tinyblob类型,用于2^8字节的二进制数据。

__init__(length=None)

继承 __init__() 方法 _Binary

初始化自身。请参阅帮助(键入(self))以获得准确的签名。

class sqlalchemy.dialects.mysql.TINYINT(display_width=None, **kw)

基地: sqlalchemy.dialects.mysql.types._IntegerType

mysql tinyint类型。

__init__(display_width=None, **kw)

构造一个tinyint。

参数
  • display_width -- 可选,此数字的最大显示宽度。

  • unsigned -- 布尔值,可选。

  • zerofill -- 可选的。如果为真,则值将存储为用零填充的字符串。请注意,这不会影响基础数据库API返回的值,这些值仍然是数字。

class sqlalchemy.dialects.mysql.TINYTEXT(**kwargs)

基地: sqlalchemy.dialects.mysql.types._StringType

mysql tinytext类型,用于最多2^8个字符的文本。

__init__(**kwargs)

构造一个tinytext。

参数
  • charset -- 可选,此字符串值的列级字符集。优先于“ascii”或“unicode”缩写。

  • collation -- 可选,此字符串值的列级排序规则。优先于“binary”速记。

  • ascii -- 默认值为false: latin1 字符集,在模式中生成ASCII。

  • unicode -- 默认值为false: ucs2 字符集,在模式中生成Unicode。

  • national -- 可选的。如果为真,请使用服务器配置的国家字符集。

  • binary -- 默认值为false:short-hand,选择与列的字符集匹配的二进制排序规则类型。在架构中生成二进制。这不影响存储的数据类型,只影响字符数据的排序规则。

class sqlalchemy.dialects.mysql.VARBINARY(length=None)

基地: sqlalchemy.types._Binary

sql varbinary类型。

__init__(length=None)

继承 __init__() 方法 _Binary

初始化自身。请参阅帮助(键入(self))以获得准确的签名。

class sqlalchemy.dialects.mysql.VARCHAR(length=None, **kwargs)

基地: sqlalchemy.dialects.mysql.types._StringTypesqlalchemy.types.VARCHAR

mysql varchar类型,用于可变长度字符数据。

__init__(length=None, **kwargs)

构造varchar。

参数
  • charset -- 可选,此字符串值的列级字符集。优先于“ascii”或“unicode”缩写。

  • collation -- 可选,此字符串值的列级排序规则。优先于“binary”速记。

  • ascii -- 默认值为false: latin1 字符集,在模式中生成ASCII。

  • unicode -- 默认值为false: ucs2 字符集,在模式中生成Unicode。

  • national -- 可选的。如果为真,请使用服务器配置的国家字符集。

  • binary -- 默认值为false:short-hand,选择与列的字符集匹配的二进制排序规则类型。在架构中生成二进制。这不影响存储的数据类型,只影响字符数据的排序规则。

class sqlalchemy.dialects.mysql.YEAR(display_width=None)

基地: sqlalchemy.types.TypeEngine

mysql-year类型,用于1901-2155年的单字节存储。

__init__(display_width=None)

初始化自身。请参阅帮助(键入(self))以获得准确的签名。

mysql dml构造

sqlalchemy.dialects.mysql.dml.insert(table, values=None, inline=False, bind=None, prefixes=None, returning=None, return_defaults=False, **dialect_kw)

构建新的 Insert 对象。

此构造函数被镜像为公共API函数;请参见 insert() 完整的用法和参数描述。

class sqlalchemy.dialects.mysql.dml.Insert(table, values=None, inline=False, bind=None, prefixes=None, returning=None, return_defaults=False, **dialect_kw)

基地: sqlalchemy.sql.expression.Insert

特定于MySQL的insert实现。

为MySQL特定语法添加方法,例如在重复的键更新时。

1.2 新版功能.

inserted

为on-duplicate key update语句提供“inserted”命名空间

mysql的on duplicate key update子句允许通过调用 VALUES() . 此属性提供此行中的所有列都是可引用的,这样它们将在 VALUES() 在on duplicate key update子句中的函数。该属性已命名 .inserted 以免与现有的 Insert.values() 方法。

on_duplicate_key_update(*args, **kw)

指定on duplicate key update子句。

参数

**kw -- 链接到更新值的列键。这些值可以是任何SQL表达式或支持的文本python值。

警告

这本词典有 not 考虑到python指定的默认更新值或生成函数,例如使用 Column.onupdate . 除非在此处手动指定值,否则不会对重复键更新样式的更新执行这些值。

参数

*args -- 作为传递键/值参数的替代方法,可以将字典或2元组列表作为单个位置参数传递。传递一个字典等同于关键字参数form::insert()。在传递两个元组列表的“name”:“some name”)上,传递一个与 Update 整体施工 参数顺序更新 ::insert().on_duplicate_key_update( [(“name”:“some name”),(“value”,“some value”)。] …versionChanged::1.3参数可以指定为一个字典或两个元组的列表;后一种形式提供了参数排序。

1.2 新版功能.

mysqlclient(mysql python的分支)

Support for the MySQL database via the mysqlclient (maintained fork of MySQL-Python) driver.

DBAPI

Documentation and download information (if applicable) for mysqlclient (maintained fork of MySQL-Python) is available at: https://pypi.org/project/mysqlclient/

Connecting

Connect String:

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

驱动程序状态

mysqlclient dbapi是 MySQL-Python 不再维护的DBAPI。 mysqlclient 支持python 2和python 3,非常稳定。

统一码

请看 统一码 有关Unicode处理的当前建议。

使用mysqldb和google cloud sql

google cloud sql现在建议使用mysqldb方言。使用以下URL连接:

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

服务器端光标

mysqldb方言支持服务器端游标。见 服务器端光标 .

PyySQL

Support for the MySQL database via the PyMySQL driver.

DBAPI

Documentation and download information (if applicable) for PyMySQL is available at: https://pymysql.readthedocs.io/

Connecting

Connect String:

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

统一码

请看 统一码 有关Unicode处理的当前建议。

mysql-python兼容性

pymysql dbapi是mysql python(mysqldb)驱动程序的纯python端口,目标是100%的兼容性。mysql python的大多数行为注释也适用于pymysql驱动程序。

MySQL连接器

Support for the MySQL database via the MySQL Connector/Python driver.

DBAPI

Documentation and download information (if applicable) for MySQL Connector/Python is available at: https://pypi.org/project/mysql-connector-python/

Connecting

Connect String:

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

CyMySQL

Support for the MySQL database via the CyMySQL driver.

DBAPI

Documentation and download information (if applicable) for CyMySQL is available at: https://github.com/nakagami/CyMySQL

Connecting

Connect String:

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

URSQL

Support for the MySQL database via the OurSQL driver.

DBAPI

Documentation and download information (if applicable) for OurSQL is available at: http://packages.python.org/oursql/

Connecting

Connect String:

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

统一码

请看 统一码 有关Unicode处理的当前建议。

谷歌应用引擎

Support for the MySQL database via the Google Cloud SQL driver.

这种方言主要基于 mysql.mysqldb 变化最小的方言。

1.0 版后已移除: 这个方言是 不再需要 对于google cloud sql,mysqldb方言可以直接使用。云SQL现在建议使用URL格式通过MySQL方言创建连接

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

DBAPI

Documentation and download information (if applicable) for Google Cloud SQL is available at: https://developers.google.com/appengine/docs/python/cloud-sql/developers-guide

Connecting

Connect String:

mysql+gaerdbms:///<dbname>?instance=<instancename>

池化

谷歌应用程序引擎的连接似乎是随机循环的,所以方言不会汇集连接。这个 NullPool 实现安装在 Engine 默认情况下。

脓毒症

Support for the MySQL database via the PyODBC driver.

注解

mysql方言的pyodbc不受支持,并且受到当前可用的ODBC驱动程序中存在的未解决字符编码问题的影响。(参见http://code.google.com/p/pyodbc/issues/detail?)ID=25)。建议使用MySQL的其他方言。

DBAPI

Documentation and download information (if applicable) for PyODBC is available at: http://pypi.python.org/pypi/pyodbc/

Connecting

Connect String:

mysql+pyodbc://<username>:<password>@<dsnname>

ZXJDBC

Support for the MySQL database via the zxjdbc for Jython driver.

注解

当前版本的SQLAlchemy不支持Jython。zxjdbc方言应被视为实验性方言。

DBAPI

Drivers for this database are available at: http://dev.mysql.com/downloads/connector/j/

Connecting

Connect String:

mysql+zxjdbc://<user>:<password>@<hostname>[:<port>]/<database>

字符集

SQLAlchemy zxjdbc方言将unicode直接传递到zxjdbc/jdbc层。允许从mysql connector/j jdbc驱动程序发送多个字符集,默认情况下,sqlachemy将其 characterEncoding 连接属性到 UTF-8 . 它可以通过 create_engine URL参数。