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

SQLAlchemy 1.1文档

MySQL的¶ T0>

支持MySQL数据库。

DBAPI支持

以下dialect / DBAPI选项可用。有关连接信息,请参阅各个DBAPI部分。

支持的版本和功能

SQLAlchemy通过现代版本支持从4.1版本开始的MySQL。然而,没有采取英勇的措施来解决主要的缺失SQL特性 - 如果你的服务器版本不支持子选择,例如,它们也不能在SQLAlchemy中工作。

查看官方的MySQL文档,了解任何给定服务器版本中支持的功能的详细信息。

连接超时

MySQL具有自动连接关闭行为,对于闲置了八个小时或更长时间的连接。为了避免出现这个问题,可以使用控制任何连接的最大时间的pool_recycle选项:

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

也可以看看

Setting Pool Recycle - 池回收功能的完整说明。

包含存储引擎的CREATE TABLE参数

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中的KEYWORD_NAME >声明。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 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,尽管新版本可能默认为InnoDBThe InnoDB engine is typically preferred for its support of transactions and foreign keys.

A Table that is created in a MySQL database with a storage engine of MyISAM will be essentially non-transactional, meaning any INSERT/UPDATE/DELETE statement referring to this table will be invoked as autocommit. 它也不会支持外键约束;而当使用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.

也可以看看

The InnoDB Storage Engine - on the MySQL website.

区分大小写和表反射

MySQL对区分大小写的标识符名称提供了不一致的支持,基于对底层操作系统的特定细节的支持。However, it has been observed that no matter what case sensitivity behavior is present, the names of tables in foreign key declarations are always received from the database as all-lower case, making it impossible to accurately reflect a schema where inter-related tables use mixed-case identifier names.

因此,强烈建议在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 COMMITTED
  • READ UNCOMMITTED
  • REPEATABLE READ
  • SERIALIZABLE
  • AUTOCOMMIT

特殊的AUTOCOMMIT值使用特定DBAPI提供的各种“autocommit”属性,目前支持MySQLdb,MySQL-Client,MySQL-Connector Python和PyMySQL。使用它,MySQL连接将为SELECT @@ autocommit;的值返回true。

版本1.1新增: - 增加了对AUTOCOMMIT隔离级别的支持。

AUTO_INCREMENT行为

在创建表时,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传递给Columnautoincrement参数来禁用此行为。对于某些存储引擎,此标志还可用于在多列键的辅助列上启用自动递增:

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

Unicode的¶ T0>

字符集选择

大多数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文档中

Unicode编码/解码

所有现代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标志设置为默认值通常总是安全的;也就是说,根本不使用它。
  • Under Python 3, the use_unicode=0 flag should never be used. Python 3下的SQLAlchemy通常假定DBAPI接收并返回字符串值,如Python 3字符串,它本质上是unicode对象。
  • 在使用MySQLdb的Python 2下,use_unicode=0标志将使提供卓越的性能,因为与SQLAlchemy的快速性相比,MySQLdb的Python 2下的unicode转换器基于C的编码器/解码器。

简而言之:不要在所有的中指定use_unicode ,而仅在Python 2 的MySQLdb上use_unicode=0 / t5>以获得潜在的性能提升。

Ansi引用风格

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的值来检测正在使用哪个版本。这种引用样式在呈现表名和列名以及反映现有数据库结构时起作用。检测是完全自动的,不需要使用任何引用样式的特殊配置。

Changed in version 0.6: detection of ANSI quoting style is entirely automatic, there’s no longer any end-user create_engine() options in this regard.

MySQL SQL扩展

许多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)

rowcount支持

SQLAlchemy将DBAPI cursor.rowcount属性标准化为“通过UPDATE或DELETE匹配的行数”的通常定义。这与大多数MySQL DBAPI驱动程序的默认设置相矛盾,即“实际修改/删除的行数”。出于这个原因,所述的SQLAlchemy MySQL的方言总是添加constants.CLIENT.FOUND_ROWS这个设置目前是硬编码的。

也可以看看

ResultProxy.rowcount

CAST支持

MySQL将文档CAST操作符记录在版本4.0.2中。当使用SQLAlchemy cast()函数时,SQLAlchemy将不会在此版本之前根据服务器版本检测在MySQL上呈现CAST标记,而是直接渲染内部表达式。

在4.0.2之后的早期MySQL版本中,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;否则直接渲染构造的内部元素。

MySQL特定索引选项

对于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只允许索引列的长度。

New in version 0.8.2: mysql_length may now be specified as a dictionary for use with composite indexes.

索引类型

某些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关于外键的行为有一些重要的注意事项。

要避免的外键参数

MySQL不支持外键参数“DEFERRABLE”,“INITIALLY”或“MATCH”。ForeignKeyConstraintForeignKey使用deferrableinitially关键字参数将会产生这些关键字在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
     )

MySQL唯一约束和反射

SQLAlchemy同时支持Index结构和unique=True结构,表示一个UNIQUE索引以及UniqueConstraint结构,表示一个UNIQUE约束。当发出DDL来创建这些约束时,MySQL支持这两种对象/语法。但是,MySQL没有独特的约束结构,它与独特的索引是分开的。也就是说,MySQL上的“UNIQUE”约束等同于创建一个“UNIQUE INDEX”。

When reflecting these constructs, the Inspector.get_indexes() and the Inspector.get_unique_constraints() methods will both return an entry for a UNIQUE index in 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.

TIMESTAMP列和NULL

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”。

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 **千瓦 T5> ) T6> ¶ T7>

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

MySQL BIGINTEGER类型。

__ init __ display_width = None** kw / T5>

构建一个BIGINTEGER。

参数:
  • display_width – Optional, maximum display width for this number.
  • 无符号 - 一个布尔值,可选。
  • zerofill - 可选。如果为true,则值将被存储为用零填充的字符串。请注意,这不会影响底层数据库API返回的值,这些值仍然是数字。
class sqlalchemy.dialects.mysql。 BINARY length = None ) T5> ¶ T6>

基础:sqlalchemy.types._Binary

SQL BINARY类型。

class sqlalchemy.dialects.mysql。 BIT length = None ) T5> ¶ T6>

基础:sqlalchemy.types.TypeEngine

MySQL BIT类型。

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

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

构建一个BIT。

参数: 长度 - 可选,位数。
class sqlalchemy.dialects.mysql.BLOB(length=None)

基础:sqlalchemy.types.LargeBinary

SQL BLOB类型。

__初始化__ T0> ( T1> 长度=无 T2> ) T3> ¶ T4>
inherited from the __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.
class sqlalchemy.dialects.mysql.BOOLEAN(create_constraint=True, name=None, _create_events=True)

基础:sqlalchemy.types.Boolean

SQL BOOLEAN类型。

__ init __ create_constraint = Truename = None_create_events = True ) T5> ¶ T6>
inherited from the __init__() method of Boolean

构造一个布尔值。

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

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

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

__init__(length=None, **kwargs)

构建一个CHAR。

参数:
  • length – Maximum data length, in characters.
  • binary – Optional, use the default binary collation for the national character set. 这不会影响存储的数据类型,对二进制数据使用BINARY类型。
  • 整理 - 可选,请求特定的排序规则。必须与国家字符集兼容。
class sqlalchemy.dialects.mysql。 DATE

基础:sqlalchemy.types.Date

SQL DATE类型。

__初始化__ T0> ¶ T1>
inherited from the __init__ attribute of object

x .__ init __(...)初始化x;请参阅帮助(键入(x))进行签名

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

基础:sqlalchemy.types.DATETIME

MySQL DATETIME类型。

__init__(timezone=False, fsp=None)

构建一个MySQL DATETIME类型。

参数:
  • 时区 - MySQL方言没有使用。
  • fsp -

    小数秒精度值。MySQL 5.6.4支持小数秒的存储;当DATETIME类型发出DDL时,将使用此参数。

    注意

    DBAPI驱动程序支持小数秒可能会受到限制;目前的支持包括MySQL Connector / Python。

0.8.5版新增:增加了支持小数秒的特定于MySQL的mysql.DATETIME

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)

构建一个DECIMAL。

参数:
  • 精确度 - 这个数字的总数字。如果比例和精度均为无,则将值存储为服务器允许的限制。
  • scale – The number of digits after the decimal point.
  • 无符号 - 一个布尔值,可选。
  • zerofill - 可选。如果为true,则值将被存储为用零填充的字符串。请注意,这不会影响底层数据库API返回的值,这些值仍然是数字。
class sqlalchemy.dialects.mysql.DOUBLE(precision=None, scale=None, asdecimal=True, **kw)

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

MySQL DOUBLE类型。

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

构建一个DOUBLE。

注意

默认情况下,DOUBLE类型将从float转换为Decimal,并使用默认为10位的截断。指定scale=ndecimal_return_scale=n以更改此比例,或asdecimal=False直接以Python浮点形式返回值。

参数:
  • 精确度 - 这个数字的总数字。如果比例和精度均为无,则将值存储为服务器允许的限制。
  • scale – The number of digits after the decimal point.
  • 无符号 - 一个布尔值,可选。
  • zerofill - 可选。如果为true,则值将被存储为用零填充的字符串。请注意,这不会影响底层数据库API返回的值,这些值仍然是数字。
class sqlalchemy.dialects.mysql。 ENUM * enums**千瓦 T5> ) T6> ¶ T7>

基础:sqlalchemy.types.Enumsqlalchemy.dialects.mysql.enumerated._EnumeratedValues

MySQL ENUM类型。

__init__(*enums, **kw)

构建一个ENUM。

例如。:

Column('myenum', ENUM("foo", "bar", "baz"))
参数:
  • 枚举 -

    此ENUM的有效值范围。根据引用标志生成模式时,值将被引用(见下文)。该对象也可以是符合PEP-435的枚举类型。

  • 严格 -

    这个标志没有效果。

    版本更改: MySQL ENUM类型以及基本枚举类型现在验证所有Python数据值。

  • charset – Optional, a column-level character set for this string value. 优先使用“ascii”或“unicode”。
  • collation – Optional, a column-level collation for this string value. 优先考虑“二元”。
  • ascii – Defaults to False: short-hand for the latin1 character set, generates ASCII in schema.
  • unicode – Defaults to False: short-hand for the ucs2 character set, generates UNICODE in schema.
  • binary – Defaults to False: short-hand, pick the binary collation type that matches the column’s character set. 在模式中生成BINARY。这并不影响存储的数据类型,只是字符数据的排序规则。
  • 引用 -

    默认为'auto':自动确定枚举值引用。如果所有枚举值被相同的引用字符包围,则使用“引用”模式。否则,使用“未加引号”模式。

    '引用':枚举中的值已被引用,它们将在生成模式时直接使用 - 此用法已弃用。

    '不加引号':枚举中的值不被引用,在生成模式时,它们将被转义并被单引号包围。

    此类型的以前版本始终要求提供手动引用的值;未来的版本将总是引用你的字符串文字。这是一个过渡选项。

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)

构建FLOAT。

参数:
  • 精确度 - 这个数字的总数字。如果比例和精度均为无,则将值存储为服务器允许的限制。
  • scale – The number of digits after the decimal point.
  • 无符号 - 一个布尔值,可选。
  • zerofill - 可选。如果为true,则值将被存储为用零填充的字符串。请注意,这不会影响底层数据库API返回的值,这些值仍然是数字。
class sqlalchemy.dialects.mysql。 INTEGER display_width = None **千瓦 T5> ) T6> ¶ T7>

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

MySQL INTEGER类型。

__ init __ display_width = None** kw / T5>

构建一个INTEGER。

参数:
  • display_width – Optional, maximum display width for this number.
  • 无符号 - 一个布尔值,可选。
  • zerofill - 可选。如果为true,则值将被存储为用零填充的字符串。请注意,这不会影响底层数据库API返回的值,这些值仍然是数字。
class sqlalchemy.dialects.mysql。 JSON none_as_null = False ) T5> ¶ T6>

基础:sqlalchemy.types.JSON

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中的新功能

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

基础:sqlalchemy.types._Binary

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

class sqlalchemy.dialects.mysql。 LONGTEXT ** kwargs ) T5> ¶ T6>

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

MySQL LONGTEXT类型,文本最多2 ^ 32个字符。

__初始化__ T0> ( T1> ** kwargs T2> ) T3> ¶ T4>

构建一个LONGTEXT。

参数:
  • charset – Optional, a column-level character set for this string value. 优先使用“ascii”或“unicode”。
  • collation – Optional, a column-level collation for this string value. 优先考虑“二元”。
  • ascii – Defaults to False: short-hand for the latin1 character set, generates ASCII in schema.
  • unicode – Defaults to False: short-hand for the ucs2 character set, generates UNICODE in schema.
  • 国家 - 可选。如果为true,请使用服务器配置的国家字符集。
  • binary – Defaults to False: short-hand, pick the binary collation type that matches the column’s character set. 在模式中生成BINARY。这并不影响存储的数据类型,只是字符数据的排序规则。
class sqlalchemy.dialects.mysql.MEDIUMBLOB(length=None)

基础:sqlalchemy.types._Binary

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

class sqlalchemy.dialects.mysql。 tt> MEDIUMINT display_width = None **千瓦 T5> ) T6> ¶ T7>

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

MySQL MEDIUMINTEGER类型。

__ init __ display_width = None** kw / T5>

构建一个MEDIUMINTEGER

参数:
  • display_width – Optional, maximum display width for this number.
  • 无符号 - 一个布尔值,可选。
  • zerofill - 可选。如果为true,则值将被存储为用零填充的字符串。请注意,这不会影响底层数据库API返回的值,这些值仍然是数字。
class sqlalchemy.dialects.mysql。 MEDIUMTEXT ** kwargs ) T5> ¶ T6>

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

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

__初始化__ T0> ( T1> ** kwargs T2> ) T3> ¶ T4>

构建一个MEDIUMTEXT。

参数:
  • charset – Optional, a column-level character set for this string value. 优先使用“ascii”或“unicode”。
  • collation – Optional, a column-level collation for this string value. 优先考虑“二元”。
  • ascii – Defaults to False: short-hand for the latin1 character set, generates ASCII in schema.
  • unicode – Defaults to False: short-hand for the ucs2 character set, generates UNICODE in schema.
  • 国家 - 可选。如果为true,请使用服务器配置的国家字符集。
  • binary – Defaults to False: short-hand, pick the binary collation type that matches the column’s character set. 在模式中生成BINARY。这并不影响存储的数据类型,只是字符数据的排序规则。
class sqlalchemy.dialects.mysql。 NCHAR length = None ** kwargs T5> ) T6> ¶ T7>

Bases: sqlalchemy.dialects.mysql.types._StringType, sqlalchemy.types.NCHAR

MySQL的NCHAR类型。

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

__init__(length=None, **kwargs)

构建一个NCHAR。

参数:
  • length – Maximum data length, in characters.
  • binary – Optional, use the default binary collation for the national character set. 这不会影响存储的数据类型,对二进制数据使用BINARY类型。
  • 整理 - 可选,请求特定的排序规则。必须与国家字符集兼容。
class sqlalchemy.dialects.mysql.NUMERIC(precision=None, scale=None, asdecimal=True, **kw)

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

MySQL的NUMERIC类型。

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

构建一个NUMERIC。

参数:
  • 精确度 - 这个数字的总数字。如果比例和精度均为无,则将值存储为服务器允许的限制。
  • scale – The number of digits after the decimal point.
  • 无符号 - 一个布尔值,可选。
  • zerofill - 可选。如果为true,则值将被存储为用零填充的字符串。请注意,这不会影响底层数据库API返回的值,这些值仍然是数字。
class sqlalchemy.dialects.mysql。 NVARCHAR length = None ** kwargs T5> ) T6> ¶ T7>

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

MySQL NVARCHAR类型。

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

__init__(length=None, **kwargs)

构建一个NVARCHAR。

参数:
  • length – Maximum data length, in characters.
  • binary – Optional, use the default binary collation for the national character set. 这不会影响存储的数据类型,对二进制数据使用BINARY类型。
  • 整理 - 可选,请求特定的排序规则。必须与国家字符集兼容。
class sqlalchemy.dialects.mysql.REAL(precision=None, scale=None, asdecimal=True, **kw)

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

MySQL REAL类型。

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

构建一个真实的。

注意

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

参数:
  • 精确度 - 这个数字的总数字。如果比例和精度均为无,则将值存储为服务器允许的限制。
  • scale – The number of digits after the decimal point.
  • 无符号 - 一个布尔值,可选。
  • zerofill - 可选。如果为true,则值将被存储为用零填充的字符串。请注意,这不会影响底层数据库API返回的值,这些值仍然是数字。
class 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,那么这个潜在值列表是必需的。

参数:
  • values – The range of valid values for this SET.
  • convert_unicode – Same flag as that of String.convert_unicode.
  • 整理 - 和String.collation
  • charset – same as that of VARCHAR.charset.
  • ascii – same as that of VARCHAR.ascii.
  • unicode – same as that of VARCHAR.unicode.
  • binary – same as that of VARCHAR.binary.
  • 引用 -

    默认为“自动”:自动确定设定值引用。如果所有值都被相同的引用字符包围,则使用“引用”模式。否则,使用“未加引号”模式。

    '引用':枚举中的值已被引用,它们将在生成模式时直接使用 - 此用法已弃用。

    '不加引号':枚举中的值不被引用,在生成模式时,它们将被转义并被单引号包围。

    此类型的以前版本始终要求提供手动引用的值;未来的版本将总是引用你的字符串文字。这是一个过渡选项。

    版本0.9.0中新增。

  • retrieve_as_bitwise -

    如果为True,那么set类型的数据将被持久化并使用整数值进行选择,其中一组被强制为持久性的按位掩码。MySQL允许这种模式具有能够明确存储值的优点,如空字符串''”。在SELECT语句中,数据类型将出现为表达式col + 0,所以该值被强制转换结果集中的整数值。如果希望保留一个可以存储空字符串''作为值的集合,则此标志是必需的。

    警告

    当使用mysql.SET.retrieve_as_bitwise时,设置值列表必须以与MySQL数据库上存在的完全相同的顺序表示。

    版本1.0.0中的新功能

class sqlalchemy.dialects.mysql。 SMALLINT display_width = None **千瓦 T5> ) T6> ¶ T7>

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

MySQL SMALLINTEGER类型。

__ init __ display_width = None** kw / T5>

构建一个SMALLINTEGER。

参数:
  • display_width – Optional, maximum display width for this number.
  • 无符号 - 一个布尔值,可选。
  • zerofill - 可选。如果为true,则值将被存储为用零填充的字符串。请注意,这不会影响底层数据库API返回的值,这些值仍然是数字。
class sqlalchemy.dialects.mysql。 TEXT length = None **千瓦 T5> ) T6> ¶ T7>

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

MySQL文本类型,文本最多2 ^ 16个字符。

__init__(length=None, **kw)

构建一个TEXT。

参数:
  • length – Optional, if provided the server may optimize storage by substituting the smallest TEXT type sufficient to store length characters.
  • charset – Optional, a column-level character set for this string value. 优先使用“ascii”或“unicode”。
  • collation – Optional, a column-level collation for this string value. 优先考虑“二元”。
  • ascii – Defaults to False: short-hand for the latin1 character set, generates ASCII in schema.
  • unicode – Defaults to False: short-hand for the ucs2 character set, generates UNICODE in schema.
  • 国家 - 可选。如果为true,请使用服务器配置的国家字符集。
  • binary – Defaults to False: short-hand, pick the binary collation type that matches the column’s character set. 在模式中生成BINARY。这并不影响存储的数据类型,只是字符数据的排序规则。
class sqlalchemy.dialects.mysql.TIME(timezone=False, fsp=None)

基础:sqlalchemy.types.TIME

MySQL时间类型。

__init__(timezone=False, fsp=None)

构建一个MySQL TIME类型。

参数:
  • 时区 - MySQL方言没有使用。
  • fsp -

    小数秒精度值。MySQL 5.6支持小数秒的存储;当为TIME类型发出DDL时将使用此参数。

    注意

    DBAPI驱动程序支持小数秒可能会受到限制;目前的支持包括MySQL Connector / Python。

New in version 0.8: The MySQL-specific TIME type as well as fractional seconds support.

class sqlalchemy.dialects.mysql。 TIMESTAMP timezone = False FSP =无 T5> ) T6> ¶ T7>

基础:sqlalchemy.types.TIMESTAMP

MySQL的TIMESTAMP类型。

__init__(timezone=False, fsp=None)

构建一个MySQL TIMESTAMP类型。

参数:
  • 时区 - MySQL方言没有使用。
  • fsp -

    小数秒精度值。MySQL 5.6.4支持小数秒的存储;当为TIMESTAMP类型发出DDL时将使用此参数。

    注意

    DBAPI驱动程序支持小数秒可能会受到限制;目前的支持包括MySQL Connector / Python。

0.8.5版新增:增加了支持小数秒的特定于MySQL的mysql.TIMESTAMP

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

基础:sqlalchemy.types._Binary

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

class sqlalchemy.dialects.mysql。 tt> TINYINT display_width = None **千瓦 T5> ) T6> ¶ T7>

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

MySQL的TINYINT类型。

__ init __ display_width = None** kw / T5>

构建一个TINYINT。

参数:
  • display_width – Optional, maximum display width for this number.
  • 无符号 - 一个布尔值,可选。
  • zerofill - 可选。如果为true,则值将被存储为用零填充的字符串。请注意,这不会影响底层数据库API返回的值,这些值仍然是数字。
类 T0> sqlalchemy.dialects.mysql。 T1> TINYTEXT T2> ( T3> ** kwargs T4> ) T5> ¶ T6>

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

MySQL TINYTEXT类型,文本最多2 ^ 8个字符。

__初始化__ T0> ( T1> ** kwargs T2> ) T3> ¶ T4>

构建一个TINYTEXT。

参数:
  • charset – Optional, a column-level character set for this string value. 优先使用“ascii”或“unicode”。
  • collation – Optional, a column-level collation for this string value. 优先考虑“二元”。
  • ascii – Defaults to False: short-hand for the latin1 character set, generates ASCII in schema.
  • unicode – Defaults to False: short-hand for the ucs2 character set, generates UNICODE in schema.
  • 国家 - 可选。如果为true,请使用服务器配置的国家字符集。
  • binary – Defaults to False: short-hand, pick the binary collation type that matches the column’s character set. 在模式中生成BINARY。这并不影响存储的数据类型,只是字符数据的排序规则。
class sqlalchemy.dialects.mysql.VARBINARY(length=None)

基础:sqlalchemy.types._Binary

SQL VARBINARY类型。

class sqlalchemy.dialects.mysql。 VARCHAR length = None ** kwargs T5> ) T6> ¶ T7>

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

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

__init__(length=None, **kwargs)

构建一个VARCHAR。

参数:
  • charset – Optional, a column-level character set for this string value. 优先使用“ascii”或“unicode”。
  • collation – Optional, a column-level collation for this string value. 优先考虑“二元”。
  • ascii – Defaults to False: short-hand for the latin1 character set, generates ASCII in schema.
  • unicode – Defaults to False: short-hand for the ucs2 character set, generates UNICODE in schema.
  • 国家 - 可选。如果为true,请使用服务器配置的国家字符集。
  • binary – Defaults to False: short-hand, pick the binary collation type that matches the column’s character set. 在模式中生成BINARY。这并不影响存储的数据类型,只是字符数据的排序规则。
class sqlalchemy.dialects.mysql。 YEAR display_width = None ) T5> ¶ T6>

基础:sqlalchemy.types.TypeEngine

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

的MySQL的Python ¶ T0>

通过MySQL-Python驱动程序支持MySQL数据库。

DBAPI ¶ T0>

MySQL-Python的文档和下载信息(如果适用)可在以下网址找到:http://sourceforge.net/projects/mysql-python

连接¶ T0>

连接字符串:

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

Unicode的¶ T0>

有关unicode处理的当前建议,请参阅Unicode

Py3K支持

目前,MySQLdb只在Python 2上运行,开发已经停止。mysqlclient is fork of MySQLdb and provides Python 3 support as well as some bugfixes.

在Google Cloud SQL中使用MySQLdb

Google云端SQL现在推荐使用MySQLdb方言。使用以下URL连接:

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

pymysql ¶ T0>

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

DBAPI ¶ T0>

有关PyMySQL的文档和下载信息(如果适用)可在以下网址获得:http://www.pymysql.org/

连接¶ T0>

连接字符串:

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

Unicode的¶ T0>

有关unicode处理的当前建议,请参阅Unicode

MySQL-Python兼容性

pymysql DBAPI是MySQL-python(MySQLdb)驱动程序的纯Python端口,它的目标是100%的兼容性。MySQL-python的大多数行为注释也适用于pymysql驱动程序。

MySQL的 - 连接器¶ T0>

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

DBAPI ¶ T0>

MySQL连接器/ Python的文档和下载信息(如果适用)可在以下网址获得:http://dev.mysql.com/downloads/connector/python/

连接¶ T0>

连接字符串:

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

Unicode的¶ T0>

有关unicode处理的当前建议,请参阅Unicode

cymysql ¶ T0>

通过CyMySQL驱动程序支持MySQL数据库。

DBAPI ¶ T0>

CyMySQL的文档和下载信息(如适用)可在以下网址找到:https://github.com/nakagami/CyMySQL

连接¶ T0>

连接字符串:

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

OurSQL ¶ T0>

通过OurSQL驱动程序支持MySQL数据库。

DBAPI ¶ T0>

OurSQL的文档和下载信息(如果适用)可在以下网址找到:http://packages.python.org/oursql/

连接¶ T0>

连接字符串:

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

Unicode的¶ T0>

有关unicode处理的当前建议,请参阅Unicode

Google App Engine

通过Google Cloud SQL驱动程序支持MySQL数据库。

这种方言主要基于mysql.mysqldb方言,只需要很少的改动。

版本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>

DBAPI ¶ T0>

有关Google Cloud SQL的文档和下载信息(如果适用),请访问:https://developers.google.com/appengine/docs/python/cloud-sql/developers-guide

连接¶ T0>

连接字符串:

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

汇集¶ T0>

Google App Engine连接似乎是随机回收的,所以方言不会汇集连接。默认情况下,NullPool实现安装在Engine中。

pyodbc ¶ T0>

通过PyODBC驱动程序支持MySQL数据库。

注意

PyODBC for MySQL方言得不到很好的支持,并且会受到当前ODBC驱动程序中存在的未解决的字符编码问题的影响。(请参阅http://code.google.com/p/pyodbc/issues/detail?id=25)。其他MySQL的方言推荐。

DBAPI ¶ T0>

PyODBC的文档和下载信息(如果适用)可在以下网址获得:http://pypi.python.org/pypi/pyodbc/

连接¶ T0>

连接字符串:

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

zxjdbc ¶ T0>

通过Jython驱动程序的zxjdbc支持MySQL数据库。

注意

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

DBAPI ¶ T0>

此数据库的驱动程序可在以下位置获得:http://dev.mysql.com/downloads/connector/j/

连接¶ T0>

连接字符串:

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

字符集

SQLAlchemy zxjdbc方言将unicode直接传递给zxjdbc / JDBC层。为了允许从MySQL Connector / J JDBC驱动程序发送多个字符集,默认情况下,SQLAlchemy将它的characterEncoding连接属性设置为UTF-8它可以通过create_engine URL参数覆盖。