SQLAlchemy通过现代版本支持从4.1版本开始的MySQL。但是，如果您的服务器版本不支持子选择，则不会采取英雄措施解决主要缺失的SQL功能，例如，它们也不会在SQLAlchemy中工作。
有关任何给定服务器版本中支持的功能的详细信息，请参阅官方的MySQL文档。
MySQL具有自动连接关闭行为，适用于闲置八小时或更长时间的连接。为了避免发生此问题，请使用控制任何连接的最大使用期限的pool_recycle选项：
engine = create_engine('mysql+mysqldb://...', pool_recycle=3600)也可以看看
Setting Pool Recycle - 池回收功能的完整说明。
MySQL’s CREATE TABLE syntax includes a wide array of special options, including ENGINE, CHARSET, MAX_ROWS, ROW_FORMAT, INSERT_METHOD, and many more. 要适应这些参数的呈现，请指定mysql_argument_name="value"形式。For example, to specify a table with ENGINE of InnoDB, CHARSET of utf8, and KEY_BLOCK_SIZE of 1024:
Table('mytable', metadata,
Column('data', String(32)),
mysql_engine='InnoDB',
mysql_charset='utf8',
mysql_key_block_size="1024"
)MySQL方言通常会将指定为mysql_keyword_name的任何关键字转换成CREATE TABLE中的语句。A handful of these names will render with a space instead of an underscore; to support this, the MySQL dialect has awareness of these particular names, which include KEYWORD_NAME >DATA DIRECTORY (e.g. mysql_data_directory), CHARACTER SET (e.g. mysql_character_set) and INDEX DIRECTORY (e.g. mysql_index_directory).
最常见的参数是mysql_engine，它引用表的存储引擎。从历史上看，MySQL服务器安装默认为MyISAM，尽管新版本可能默认为InnoDB。The InnoDB engine is typically preferred for its support of transactions and foreign keys.
在具有MyISAM存储引擎的MySQL数据库中创建的Table将基本上是非事务性的，这意味着引用此表的任何INSERT / UPDATE / DELETE语句将是被调用为自动提交。它也不会支持外键约束；而当使用MyISAM存储引擎时，CREATE TABLE语句接受外键选项，这些参数将被丢弃。反映这样的表格也不会产生外键约束信息。
For fully atomic transactions as well as support for foreign key constraints, all participating CREATE TABLE statements must specify a transactional engine, which in the vast majority of cases is InnoDB.
也可以看看
InnoDB存储引擎 - 在MySQL网站上。
MySQL对区分大小写的标识符名称提供了不一致的支持，基于对底层操作系统特定细节的支持。然而，据观察，无论出现什么样的大小写敏感性行为，外键声明中的表名都始终是总是从数据库接收为全小写，因此无法准确反映架构中相互关联的表使用混合大小写标识符名称。
因此，强烈建议在SQLAlchemy以及MySQL数据库本身中声明表名全部小写，尤其是在要使用数据库反射功能的情况下。
All MySQL dialects support setting of transaction isolation level both via a dialect-specific parameter create_engine.isolation_level accepted by create_engine(), as well as the Connection.execution_options.isolation_level argument as passed to Connection.execution_options(). This feature works by issuing the command SET SESSION TRANSACTION ISOLATION LEVEL <level> for each new connection. 对于特殊的AUTOCOMMIT隔离级别，使用了特定于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的有效值包括：
READ COMMITTEDREAD UNCOMMITTEDREPEATABLE READSERIALIZABLEAUTOCOMMIT特殊的AUTOCOMMIT值使用特定DBAPI提供的各种“autocommit”属性，目前支持MySQLdb，MySQL-Client，MySQL-Connector Python和PyMySQL。使用它，MySQL连接将对SELECT @@ autocommit；的值返回true。
1.1版新增功能： - 增加了对AUTOCOMMIT隔离级别的支持。
创建表时，SQLAlchemy将在未标记为外键的第一个Integer主键列上自动设置AUTO_INCREMENT：
>>> 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)
)您可以通过将False传递给Column的autoincrement参数来禁用此行为。此标志还可用于启用某些存储引擎的多列键中辅助列的自动递增：
Table('mytable', metadata,
Column('gid', Integer, primary_key=True, autoincrement=False),
Column('id', Integer, primary_key=True)
)大多数MySQL DBAPI提供了为连接设置客户端字符集的选项。这通常通过URL中的charset参数提供，例如：
e = create_engine("mysql+pymysql://scott:tiger@localhost/test?charset=utf8")这个字符集是连接的客户端字符集。Some MySQL DBAPIs will default this to a value such as latin1, and some will make use of the default-character-set setting in the my.cnf file as well. 应该查阅正在使用的DBAPI的文档以了解具体行为。
用于Unicode的编码传统上是'utf8'。但是，对于正向版本的MySQL 5.5.3，引入了一个新的特定于MySQL的编码'utf8mb4'。这种新编码的基本原理是由于MySQL的utf-8编码仅支持最多三个字节而不是四个的码位。因此，当与包含三个字节以上的代码点的MySQL数据库进行通信时，如果数据库和客户端DBAPI都支持，则这个新的字符集是首选的，如下所示：
e = create_engine("mysql+pymysql://scott:tiger@localhost/test?charset=utf8mb4")目前，MySQLdb和PyMySQL的最新版本支持utf8mb4字符集。其他DBAPI如MySQL-Connector和OurSQL可能不能支持它。
为了使用utf8mb4编码，可能需要更改MySQL架构和/或服务器配置。
也可以看看
utf8mb4字符集 - 在MySQL文档中
所有现代的MySQL DBAPI都提供了在Python应用程序空间和数据库之间处理unicode数据编码和解码的服务。由于情况并非总是如此，SQLAlchemy还包含一个执行编码/解码任务的综合系统。由于这些系统中只有一个应该在使用，SQLAlchemy长期以来包含了在第一次连接时自动检测DBAPI是否自动处理unicode的功能。
MySQL DBAPI是否处理编码通常可以使用DBAPI标志use_unicode进行配置，该标志至少已被MySQLdb，PyMySQL和MySQL-Connector支持。在“connect args”或查询字符串中将此值设置为0将导致禁用DBAPI处理unicode的效果，例如，它将返回str类型或bytes类型，数据在配置的字符集中：
# connect while disabling the DBAPI's unicode encoding/decoding
e = create_engine("mysql+mysqldb://scott:tiger@localhost/test?charset=utf8&use_unicode=0")目前对现代DBAPI的建议如下：
use_unicode标志设置为其默认值通常总是安全的；也就是说，根本不要使用它。use_unicode=0标志应该永远不会被使用。Python 3下的SQLAlchemy通常假定DBAPI接收并返回字符串值，如Python 3字符串，它本质上是unicode对象。use_unicode=0标志将提供卓越的性能，因为与SQLAlchemy的快速性相比，MySQLdb的Python 2下的unicode转换器仅被观察到异常缓慢的性能基于C的编码器/解码器。简而言之：不要在所有的中指定use_unicode ，并且Python 2 的MySQLdb上的use_unicode=0 / t5>以获得潜在的性能增益。
MySQL features two varieties of identifier “quoting style”, one using backticks and the other using quotes, e.g. `some_identifier` vs. "some_identifier". 当首次建立与特定Engine的连接时，所有MySQL方言通过检查sql_mode的值来检测正在使用哪个版本。这种引用风格在呈现表名和列名以及反映现有数据库结构时起作用。检测是完全自动的，不需要使用任何引用样式的特殊配置。
在版本0.6中更改：检测ANSI引用样式是完全自动的，在这方面不再有任何最终用户create_engine()选项。
许多MySQL SQL扩展都是通过SQLAlchemy的通用函数和运算符支持来处理的：
table.select(table.c.password==func.md5('plaintext'))
table.select(table.c.username.op('regexp')('^[a-d]'))当然，任何有效的MySQL语句也可以作为字符串执行。
目前有一些对SQL扩展的有限直接支持。
SELECT杂注：
select(..., prefixes=['HIGH_PRIORITY', 'SQL_SMALL_RESULT'])更新与限制：
update(..., mysql_limit=10)SQLAlchemy将DBAPI cursor.rowcount属性标准化为“UPDATE或DELETE匹配的行数”的通常定义。这与大多数MySQL DBAPI驱动程序的默认设置相矛盾，即“实际修改/删除的行数”。因此，SQLAlchemy MySQL方言总是在连接时添加constants.CLIENT.FOUND_ROWS标志或任何等同于目标方言的标志。此设置目前是硬编码的。
也可以看看
MySQL将文档CAST操作符记录在版本4.0.2中。当使用SQLAlchemy cast()函数时，基于服务器版本检测，SQLAlchemy将不会在此版本之前在MySQL上呈现CAST标记，而是直接渲染内部表达式。
在早期的MySQL版本4.0.2之后，CAST可能仍然不可取，因为在4.1.1之前它没有添加所有的数据类型支持。如果您的应用程序属于这个狭窄区域，则可以使用Custom SQL Constructs and Compilation Extension系统按照以下配方来控制CAST的行为：
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()结构以在完全呈现CAST之前检查版本4.1.0；否则直接渲染构造的内部元素。
针对Index结构的特定于MySQL的扩展可用。
MySQL提供了创建具有一定长度的索引条目的选项，其中“length”是指每个值中将成为索引一部分的字符或字节数。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})对于非二进制字符串类型，前缀长度以字符给出，二进制字符串类型以字节给出。传递给关键字参数的值必须是或者是一个整数（因此，为索引的所有列指定相同的前缀长度值）或者一个字典中的列名称和值是前缀相应列的长度值。如果是CHAR，VARCHAR，TEXT，BINARY，VARBINARY和BLOB，MySQL只允许索引列的长度。
0.8.2版中的新功能 mysql_length现在可以被指定为与组合索引一起使用的字典。
某些MySQL存储引擎允许您在创建索引或主键约束时指定索引类型。SQLAlchemy通过Index上的mysql_using参数提供此功能：
Index('my_index', my_table.c.data, mysql_using='hash')以及PrimaryKeyConstraint上的mysql_using参数：
PrimaryKeyConstraint("data", mysql_using='hash')The value passed to the keyword argument will be simply passed through to the underlying CREATE INDEX or PRIMARY KEY clause, so it must be a valid index type for your MySQL storage engine.
有关更多信息，请访问：
http://dev.mysql.com/doc/refman/5.0/en/create-index.html T0>
http://dev.mysql.com/doc/refman/5.0/en/create-table.html T0>
MySQL关于外键的行为有一些重要的注意事项。
MySQL不支持外键参数“DEFERRABLE”，“INITIALLY”或“MATCH”。对ForeignKeyConstraint或ForeignKey使用deferrable或initially关键字参数将会产生这些关键字在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)Changed in version 0.9.0: - the MySQL backend no longer silently ignores the deferrable or initially keyword arguments of ForeignKeyConstraint and ForeignKey.
“MATCH”关键字实际上更加隐蔽，并且被SQLAlchemy与MySQL后端结合在一起明确地禁止。这个参数被MySQL默默地忽略，但是另外有ON UPDATE和ON DELETE选项也被后端忽略。因此MATCH不应该与MySQL后端一起使用；与DEFERRABLE和INITIALLY一样，自定义编译规则可用于在DDL定义时更正MySQL ForeignKeyConstraint。
New in version 0.9.0: - the MySQL backend will raise a CompileError when the match keyword is used with ForeignKeyConstraint or ForeignKey.
并非所有的MySQL存储引擎都支持外键。When using the very common MyISAM MySQL storage engine, the information loaded by table reflection will not include foreign keys. 对于这些表，您可以在反射时提供ForeignKeyConstraint：
Table('mytable', metadata,
ForeignKeyConstraint(['other_id'], ['othertable.other_id']),
autoload=True
)SQLAlchemy支持带有标志unique=True的Index结构，表示一个UNIQUE索引以及UniqueConstraint结构，表示一个UNIQUE约束。当发出DDL来创建这些约束时，MySQL支持这两种对象/语法。但是，MySQL没有独特的约束结构，它与独特的索引是分开的；也就是说，MySQL上的“UNIQUE”约束等同于创建“UNIQUE INDEX”。
当反映这些结构时，Inspector.get_indexes()和Inspector.get_unique_constraints()方法都会返回一个UNIQUE索引的条目MySQL的。However, when performing full table reflection using Table(..., autoload=True), the UniqueConstraint construct is not part of the fully reflected Table construct under any circumstances; this construct is always represented by a Index with the unique=True setting present in the Table.indexes collection.
MySQL在历史上强制指定TIMESTAMP数据类型的列隐式地包含缺省值CURRENT_TIMESTAMP，尽管没有说明，并且另外将列设置为NOT NULL，与所有其他数据类型相反：
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在上面，我们看到INTEGER列默认为NULL，除非它用NOT NULL指定。但是，当列的类型为TIMESTAMP时，会生成CURRENT_TIMESTAMP的隐式缺省值，这也会强制该列成为NOT NULL，即使我们没有这样指定它。
MySQL的这种行为可以使用MySQL 5.6中引入的explicit_defaults_for_timestamp配置标志在MySQL端进行更改。在启用此服务器设置的情况下，TIMESTAMP列的行为与MySQL侧的任何其他数据类型相对于默认和可空性相同。
但是，为了适应绝大多数不指定此新标志的MySQL数据库，SQLAlchemy会使用任何未指定nullable=False的TIMESTAMP列显式地发出“NULL”说明符。为了适应更新的指定explicit_defaults_for_timestamp的数据库，SQLAlchemy还为指定nullable=False的TIMESTAMP列发出NOT NULL。以下示例说明：
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现在在所有情况下为TIMESTAMP列呈现NULL或NOT NULL，以适应explicit_defaults_for_timestamp。在此版本之前，它不会为nullable=False的TIMESTAMP列呈现“NOT NULL”。
与所有SQLAlchemy方言一样，所有已知可用于MySQL的UPPERCASE类型都可从顶级方言导入：
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的构造参数的类型如下所示：
sqlalchemy.dialects.mysql。 BIGINT （ display_width = None， **千瓦 T5> ） T6> ¶ T7>基础：sqlalchemy.dialects.mysql.types._IntegerType，sqlalchemy.types.BIGINT
MySQL BIGINTEGER类型。
sqlalchemy.dialects.mysql.BINARY(length=None)¶基础：sqlalchemy.types._Binary
SQL BINARY类型。
sqlalchemy.dialects.mysql.BIT(length=None)¶基础：sqlalchemy.types.TypeEngine
MySQL BIT类型。
这种类型适用于MyISAM的MySQL 5.0.3或更高版本，以及MyISAM，MEMORY，InnoDB和BDB的5.0.5或更高版本。对于旧版本，请使用MSTinyInteger()类型。
sqlalchemy.dialects.mysql.BLOB(length=None)¶基础：sqlalchemy.types.LargeBinary
SQL BLOB类型。
__初始化__ T0> （ T1> 长度=无 T2> ） T3> ¶ T4>__init__() method of LargeBinary构建一个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. |
|---|
sqlalchemy.dialects.mysql。 BOOLEAN （ create_constraint = True， name = None，_create_events = True tt> ） ¶SQL BOOLEAN类型。
__ init __ （ create_constraint = True，name =无，_create_events = True ） T5> ¶ T6>__init__() method of Boolean构造一个布尔值。
| 参数： |
|---|
sqlalchemy.dialects.mysql.CHAR(length=None, **kwargs)¶基础：sqlalchemy.dialects.mysql.types._StringType，sqlalchemy.types.CHAR
MySQL CHAR类型，用于固定长度的字符数据。
sqlalchemy.dialects.mysql。 DATE ¶SQL DATE类型。
__初始化__ T0> ¶ T1>__init__ 属性 objectx .__ init __（...）初始化x；请参阅帮助（类型（x））进行签名
sqlalchemy.dialects.mysql。 DATETIME （ timezone = False， FSP =无 T5> ） T6> ¶ T7>MySQL DATETIME类型。
__init__(timezone=False, fsp=None)¶构建一个MySQL DATETIME类型。
| 参数： |
|---|
0.8.5版新增：增加了支持小数秒的特定于MySQL的mysql.DATETIME。
sqlalchemy.dialects.mysql。 DECIMAL （ precision = None， scale = None，asdecimal = True，** kw ） 基础：sqlalchemy.dialects.mysql.types._NumericType，sqlalchemy.types.DECIMAL
MySQL DECIMAL类型。
sqlalchemy.dialects.mysql。 DOUBLE （ precision = None， scale = None，asdecimal = True，** kw ） 基础：sqlalchemy.dialects.mysql.types._FloatType
MySQL DOUBLE类型。
sqlalchemy.dialects.mysql。 ENUM （ * enums，**千瓦 T5> ） T6> ¶ T7>基础：sqlalchemy.types.Enum，sqlalchemy.dialects.mysql.enumerated._EnumeratedValues
MySQL ENUM类型。
__ init __ （ * enums，** kw ） T5>构造一个枚举。
例如。：
Column('myenum', ENUM("foo", "bar", "baz"))| 参数： |
|
|---|
sqlalchemy.dialects.mysql。 FLOAT （ precision = None， scale = None，asdecimal = False，** kw ） 基础：sqlalchemy.dialects.mysql.types._FloatType，sqlalchemy.types.FLOAT
MySQL FLOAT类型。
sqlalchemy.dialects.mysql。 INTEGER （ display_width = None， **千瓦 T5> ） T6> ¶ T7>基础：sqlalchemy.dialects.mysql.types._IntegerType，sqlalchemy.types.INTEGER
MySQL INTEGER类型。
sqlalchemy.dialects.mysql。 JSON （ none_as_null = False ） T5> ¶ T6>MySQL JSON类型。
MySQL从版本5.7开始支持JSON。Note that MariaDB does not support JSON at the time of this writing.
mysql.JSON类型支持JSON值的持久性以及types.JSON数据类型提供的核心索引操作，方法是调整操作以呈现JSON_EXTRACT
版本1.1中的新功能
sqlalchemy.dialects.mysql。 LONGBLOB （ length = None ） T5> ¶ T6>基础：sqlalchemy.types._Binary
MySQL LONGBLOB类型，用于最多2 ^ 32字节的二进制数据。
sqlalchemy.dialects.mysql。 LONGTEXT （ ** kwargs ） T5> ¶ T6>基础：sqlalchemy.dialects.mysql.types._StringType
MySQL LONGTEXT类型，文本最多2 ^ 32个字符。
__初始化__ T0> （ T1> ** kwargs T2> ） T3> ¶ T4>构建一个LONGTEXT。
| 参数： |
|
|---|
sqlalchemy.dialects.mysql。 MEDIUMBLOB （ length = None ） T5> ¶ T6>基础：sqlalchemy.types._Binary
MySQL MEDIUMBLOB类型，用于最大2 ^ 24字节的二进制数据。
sqlalchemy.dialects.mysql。 tt> MEDIUMINT （ display_width = None， **千瓦 T5> ） T6> ¶ T7>基础：sqlalchemy.dialects.mysql.types._IntegerType
MySQL MEDIUMINTEGER类型。
sqlalchemy.dialects.mysql。 MEDIUMTEXT （ ** kwargs ） T5> ¶ T6>基础：sqlalchemy.dialects.mysql.types._StringType
MySQL MEDIUMTEXT类型，用于最多2 ^ 24个字符的文本。
__初始化__ T0> （ T1> ** kwargs T2> ） T3> ¶ T4>构建MEDIUMTEXT。
| 参数： |
|
|---|
sqlalchemy.dialects.mysql。 NCHAR （ length = None， ** kwargs T5> ） T6> ¶ T7>基础：sqlalchemy.dialects.mysql.types._StringType，sqlalchemy.types.NCHAR
MySQL NCHAR类型。
用于服务器配置的国家字符集中的固定长度字符数据。
sqlalchemy.dialects.mysql。 NUMERIC （ precision = None， scale = None，asdecimal = True，** kw ） 基础：sqlalchemy.dialects.mysql.types._NumericType，sqlalchemy.types.NUMERIC
MySQL NUMERIC类型。
sqlalchemy.dialects.mysql。 NVARCHAR （ length = None， ** kwargs T5> ） T6> ¶ T7>基础：sqlalchemy.dialects.mysql.types._StringType，sqlalchemy.types.NVARCHAR
MySQL NVARCHAR类型。
用于服务器配置的国家字符集中的可变长度字符数据。
sqlalchemy.dialects.mysql。 REAL （ precision = None， scale = None，asdecimal = True，** kw ） 基础：sqlalchemy.dialects.mysql.types._FloatType，sqlalchemy.types.REAL
MySQL REAL类型。
sqlalchemy.dialects.mysql.SET(*values, **kw)¶基础：sqlalchemy.dialects.mysql.enumerated._EnumeratedValues
MySQL SET类型。
__init__(*values, **kw)¶构建一个SET。
例如。：
Column('myset', SET("foo", "bar", "baz"))如果此组将用于为表生成DDL，或者SET.retrieve_as_bitwise标志设置为True，则需要使用潜在值列表。
| 参数： |
|
|---|
sqlalchemy.dialects.mysql。 SMALLINT （ display_width = None， **千瓦 T5> ） T6> ¶ T7>基础：sqlalchemy.dialects.mysql.types._IntegerType，sqlalchemy.types.SMALLINT
MySQL SMALLINTEGER类型。
sqlalchemy.dialects.mysql。 TEXT （ length = None， **千瓦 T5> ） T6> ¶ T7>基础：sqlalchemy.dialects.mysql.types._StringType，sqlalchemy.types.TEXT
MySQL文本类型，文本最多2 ^ 16个字符。
__初始化__ T0> （ T1> 长度=无 T2>， **千瓦 T3> ） T4> ¶< / T5>构建一个TEXT。
| 参数： |
|
|---|
sqlalchemy.dialects.mysql.TIME(timezone=False, fsp=None)¶MySQL TIME类型。
sqlalchemy.dialects.mysql。 TIMESTAMP （ timezone = False， FSP =无 T5> ） T6> ¶ T7>MySQL TIMESTAMP类型。
__init__(timezone=False, fsp=None)¶构建一个MySQL TIMESTAMP类型。
| 参数： |
|---|
0.8.5版新增：增加了支持小数秒的特定于MySQL的mysql.TIMESTAMP。
sqlalchemy.dialects.mysql。 TINYBLOB （ length = None ） T5> ¶ T6>基础：sqlalchemy.types._Binary
MySQL TINYBLOB类型，用于2 ^ 8字节的二进制数据。
sqlalchemy.dialects.mysql。 TINYINT （ display_width = None， **千瓦 T5> ） T6> ¶ T7>基础：sqlalchemy.dialects.mysql.types._IntegerType
MySQL TINYINT类型。
sqlalchemy.dialects.mysql。 TINYTEXT （ ** kwargs ） T5> ¶ T6>基础：sqlalchemy.dialects.mysql.types._StringType
MySQL TINYTEXT类型，文本最多2 ^ 8个字符。
__初始化__ T0> （ T1> ** kwargs T2> ） T3> ¶ T4>构建一个TINYTEXT。
| 参数： |
|
|---|
sqlalchemy.dialects.mysql.VARBINARY(length=None)¶基础：sqlalchemy.types._Binary
SQL VARBINARY类型。
sqlalchemy.dialects.mysql。 VARCHAR （ length = None， ** kwargs T5> ） T6> ¶ T7>基础：sqlalchemy.dialects.mysql.types._StringType，sqlalchemy.types.VARCHAR
MySQL VARCHAR类型，用于可变长度字符数据。
__ init __ （ length = None，** kwargs ） / T5>构建一个VARCHAR。
| 参数： |
|
|---|
sqlalchemy.dialects.mysql。 YEAR （ display_width = None ） T5> ¶ T6>基础：sqlalchemy.types.TypeEngine
MySQL YEAR类型，用于1901-2155年的单字节存储。
通过MySQL-Python驱动程序支持MySQL数据库。
MySQL-Python的文档和下载信息（如果适用）可在以下网址找到：http://sourceforge.net/projects/mysql-python
目前，MySQLdb只在Python 2上运行，开发已停止。mysqlclient is fork of MySQLdb and provides Python 3 support as well as some bugfixes.
Google Cloud SQL现在推荐使用MySQLdb方言。使用以下URL连接：
mysql+mysqldb://root@/<dbname>?unix_socket=/cloudsql/<projectid>:<instancename>通过PyMySQL驱动程序支持MySQL数据库。
PyMySQL的文档和下载信息（如果适用）可在以下网址获得：http://www.pymysql.org/
pymysql DBAPI是MySQL-python（MySQLdb）驱动程序的纯Python端口，其目标是100％的兼容性。MySQL-python的大多数行为注释也适用于pymysql驱动程序。
通过MySQL Connector / Python驱动程序支持MySQL数据库。
MySQL Connector / Python的文档和下载信息（如果适用）可在以下网址获得：http://dev.mysql.com/downloads/connector/python/
通过CyMySQL驱动程序支持MySQL数据库。
CyMySQL的文档和下载信息（如果适用）可在以下网址获得：https://github.com/nakagami/CyMySQL
通过OurSQL驱动程序支持MySQL数据库。
OurSQL的文档和下载信息（如果适用）可在以下网址获得：http://packages.python.org/oursql/
通过Google Cloud SQL驱动程序支持MySQL数据库。
这种方言主要基于mysql.mysqldb方言，只有很少的变化。
New in version 0.7.8.
Deprecated since version 1.0: This dialect is no longer necessary for Google Cloud SQL; the MySQLdb dialect can be used directly. Cloud SQL现在推荐使用URL格式通过mysql方言创建连接
mysql+mysqldb://root@/<dbname>?unix_socket=/cloudsql/<projectid>:<instancename>
有关Google Cloud SQL的文档和下载信息（如果适用），请访问：https://developers.google.com/appengine/docs/python/cloud-sql/developers-guide
通过PyODBC驱动程序支持MySQL数据库。
注意
用于MySQL方言的PyODBC没有得到很好的支持，并且会受到当前ODBC驱动程序中存在的未解决的字符编码问题的影响。（请参阅http://code.google.com/p/pyodbc/issues/detail?id=25）。推荐其他MySQL的方言。
PyODBC的文档和下载信息（如果适用）可在以下网址获得：http://pypi.python.org/pypi/pyodbc/
通过用于Jython驱动程序的zxjdbc支持MySQL数据库。
注意
当前版本的SQLAlchemy不支持Jython。zxjdbc方言应该被认为是实验性的。
此数据库的驱动程序可在以下网址找到：http://dev.mysql.com/downloads/connector/j/
SQLAlchemy zxjdbc方言将unicode直接传递给zxjdbc / JDBC层。为了允许从MySQL Connector / J JDBC驱动程序发送多个字符集，默认情况下，SQLAlchemy将其characterEncoding连接属性设置为UTF-8。它可以通过create_engine URL参数覆盖。