Current File : //opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyc
�
��4]c @ s� d Z d d l m Z d d l m Z d d l Z d d l Z d d l m Z d d l
m Z d d l
m Z d d l
m Z d d
l
m Z d d l
m Z d d l m Z d d
l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m! Z! d d l m" Z" d d l m# Z# d d l m$ Z$ d d l m% Z% d d l m& Z& d d! l m' Z' d d" l m( Z( d d# l m) Z) d d$ l m* Z* d d% l m+ Z+ d d& l m, Z, d d' l m- Z- d d( l m. Z. d d) l m/ Z/ d d* l m0 Z0 d+ d, l m1 Z1 d+ d- l m2 Z2 d+ d. l m3 Z4 d+ d/ l m5 Z5 d+ d0 l m Z6 d+ d1 l m7 Z7 d+ d2 l8 m9 Z9 d+ d l8 m Z d+ d3 l5 m: Z: d+ d4 l5 m; Z; d+ d5 l m< Z< d+ d6 l m= Z= d+ d7 l m> Z> d+ d8 l m? Z? d+ d9 l m@ Z@ d+ d: l7 mA ZA eB d; d< d= d> d? d@ dA dB dC dD dE dF dG dH dI dJ dK dL dM dN dO dP dQ dR dS dT dU dV dW dX dY dZ d[ d\ d] d^ d_ d` da db dc dd de df dg dh di dj dk dl dm dn do dp dq dr ds dt du dv dw dx dy dz d{ d| d} d~ d d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d ddddddddd d
d d d
ddddddddddddddd d d d d d; d� d� d� d� d� d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLg� ZC e jD dMe jE e jF B� ZG e jD dNe jE e jF B� ZH e* ZI e ZJ e ZK e ZL e! ZM e, ZN e= ZO e< ZP e@ ZQ e$ ZR e& ZS e ZT e/ ZU e ZV e# ZW e. ZX e) ZY e0 ZZ e+ Z[ e Z\ e( Z] e- Z^ e" Z_ e Z` e% Za e Zb e Zc e' Zd e Ze e Zf i e e 6e e 6e e 6e% e6 jg 6e e6 jh 6e* e6 ji 6e e6 jj 6e e6 jk 6e e6 j 6e e6 j j 6e e6 j j 6Zl i# e dF 6e< dG 6e dO6e= dH 6e> dP6e dO 6e? dQ6e dR6e df 6e dq 6e dS6e dT6e d~ 6e d� 6e d� 6e dU6e d� 6e d� 6e! d� 6e" d� 6e# d� 6e$ dV6e& dW6e% d� 6e d� 6e( d� 6e) dX6e* dY6e+ dZ6e, d� 6e- d� 6e. d� 6e@ d6e/ d6e0 d[6Zm d\e9 jn f d]� � YZo d^e: jp f d_� � YZq d`e: jr f da� � YZs dbe: jt f dc� � YZu dde: jv f de� � YZw e2 jx dfe9 jy f dg� � Y� Zz dhe{ f di� � YZ| d S(j s�m
.. dialect:: mysql
:name: MySQL
Supported Versions and Features
-------------------------------
SQLAlchemy supports MySQL starting with version 4.1 through modern releases.
However, no heroic measures are taken to work around major missing
SQL features - if your server version does not support sub-selects, for
example, they won't work in SQLAlchemy either.
See the official MySQL documentation for detailed information about features
supported in any given server release.
.. _mysql_connection_timeouts:
Connection Timeouts and Disconnects
-----------------------------------
MySQL features an automatic connection close behavior, for connections that
have been idle for a fixed period of time, defaulting to eight hours.
To circumvent having this issue, use
the :paramref:`.create_engine.pool_recycle` option which ensures that
a connection will be discarded and replaced with a new one if it has been
present in the pool for a fixed number of seconds::
engine = create_engine('mysql+mysqldb://...', pool_recycle=3600)
For more comprehensive disconnect detection of pooled connections, including
accommodation of server restarts and network issues, a pre-ping approach may
be employed. See :ref:`pool_disconnects` for current approaches.
.. seealso::
:ref:`pool_disconnects` - Background on several techniques for dealing
with timed out connections as well as database restarts.
.. _mysql_storage_engines:
CREATE TABLE arguments including Storage Engines
------------------------------------------------
MySQL's CREATE TABLE syntax includes a wide array of special options,
including ``ENGINE``, ``CHARSET``, ``MAX_ROWS``, ``ROW_FORMAT``,
``INSERT_METHOD``, and many more.
To accommodate the rendering of these arguments, specify the form
``mysql_argument_name="value"``. For example, to specify a table with
``ENGINE`` of ``InnoDB``, ``CHARSET`` of ``utf8mb4``, and ``KEY_BLOCK_SIZE``
of ``1024``::
Table('mytable', metadata,
Column('data', String(32)),
mysql_engine='InnoDB',
mysql_charset='utf8mb4',
mysql_key_block_size="1024"
)
The MySQL dialect will normally transfer any keyword specified as
``mysql_keyword_name`` to be rendered as ``KEYWORD_NAME`` in the
``CREATE TABLE`` statement. 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``).
The most common argument is ``mysql_engine``, which refers to the storage
engine for the table. Historically, MySQL server installations would default
to ``MyISAM`` for this value, although newer versions may be defaulting
to ``InnoDB``. The ``InnoDB`` engine is typically preferred for its support
of transactions and foreign keys.
A :class:`.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. It also will have no support for foreign key constraints; while
the ``CREATE TABLE`` statement accepts foreign key options, when using the
``MyISAM`` storage engine these arguments are discarded. Reflecting such a
table will also produce no foreign key constraint information.
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``.
.. seealso::
`The InnoDB Storage Engine
<http://dev.mysql.com/doc/refman/5.0/en/innodb-storage-engine.html>`_ -
on the MySQL website.
Case Sensitivity and Table Reflection
-------------------------------------
MySQL has inconsistent support for case-sensitive identifier
names, basing support on specific details of the underlying
operating system. 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.
Therefore it is strongly advised that table names be declared as
all lower case both within SQLAlchemy as well as on the MySQL
database itself, especially if database reflection features are
to be used.
.. _mysql_isolation_level:
Transaction Isolation Level
---------------------------
All MySQL dialects support setting of transaction isolation level both via a
dialect-specific parameter :paramref:`.create_engine.isolation_level` accepted
by :func:`.create_engine`, as well as the
:paramref:`.Connection.execution_options.isolation_level` argument as passed to
:meth:`.Connection.execution_options`. This feature works by issuing the
command ``SET SESSION TRANSACTION ISOLATION LEVEL <level>`` for each new
connection. For the special AUTOCOMMIT isolation level, DBAPI-specific
techniques are used.
To set isolation level using :func:`.create_engine`::
engine = create_engine(
"mysql://scott:tiger@localhost/test",
isolation_level="READ UNCOMMITTED"
)
To set using per-connection execution options::
connection = engine.connect()
connection = connection.execution_options(
isolation_level="READ COMMITTED"
)
Valid values for ``isolation_level`` include:
* ``READ COMMITTED``
* ``READ UNCOMMITTED``
* ``REPEATABLE READ``
* ``SERIALIZABLE``
* ``AUTOCOMMIT``
The special ``AUTOCOMMIT`` value makes use of the various "autocommit"
attributes provided by specific DBAPIs, and is currently supported by
MySQLdb, MySQL-Client, MySQL-Connector Python, and PyMySQL. Using it,
the MySQL connection will return true for the value of
``SELECT @@autocommit;``.
.. versionadded:: 1.1 - added support for the AUTOCOMMIT isolation level.
AUTO_INCREMENT Behavior
-----------------------
When creating tables, SQLAlchemy will automatically set ``AUTO_INCREMENT`` on
the first :class:`.Integer` primary key column which is not marked as a
foreign key::
>>> 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)
)
You can disable this behavior by passing ``False`` to the
:paramref:`~.Column.autoincrement` argument of :class:`.Column`. This flag
can also be used to enable auto-increment on a secondary column in a
multi-column key for some storage engines::
Table('mytable', metadata,
Column('gid', Integer, primary_key=True, autoincrement=False),
Column('id', Integer, primary_key=True)
)
.. _mysql_ss_cursors:
Server Side Cursors
-------------------
Server-side cursor support is available for the MySQLdb and PyMySQL dialects.
From a MySQL point of view this means that the ``MySQLdb.cursors.SSCursor`` or
``pymysql.cursors.SSCursor`` class is used when building up the cursor which
will receive results. The most typical way of invoking this feature is via the
:paramref:`.Connection.execution_options.stream_results` connection execution
option. Server side cursors can also be enabled for all SELECT statements
unconditionally by passing ``server_side_cursors=True`` to
:func:`.create_engine`.
.. versionadded:: 1.1.4 - added server-side cursor support.
.. _mysql_unicode:
Unicode
-------
Charset Selection
~~~~~~~~~~~~~~~~~
Most MySQL DBAPIs offer the option to set the client character set for
a connection. This is typically delivered using the ``charset`` parameter
in the URL, such as::
e = create_engine(
"mysql+pymysql://scott:tiger@localhost/test?charset=utf8mb4")
This charset is the **client character set** for the connection. 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. Documentation for the DBAPI in use should be consulted
for specific behavior.
The encoding used for Unicode has traditionally been ``'utf8'``. However,
for MySQL versions 5.5.3 on forward, a new MySQL-specific encoding
``'utf8mb4'`` has been introduced, and as of MySQL 8.0 a warning is emitted
by the server if plain ``utf8`` is specified within any server-side
directives, replaced with ``utf8mb3``. The rationale for this new encoding
is due to the fact that MySQL's legacy utf-8 encoding only supports
codepoints up to three bytes instead of four. Therefore,
when communicating with a MySQL database
that includes codepoints more than three bytes in size,
this new charset is preferred, if supported by both the database as well
as the client DBAPI, as in::
e = create_engine(
"mysql+pymysql://scott:tiger@localhost/test?charset=utf8mb4")
All modern DBAPIs should support the ``utf8mb4`` charset.
In order to use ``utf8mb4`` encoding for a schema that was created with legacy
``utf8``, changes to the MySQL schema and/or server configuration may be
required.
.. seealso::
`The utf8mb4 Character Set \
<http://dev.mysql.com/doc/refman/5.5/en/charset-unicode-utf8mb4.html>`_ - \
in the MySQL documentation
.. _mysql_binary_introducer:
Dealing with Binary Data Warnings and Unicode
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
MySQL versions 5.6, 5.7 and later (not MariaDB at the time of this writing) now
emit a warning when attempting to pass binary data to the database, while a
character set encoding is also in place, when the binary data itself is not
valid for that encoding::
default.py:509: Warning: (1300, "Invalid utf8mb4 character string:
'F9876A'")
cursor.execute(statement, parameters)
This warning is due to the fact that the MySQL client library is attempting to
interpret the binary string as a unicode object even if a datatype such
as :class:`.LargeBinary` is in use. To resolve this, the SQL statement requires
a binary "character set introducer" be present before any non-NULL value
that renders like this::
INSERT INTO table (data) VALUES (_binary %s)
These character set introducers are provided by the DBAPI driver, assuming the
use of mysqlclient or PyMySQL (both of which are recommended). Add the query
string parameter ``binary_prefix=true`` to the URL to repair this warning::
# 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")
The ``binary_prefix`` flag may or may not be supported by other MySQL drivers.
SQLAlchemy itself cannot render this ``_binary`` prefix reliably, as it does
not work with the NULL value, which is valid to be sent as a bound parameter.
As the MySQL driver renders parameters directly into the SQL string, it's the
most efficient place for this additional keyword to be passed.
.. seealso::
`Character set introducers <https://dev.mysql.com/doc/refman/5.7/en/charset-introducer.html>`_ - on the MySQL website
ANSI Quoting Style
------------------
MySQL features two varieties of identifier "quoting style", one using
backticks and the other using quotes, e.g. ```some_identifier``` vs.
``"some_identifier"``. All MySQL dialects detect which version
is in use by checking the value of ``sql_mode`` when a connection is first
established with a particular :class:`.Engine`. This quoting style comes
into play when rendering table and column names as well as when reflecting
existing database structures. The detection is entirely automatic and
no special configuration is needed to use either quoting style.
MySQL SQL Extensions
--------------------
Many of the MySQL SQL extensions are handled through SQLAlchemy's generic
function and operator support::
table.select(table.c.password==func.md5('plaintext'))
table.select(table.c.username.op('regexp')('^[a-d]'))
And of course any valid MySQL statement can be executed as a string as well.
Some limited direct support for MySQL extensions to SQL is currently
available.
* INSERT..ON DUPLICATE KEY UPDATE: See
:ref:`mysql_insert_on_duplicate_key_update`
* SELECT pragma, use :meth:`.Select.prefix_with` and :meth:`.Query.prefix_with`::
select(...).prefix_with(['HIGH_PRIORITY', 'SQL_SMALL_RESULT'])
* UPDATE with LIMIT::
update(..., mysql_limit=10)
* optimizer hints, use :meth:`.Select.prefix_with` and :meth:`.Query.prefix_with`::
select(...).prefix_with("/*+ NO_RANGE_OPTIMIZATION(t4 PRIMARY) */")
* index hints, use :meth:`.Select.with_hint` and :meth:`.Query.with_hint`::
select(...).with_hint(some_table, "USE INDEX xyz")
.. _mysql_insert_on_duplicate_key_update:
INSERT...ON DUPLICATE KEY UPDATE (Upsert)
------------------------------------------
MySQL allows "upserts" (update or insert)
of rows into a table via the ``ON DUPLICATE KEY UPDATE`` clause of the
``INSERT`` statement. A candidate row will only be inserted if that row does
not match an existing primary or unique key in the table; otherwise, an UPDATE
will be performed. The statement allows for separate specification of the
values to INSERT versus the values for UPDATE.
SQLAlchemy provides ``ON DUPLICATE KEY UPDATE`` support via the MySQL-specific
:func:`.mysql.dml.insert()` function, which provides
the generative method :meth:`~.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)
Unlike PostgreSQL's "ON CONFLICT" phrase, the "ON DUPLICATE KEY UPDATE"
phrase will always match on any primary key or unique key, and will always
perform an UPDATE if there's a match; there are no options for it to raise
an error or to skip performing an UPDATE.
``ON DUPLICATE KEY UPDATE`` is used to perform an update of the already
existing row, using any combination of new values as well as values
from the proposed insertion. These values are normally specified using
keyword arguments passed to the
:meth:`~.mysql.dml.Insert.on_duplicate_key_update`
given column key values (usually the name of the column, unless it
specifies :paramref:`.Column.key`) as keys and literal or SQL expressions
as values::
on_duplicate_key_stmt = insert_stmt.on_duplicate_key_update(
data="some data",
updated_at=func.current_timestamp(),
)
In a manner similar to that of :meth:`.UpdateBase.values`, other parameter
forms are accepted, including a single dictionary::
on_duplicate_key_stmt = insert_stmt.on_duplicate_key_update(
{"data": "some data", "updated_at": func.current_timestamp()},
)
as well as a list of 2-tuples, which will automatically provide
a parameter-ordered UPDATE statement in a manner similar to that described
at :ref:`updates_order_parameters`. Unlike the :class:`.Update` object,
no special flag is needed to specify the intent since the argument form is
this context is unambiguous::
on_duplicate_key_stmt = insert_stmt.on_duplicate_key_update(
[
("data", "some data"),
("updated_at", func.current_timestamp()),
],
)
.. versionchanged:: 1.3 support for parameter-ordered UPDATE clause within
MySQL ON DUPLICATE KEY UPDATE
.. warning::
The :meth:`.Insert.on_duplicate_key_update` method does **not** take into
account Python-side default UPDATE values or generation functions, e.g.
e.g. those specified using :paramref:`.Column.onupdate`.
These values will not be exercised for an ON DUPLICATE KEY style of UPDATE,
unless they are manually specified explicitly in the parameters.
In order to refer to the proposed insertion row, the special alias
:attr:`~.mysql.dml.Insert.inserted` is available as an attribute on
the :class:`.mysql.dml.Insert` object; this object is a
:class:`.ColumnCollection` which contains all columns of the target
table::
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)
When rendered, the "inserted" namespace will produce the expression
``VALUES(<columnname>)``.
.. versionadded:: 1.2 Added support for MySQL ON DUPLICATE KEY UPDATE clause
rowcount Support
----------------
SQLAlchemy standardizes the DBAPI ``cursor.rowcount`` attribute to be the
usual definition of "number of rows matched by an UPDATE or DELETE" statement.
This is in contradiction to the default setting on most MySQL DBAPI drivers,
which is "number of rows actually modified/deleted". For this reason, the
SQLAlchemy MySQL dialects always add the ``constants.CLIENT.FOUND_ROWS``
flag, or whatever is equivalent for the target dialect, upon connection.
This setting is currently hardcoded.
.. seealso::
:attr:`.ResultProxy.rowcount`
CAST Support
------------
MySQL documents the CAST operator as available in version 4.0.2. When using
the SQLAlchemy :func:`.cast` function, SQLAlchemy
will not render the CAST token on MySQL before this version, based on server
version detection, instead rendering the internal expression directly.
CAST may still not be desirable on an early MySQL version post-4.0.2, as it
didn't add all datatype support until 4.1.1. If your application falls into
this narrow area, the behavior of CAST can be controlled using the
:ref:`sqlalchemy.ext.compiler_toplevel` system, as per the recipe below::
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)
The above function, which only needs to be declared once
within an application, overrides the compilation of the
:func:`.cast` construct to check for version 4.1.0 before
fully rendering CAST; else the internal element of the
construct is rendered directly.
.. _mysql_indexes:
MySQL Specific Index Options
----------------------------
MySQL-specific extensions to the :class:`.Index` construct are available.
Index Length
~~~~~~~~~~~~~
MySQL provides an option to create index entries with a certain length, where
"length" refers to the number of characters or bytes in each value which will
become part of the index. SQLAlchemy provides this feature via the
``mysql_length`` parameter::
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})
Prefix lengths are given in characters for nonbinary string types and in bytes
for binary string types. The value passed to the keyword argument *must* be
either an integer (and, thus, specify the same prefix length value for all
columns of the index) or a dict in which keys are column names and values are
prefix length values for corresponding columns. MySQL only allows a length for
a column of an index if it is for a CHAR, VARCHAR, TEXT, BINARY, VARBINARY and
BLOB.
Index Prefixes
~~~~~~~~~~~~~~
MySQL storage engines permit you to specify an index prefix when creating
an index. SQLAlchemy provides this feature via the
``mysql_prefix`` parameter on :class:`.Index`::
Index('my_index', my_table.c.data, mysql_prefix='FULLTEXT')
The value passed to the keyword argument will be simply passed through to the
underlying CREATE INDEX, so it *must* be a valid index prefix for your MySQL
storage engine.
.. versionadded:: 1.1.5
.. seealso::
`CREATE INDEX <http://dev.mysql.com/doc/refman/5.0/en/create-index.html>`_ - MySQL documentation
Index Types
~~~~~~~~~~~~~
Some MySQL storage engines permit you to specify an index type when creating
an index or primary key constraint. SQLAlchemy provides this feature via the
``mysql_using`` parameter on :class:`.Index`::
Index('my_index', my_table.c.data, mysql_using='hash')
As well as the ``mysql_using`` parameter on :class:`.PrimaryKeyConstraint`::
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.
More information can be found at:
http://dev.mysql.com/doc/refman/5.0/en/create-index.html
http://dev.mysql.com/doc/refman/5.0/en/create-table.html
Index Parsers
~~~~~~~~~~~~~
CREATE FULLTEXT INDEX in MySQL also supports a "WITH PARSER" option. This
is available using the keyword argument ``mysql_with_parser``::
Index(
'my_index', my_table.c.data,
mysql_prefix='FULLTEXT', mysql_with_parser="ngram")
.. versionadded:: 1.3
.. _mysql_foreign_keys:
MySQL Foreign Keys
------------------
MySQL's behavior regarding foreign keys has some important caveats.
Foreign Key Arguments to Avoid
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
MySQL does not support the foreign key arguments "DEFERRABLE", "INITIALLY",
or "MATCH". Using the ``deferrable`` or ``initially`` keyword argument with
:class:`.ForeignKeyConstraint` or :class:`.ForeignKey` will have the effect of
these keywords being rendered in a DDL expression, which will then raise an
error on MySQL. In order to use these keywords on a foreign key while having
them ignored on a MySQL backend, use a custom compile rule::
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)
.. versionchanged:: 0.9.0 - the MySQL backend no longer silently ignores
the ``deferrable`` or ``initially`` keyword arguments of
:class:`.ForeignKeyConstraint` and :class:`.ForeignKey`.
The "MATCH" keyword is in fact more insidious, and is explicitly disallowed
by SQLAlchemy in conjunction with the MySQL backend. This argument is
silently ignored by MySQL, but in addition has the effect of ON UPDATE and ON
DELETE options also being ignored by the backend. Therefore MATCH should
never be used with the MySQL backend; as is the case with DEFERRABLE and
INITIALLY, custom compilation rules can be used to correct a MySQL
ForeignKeyConstraint at DDL definition time.
.. versionadded:: 0.9.0 - the MySQL backend will raise a
:class:`.CompileError` when the ``match`` keyword is used with
:class:`.ForeignKeyConstraint` or :class:`.ForeignKey`.
Reflection of Foreign Key Constraints
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Not all MySQL storage engines support foreign keys. When using the
very common ``MyISAM`` MySQL storage engine, the information loaded by table
reflection will not include foreign keys. For these tables, you may supply a
:class:`~sqlalchemy.ForeignKeyConstraint` at reflection time::
Table('mytable', metadata,
ForeignKeyConstraint(['other_id'], ['othertable.other_id']),
autoload=True
)
.. seealso::
:ref:`mysql_storage_engines`
.. _mysql_unique_constraints:
MySQL Unique Constraints and Reflection
---------------------------------------
SQLAlchemy supports both the :class:`.Index` construct with the
flag ``unique=True``, indicating a UNIQUE index, as well as the
:class:`.UniqueConstraint` construct, representing a UNIQUE constraint.
Both objects/syntaxes are supported by MySQL when emitting DDL to create
these constraints. However, MySQL does not have a unique constraint
construct that is separate from a unique index; that is, the "UNIQUE"
constraint on MySQL is equivalent to creating a "UNIQUE INDEX".
When reflecting these constructs, the :meth:`.Inspector.get_indexes`
and the :meth:`.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 :class:`.UniqueConstraint` construct is
**not** part of the fully reflected :class:`.Table` construct under any
circumstances; this construct is always represented by a :class:`.Index`
with the ``unique=True`` setting present in the :attr:`.Table.indexes`
collection.
.. _mysql_timestamp_null:
TIMESTAMP Columns and NULL
--------------------------
MySQL historically enforces that a column which specifies the
TIMESTAMP datatype implicitly includes a default value of
CURRENT_TIMESTAMP, even though this is not stated, and additionally
sets the column as NOT NULL, the opposite behavior vs. that of all
other datatypes::
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
Above, we see that an INTEGER column defaults to NULL, unless it is specified
with NOT NULL. But when the column is of type TIMESTAMP, an implicit
default of CURRENT_TIMESTAMP is generated which also coerces the column
to be a NOT NULL, even though we did not specify it as such.
This behavior of MySQL can be changed on the MySQL side using the
`explicit_defaults_for_timestamp
<http://dev.mysql.com/doc/refman/5.6/en/server-system-variables.html
#sysvar_explicit_defaults_for_timestamp>`_ configuration flag introduced in
MySQL 5.6. With this server setting enabled, TIMESTAMP columns behave like
any other datatype on the MySQL side with regards to defaults and nullability.
However, to accommodate the vast majority of MySQL databases that do not
specify this new flag, SQLAlchemy emits the "NULL" specifier explicitly with
any TIMESTAMP column that does not specify ``nullable=False``. In order to
accommodate newer databases that specify ``explicit_defaults_for_timestamp``,
SQLAlchemy also emits NOT NULL for TIMESTAMP columns that do specify
``nullable=False``. The following example illustrates::
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)
output::
CREATE TABLE ts_test (
a INTEGER,
b INTEGER NOT NULL,
c TIMESTAMP NULL,
d TIMESTAMP NOT NULL
)
.. versionchanged:: 1.0.0 - SQLAlchemy now renders NULL or NOT NULL in all
cases for TIMESTAMP columns, to accommodate
``explicit_defaults_for_timestamp``. Prior to this version, it will
not render "NOT NULL" for a TIMESTAMP column that is ``nullable=False``.
i����( t array( t defaultdictNi ( t
reflection( t ENUM( t SET( t JSON( t
JSONIndexType( t JSONPathType( t
_FloatType( t _IntegerType( t
_MatchType( t _NumericType( t _StringType( t BIGINT( t BIT( t CHAR( t DATETIME( t DECIMAL( t DOUBLE( t FLOAT( t INTEGER( t LONGBLOB( t LONGTEXT( t
MEDIUMBLOB( t MEDIUMINT( t
MEDIUMTEXT( t NCHAR( t NUMERIC( t NVARCHAR( t REAL( t SMALLINT( t TEXT( t TIME( t TIMESTAMP( t TINYBLOB( t TINYINT( t TINYTEXT( t VARCHAR( t YEARi ( t exc( t log( t schema( t sql( t types( t util( t default( t compiler( t elements( t BINARY( t BLOB( t BOOLEAN( t DATE( t VARBINARY( t topologicalt
accessiblet addt allt altert analyzet andt ast asct
asensitivet beforet betweent bigintt binaryt blobt botht byt callt cascadet caset changet chart charactert checkt collatet columnt conditiont
constraintt continuet convertt createt crosst current_datet current_timet current_timestampt current_usert cursort databaset databasest day_hourt day_microsecondt
day_minutet
day_secondt dect decimalt declareR- t delayedt deletet desct describet
deterministict distinctt distinctrowt divt doublet dropt dualt eacht elset elseift enclosedt escapedt existst exitt explaint falset fetcht floatt float4t float8t fort forcet foreignt fromt fulltextt grantt groupt havingt
high_priorityt hour_microsecondt hour_minutet hour_secondt ift ignoret int indext infilet innert inoutt insensitivet insertt intt int1t int2t int3t int4t int8t integert intervalt intot ist iteratet joint keyt keyst killt leadingt leavet leftt liket limitt lineart linest loadt localtimet localtimestampt lockt longt longblobt longtextt loopt low_priorityt master_ssl_verify_server_certt matcht
mediumblobt mediumintt
mediumtextt middleintt minute_microsecondt
minute_secondt modt modifiest naturalt nott no_write_to_binlogt nullt numerict ont optimizet optiont
optionallyt ort ordert outt outert outfilet precisiont primaryt proceduret purget ranget readt readst read_onlyt
read_writet realt
referencest regexpt releaset renamet repeatt replacet requiret restrictt returnt revoket rightt rlikeR) t schemast second_microsecondt selectt sensitivet separatort sett showt smallintt spatialt specificR* t sqlexceptiont sqlstatet
sqlwarningt sql_big_resultt sql_calc_found_rowst sql_small_resultt sslt startingt
straight_joint tablet
terminatedt thent tinyblobt tinyintt tinytextt tot trailingt triggert truet undot uniont uniquet unlockt unsignedt updatet usaget uset usingt utc_datet utc_timet
utc_timestampt valuest varbinaryt varchart varcharactert varyingt whent wheret whilet witht writet x509t xort
year_montht zerofillt columnst fieldst
privilegest sonamet tablest generalt ignore_server_idst master_heartbeat_periodt maxvaluet resignalt signalt slowt gett io_after_gtidst io_before_gtidst master_bindt one_shott partitiont sql_after_gtidst sql_before_gtidst generatedt optimizer_costst storedt virtualt admint cume_distt emptyt exceptt first_valuet groupingt functiont groupst
json_tablet
last_valuet nth_valuet ntilet oft overt percent_rankt persistt persist_onlyt rankt recursivet rolet rowt rowst
row_numbert systemt windows@ \s*(?:UPDATE|INSERT|CREATE|DELETE|DROP|ALTER|LOAD +DATA|REPLACE)s% \s*SET\s+(?:(?:GLOBAL|SESSION)\s+)?\wt bitt booleant datet datetimet enumt fixedt jsont nchart nvarchart textt timet timestampt yeart MySQLExecutionContextc B s e Z d � Z d � Z RS( c C s
t j | � S( N( t
AUTOCOMMIT_RER� ( t selft statement( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt should_autocommit_text� s c C s/ | j j r" | j j | j j � St � � d S( N( t dialectt supports_server_side_cursorst _dbapi_connectionRY t _sscursort NotImplementedError( RT ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt create_server_side_cursor� s ( t __name__t
__module__RV R\ ( ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyRR � s t
MySQLCompilerc B s e Z e Z e j j j � Z e j i d d 6� d � Z d � Z
d � Z d � Z d � Z
d � Z d � Z d � Z d d
� Z d � Z d � Z d
� Z d � Z d � Z e d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z! RS( t millisecondt millisecondsc K s d | j | � S( Ns rand%s( t function_argspec( RT t fnt kw( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_random_func� s c K s d S( Ns SYSDATE()( ( RT Rc Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_sysdate_func� s c K s, d | j | j | � | j | j | � f S( Ns JSON_EXTRACT(%s, %s)( t processR� R� ( RT RB t operatorRd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_json_getitem_op_binary� s c K s, d | j | j | � | j | j | � f S( Ns JSON_EXTRACT(%s, %s)( Rg R� R� ( RT RB Rh Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt! visit_json_path_getitem_op_binary� s c s� � j r� g � j D] } t j | � ^ q } t | � } g | D]. } | | j j j k rA | j j j | ^ qA g | j j j D] } | j | k r� | ^ q� } n | j j j } g } xU� f d � | D� D]=} � j | j }
t j |
� r1t j
d |
d | j �}
| j
|
j � d t �} n� t |
t j
� r�|
j j r�|
j � }
| j |
_ | j
|
j � d t �} n_ t |
t j � r�|
j � j k r�d | j j | j � d } n | j
|
j � d t �} | j j | j � } | j d | | f � q� Wt � j � t d � | D� � }
|
rst j d | j j j d j d
� |
D� � f � n d d j | � S( Nc 3 s' | ] } | j � j k r | Vq d S( N( R� R� ( t .0t col( t on_duplicate( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pys <genexpr>� s t type_t
use_schemas VALUES(t )s %s = %sc s s | ] } | j Vq d S( N( R� ( Rk t c( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pys <genexpr>� s sF Additional column names not matching any column keys in table '%s': %ss , c s s | ] } d | Vq d S( s '%s'N( ( Rk Rq ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pys <genexpr>� s s ON DUPLICATE KEY UPDATE ( t _parameter_orderingR/ t _column_as_keyR� RU R� Rq R� R� t _is_literalt
BindParametert Nonet typeRg t
self_groupt Falset
isinstancet _isnullt _clonet ColumnClauset inserted_aliast preparert quotet namet appendR, t warnR� ( RT Rm Rd R� t parameter_orderingt ordered_keysRq t colst clausesRN t valt
value_textt name_textt non_matching( ( Rm sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_on_duplicate_key_update� s@ "
+5 # !c K s, d | j | j | � | j | j | � f S( Ns concat(%s, %s)( Rg R� R� ( RT RB Rh Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_concat_op_binary� s c K s, d | j | j | � | j | j | � f S( Ns' MATCH (%s) AGAINST (%s IN BOOLEAN MODE)( Rg R� R� ( RT RB Rh Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_match_op_binary� s c C s | S( N( ( RT R� RN ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt get_from_hint_text s c K sz | d k r$ | j j | j � } n t | t j � rL | j | | j | � St | t j � r{ t
| d t � rt d Sd Sn� t | t j � r� d St | t j
t j t j t j f � r� | j j j | � St | t j � rt | t t f � rt j | � } | j j j | � St | t j � r+d St | t j � rAd St | t j � rr| j j j | � j d d � Sd Sd S( NR� s UNSIGNED INTEGERs SIGNED INTEGERR R0 R R R ( Rv Rw t dialect_implRW Rz t sqltypest
TypeDecoratort visit_typeclauset implt Integert getattrRy R! R t DateTimet Datet Timet
type_compilerRg t StringR R R t _adapt_string_for_castt _BinaryR R R� ( RT t
typeclauseRn Rd t adapted( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR� s:
c K s� | j j s2 t j d � | j | j j � | � S| j | j � } | d k r� t j d | j j j | j j
� � | j | j j � | � Sd | j | j | � | f S( NsF Current MySQL version does not support CAST; the CAST will be skipped.sE Datatype %s does not support CAST on MySQL; the CAST will be skipped.s CAST(%s AS %s)( RW t _supports_castR, R� Rg t clauseRx R� Rv R� Rw ( RT t castRd Rn ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt
visit_cast, s c C s@ t t | � j | | � } | j j r< | j d d � } n | S( Ns \s \\( t superR_ t render_literal_valueRW t _backslash_escapesR� ( RT t valueRn ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR� @ s c K s d S( NR� ( ( RT t elementRd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt
visit_trueH s c K s d S( NRv ( ( RT R� Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_falseK s c K s; t | j t j � r& | j j � d S| j r3 d Sd Sd S( s� Add special MySQL keywords in place of DISTINCT.
.. note::
this usage is deprecated. :meth:`.Select.prefix_with`
should be used for special keywords at the start
of a SELECT.
t s DISTINCT t N( Rz t _distinctR, t string_typest upper( RT R� Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt get_select_precolumnsN s
c K s | j r d } n | j r$ d } n d } d j | j | j d t | �| | j | j d t | �d | j | j | � f � S( Ns FULL OUTER JOIN s LEFT OUTER JOIN s INNER JOIN R� t asfroms ON ( t fullt isouterR� Rg R� t TrueR� t onclause( RT R� R� t kwargst join_type( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt
visit_join_ s c K s | j j r d Sd Sd S( Ns LOCK IN SHARE MODEs FOR UPDATE( t _for_update_argR� ( RT R� Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt for_update_clauseq s c K s� | j | j } } | d k r/ | d k r/ d S| d k r� | d k ra d | j | | � d f Sd | j | | � | j | | � f Sn d | j | | � f Sd S( NR� s
LIMIT %s, %st 18446744073709551615s
LIMIT %s( t
_limit_clauset _offset_clauseRv Rg ( RT R� Rd t limit_clauset
offset_clause( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR� w s
c C s5 | j j d | j j d � } | r- d | Sd Sd S( Ns %s_limits LIMIT %s( R� R RW R� Rv ( RT t update_stmtR� ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt update_limit_clause� s c s- d j � � f d � | g t | � D� � S( Ns , c 3 s' | ] } | j � d t � �Vq d S( R� N( t _compiler_dispatchR� ( Rk t t( Rd RT ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pys <genexpr>� s ( R� t list( RT R� t
from_tablet extra_fromsRd ( ( Rd RT sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt update_tables_clause� s c K s d S( N( Rv ( RT R� R� R� t
from_hintsRd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt update_from_clause� s c C s4 t } | r t } n | j | d t d t d | �S( s= If we have extra froms make sure we render any alias as hint.R� t iscrudt ashint( Ry R� R� ( RT t delete_stmtR� R� R� ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt delete_table_clause� s
c s. d d j � � � f d � | g | D� � S( s4 Render the DELETE .. USING clause specific to MySQL.s USING s , c 3 s- | ]# } | j � d t d � � �Vq d S( R� t fromhintsN( R� R� ( Rk R� ( R� Rd RT ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pys <genexpr>� s ( R� ( RT R� R� R� R� Rd ( ( R� Rd RT sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt delete_extra_from_clause� s c C sH d i d j d � t | � D� � d 6d j d � t | � D� � d 6S( NsA SELECT %(outer)s FROM (SELECT %(inner)s) as _empty_set WHERE 1!=1s , c s s | ] \ } } d | Vq d S( s 1 AS _in_%sN( ( Rk t idxRn ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pys <genexpr>� s R� c s s | ] \ } } d | Vq d S( s _in_%sN( ( Rk R� Rn ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pys <genexpr>� s R� ( R� t enumerate( RT t
element_types( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_empty_set_expr� s N(" R] R^ R� t' render_table_with_column_in_update_fromR. t SQLCompilert extract_mapt copyR� Re Rf Ri Rj R� R� R� R� Rv R� R� R� R� R� R� Ry R� R� R� R� R� R� R� R� R� ( ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR_ � s4 5 & ( t MySQLDDLCompilerc B sb e Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z RS(
c K sI | j j | � | j j j | j d | �g } t | j j | j � t j � } | j
sj | j d � n | j
r� | r� | j d � n | j | � } | d k r� | j d | � n | j } | d k r� | j j | t j � � } | j d | � n | j d k r<| | j j k r<| j d k r<| j d � n d j | � S( s Builds column DDL.t type_expressions NOT NULLt NULLs DEFAULT s COMMENT t AUTO_INCREMENTR� N( R t
format_columnRW R� Rg Rw Rz t _unwrapped_dialect_implR� R! t nullableR� t get_column_default_stringRv t commentt sql_compilerR� R� R� t _autoincrement_columnt server_defaultR� ( RT RN Rd t colspect is_timestampR- R� t literal( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt get_column_specification� s. c
s� g } t � f d � | j j � D� � } | j d k rJ | j | d <n d d d d g } t | � j | � } t | � j | � } x� t j d d g | � D]� } | | } | t
j k r� � j j
| t j � � } n | d k r� | j d d � } n d } | d k rd } n | j | j | | f � � q� Wx� t j d d d d d d g | � D]q } | | } | t
j k r�� j j
| t j � � } n | j d d � } d } | j | j | | f � � q]Wd j | � S( s9 Build table-level CREATE options like ENGINE and COLLATE.c 3 sT | ]J \ } } | j d � j j � r | t � j j � d j � | f Vq d S( s %s_i N( t
startswithRW R� t lenR� ( Rk t kt v( RT ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pys <genexpr> s t COMMENTt PARTITION_BYt
PARTITIONSt
SUBPARTITIONSt SUBPARTITION_BYt DEFAULT_CHARSETt COLLATEt DEFAULT_CHARACTER_SETt DATA_DIRECTORYt INDEX_DIRECTORYt
CHARACTER_SETt DEFAULT_COLLATEt _R� t =t
TABLESPACEs DEFAULT CHARACTER SETs
CHARACTER SETN( R� R� ( R� R� ( R� R� R� R� R� R� ( R� s DEFAULT CHARACTER SETs
CHARACTER SETR� ( R� R� ( R� R� ( R� R� ( R� R� ( R� R� ( R� R� ( t dictR� t itemsR� Rv R� t
differencet intersectionR5 t sortt _reflectiont _options_of_type_stringR� R� R� R� R� R� R� (
RT R� t
table_optst optst partition_optionst nonpart_optionst part_optionst optt argt joiner( ( RT sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt post_create_table� sh
c
s� | j } | j | � | j } | j | j � } g | j D]$ } | j j | d t d t �^ q; } | j
| � } d } | j r� | d 7} n | j j
d d � }
|
r� | |
d 7} n | d | | f 7} | j d d � � d k rLt � t � r*d
j � f d � t | j | � D� � } q[d
j � f d � | D� � } n d
j | � } | d
| 7} | j d d } | d k r�| d | f 7} n | j d d } | d k r�| d | j | � 7} n | S( Nt
include_tablet
literal_bindss CREATE s UNIQUE t mysql_prefixR� s INDEX %s ON %s t mysqlt lengths , c 3 se | ][ \ } } | j � k r5 d | � | j f n' | � k rU d | � | f n d | Vq d S( s %s(%d)s %sN( R� ( Rk Rl t expr( R ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pys <genexpr>r s c 3 s | ] } d | � f Vq d S( s %s(%d)N( ( Rk Rl ( R ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pys <genexpr> s s (%s)t with_parsers WITH PARSER %sR s USING %s( R� t _verify_index_tableR t format_tableR� t expressionsR� Rg Ry R� t _prepared_index_nameR� R� R Rv t dialect_optionsRz R� R� t zipR� (
RT RS Rd R� R R� R R R� RN t index_prefixt parserR ( ( R sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_create_indexR s>
1
c C sP t t | � j | � } | j d d } | rL | d | j j | � 7} n | S( NR R s USING %s( R� R� t visit_primary_key_constraintR R R� ( RT RP RN R ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR � s c C s5 | j } d | j | d t �| j j | j � f S( Ns
DROP INDEX %s ON %st include_schema( R� R Ry R R R� ( RT Rl R� ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_drop_index� s c C s� | j } t | t j � r6 d } | j j | � } n� t | t j � rW d } d } n� t | t j � r� d } | j j | � } nZ t | t j � r� | j j
r� d } n d } | j j | � } n d } | j j | � } d | j j | j � | | f S( Ns FOREIGN KEY s PRIMARY KEY R� s INDEX s CONSTRAINT s CHECK s ALTER TABLE %s DROP %s%s(
R� Rz t sa_schemat ForeignKeyConstraintR t format_constraintt PrimaryKeyConstraintt UniqueConstraintt CheckConstraintRW t _is_mariadbR R� ( RT Rl RP t qualt const( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_drop_constraint� s* c C s% | j d k r! t j d � � n d S( Nsj MySQL ignores the 'MATCH' keyword while at the same time causes ON UPDATE/ON DELETE clauses to be ignored.R� ( R� Rv R' t CompileError( RT RP ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt define_constraint_match� s c C s8 d | j j | j � | j j | j j t j � � f S( Ns ALTER TABLE %s COMMENT %s( R R R� R� R� R� R� R� ( RT RS ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_set_table_comment� s c C s d | j j | j � S( Ns ALTER TABLE %s COMMENT ''( R R R� ( RT RS ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_drop_table_comment� s c C s> d | j j | j j � | j j | j � | j | j � f S( Ns ALTER TABLE %s CHANGE %s %s( R R R� R� R� R� ( RT RS ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_set_column_comment� s ( R] R^ R� R
R R R R' R) R* R+ R, ( ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR� � s + S = t MySQLTypeCompilerc B sg e Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d
� Z d � Z
d � Z d
� Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z! d � Z" d! � Z# d" � Z$ d# � Z% d$ � Z& d% � Z' d& � Z( RS(' c C sC | j | � s | S| j r) | d 7} n | j r? | d 7} n | S( sA Extend a numeric-type declaration with MySQL specific extensions.s UNSIGNEDs ZEROFILL( t _mysql_typeR� R ( RT Rn t spec( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt _extend_numeric� s
c s � � f d � } | d � r1 d | d � } n0 | d � rF d } n | d � r[ d } n d } | d � r} d � j } n | d
� r� d } n d } | d � r� d
j g d | | f D] } | d k r� | ^ q� � Sd
j g | | | f D] } | d k r� | ^ q� � S( s� Extend a string-type declaration with standard SQL CHARACTER SET /
COLLATE annotations and MySQL specific extensions.
c s t � | � j | � � S( N( R� R ( R� ( t defaultsRn ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt attr� s t charsets CHARACTER SET %st asciit ASCIIt unicodet UNICODEt collations
COLLATE %sRB R0 t nationalR� t NATIONALN( Rv R8 R� ( RT Rn R1 R/ R2 R3 R8 Rq ( ( R1 Rn sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt _extend_string� s$ /c C s t | t t f � S( N( Rz R R ( RT Rn ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR. s c K sx | j d k r | j | d � S| j d k rL | j | d i | j d 6� S| j | d i | j d 6| j d 6� Sd S( NR s NUMERIC(%(precision)s)R� s! NUMERIC(%(precision)s, %(scale)s)t scale( R� Rv R0 R< ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt
visit_NUMERIC s c K sx | j d k r | j | d � S| j d k rL | j | d i | j d 6� S| j | d i | j d 6| j d 6� Sd S( NR s DECIMAL(%(precision)s)R� s! DECIMAL(%(precision)s, %(scale)s)R< ( R� Rv R0 R< ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt
visit_DECIMAL s c K sZ | j d k rF | j d k rF | j | d i | j d 6| j d 6� S| j | d � Sd S( Ns DOUBLE(%(precision)s, %(scale)s)R� R< R ( R� Rv R< R0 ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_DOUBLE' s c K sZ | j d k rF | j d k rF | j | d i | j d 6| j d 6� S| j | d � Sd S( Ns REAL(%(precision)s, %(scale)s)R� R< R ( R� Rv R< R0 ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt
visit_REAL1 s c K s� | j | � rM | j d k rM | j d k rM | j | d | j | j f � S| j d k rv | j | d | j f � S| j | d � Sd S( Ns
FLOAT(%s, %s)s FLOAT(%s)R ( R. R< Rv R� R0 ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_FLOAT; s c K sP | j | � r< | j d k r< | j | d i | j d 6� S| j | d � Sd S( Ns INTEGER(%(display_width)s)t
display_widthR ( R. RB Rv R0 ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt
visit_INTEGERK s c K sP | j | � r< | j d k r< | j | d i | j d 6� S| j | d � Sd S( Ns BIGINT(%(display_width)s)RB R
( R. RB Rv R0 ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_BIGINTU s c K sP | j | � r< | j d k r< | j | d i | j d 6� S| j | d � Sd S( Ns MEDIUMINT(%(display_width)s)RB R ( R. RB Rv R0 ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_MEDIUMINT_ s c K sI | j | � r5 | j d k r5 | j | d | j � S| j | d � Sd S( Ns TINYINT(%s)R# ( R. RB Rv R0 ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt
visit_TINYINTi s c K sP | j | � r< | j d k r< | j | d i | j d 6� S| j | d � Sd S( Ns SMALLINT(%(display_width)s)RB R ( R. RB Rv R0 ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_SMALLINTq s c K s" | j d k r d | j Sd Sd S( Ns BIT(%s)R ( R Rv ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_BIT{ s c K s% t | d d � r d | j Sd Sd S( Nt fsps DATETIME(%d)R ( R� Rv RI ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_DATETIME� s c K s d S( NR3 ( ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt
visit_DATE� s c K s% t | d d � r d | j Sd Sd S( NRI s TIME(%d)R ( R� Rv RI ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt
visit_TIME� s c K s% t | d d � r d | j Sd Sd S( NRI s
TIMESTAMP(%d)R! ( R� Rv RI ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_TIMESTAMP� s c K s" | j d k r d Sd | j Sd S( NR& s YEAR(%s)( RB Rv ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt
visit_YEAR� s c K s: | j r# | j | i d | j � S| j | i d � Sd S( Ns TEXT(%d)R ( R R; ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt
visit_TEXT� s c K s | j | i d � S( NR$ ( R; ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_TINYTEXT� s c K s | j | i d � S( NR ( R; ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_MEDIUMTEXT� s c K s | j | i d � S( NR ( R; ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_LONGTEXT� s c K s@ | j r# | j | i d | j � St j d | j j � � d S( Ns VARCHAR(%d)s' VARCHAR requires a length on dialect %s( R R; R' R( RW R� ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt
visit_VARCHAR� s c K sA | j r* | j | i d i | j d 6� S| j | i d � Sd S( Ns CHAR(%(length)s)R R ( R R; ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt
visit_CHAR� s c K sN | j r1 | j | i t d 6d i | j d 6� St j d | j j � � d S( NR9 s VARCHAR(%(length)s)R s( NVARCHAR requires a length on dialect %s( R R; R� R' R( RW R� ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_NVARCHAR� s
c K sO | j r1 | j | i t d 6d i | j d 6� S| j | i t d 6d � Sd S( NR9 s CHAR(%(length)s)R R ( R R; R� ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_NCHAR� s
c K s d | j S( Ns
VARBINARY(%d)( R ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_VARBINARY� s c K s d S( NR ( ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt
visit_JSON� s c K s
| j | � S( N( t
visit_BLOB( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_large_binary� s c K s9 | j s t t | � j | � S| j d | | j � Sd S( NR ( t native_enumR� R- t
visit_enumt _visit_enumerated_valuest enums( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR\ � s c K s | j r d | j Sd Sd S( Ns BLOB(%d)R1 ( R ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyRY � s c K s d S( NR" ( ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_TINYBLOB� s c K s d S( NR ( ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_MEDIUMBLOB� s c K s d S( NR ( ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_LONGBLOB� s c C sZ g } x+ | D]# } | j d | j d d � � q
W| j | i d | d j | � f � S( Ns '%s't 's ''s %s(%s)t ,( R� R� R; R� ( RT R� Rn t enumerated_valuest quoted_enumst e( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR] � s
!c K s | j d | | j � S( NR ( R] t _enumerated_values( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt
visit_ENUM� s c K s | j d | | j � S( NR ( R] Rg ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt visit_SET s c K s d S( Nt BOOL( ( RT Rn Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt
visit_BOOLEAN s () R] R^ R0 R; R. R= R> R? R@ RA RC RD RE RF RG RH RJ RK RL RM RN RO RP RQ RR RS RT RU RV RW RX RZ R\ RY R_ R` Ra R] Rh Ri Rk ( ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR- � sN "
t MySQLIdentifierPreparerc B s# e Z e Z e d � Z d � Z RS( c K s; | s d } n d } t t | � j | d | d | �d S( Nt `t "t
initial_quotet escape_quote( R� Rl t __init__( RT RW t server_ansiquotesRd R� ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyRq
s
c G s2 t g | D]! } | d k r
| j | � ^ q
� S( s4 Unilaterally identifier-quote any number of strings.N( t tupleRv t quote_identifier( RT t idst i( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt _quote_free_identifiers s ( R] R^ t RESERVED_WORDSt reserved_wordsRy Rq Rw ( ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyRl s
t MySQLDialectc B s� e Z d Z d Z e Z e Z d Z d Z e Z
e Z e Z e Z
e Z e Z d Z e Z e Z e Z e Z e Z e Z e Z e Z e Z e j i dB d 6f e! j" i dB d 6f e j# i dB d 6f e j$ i dB d 6dB d 6dB d 6dB d
6f g Z% dB dB dB d � Z& d � Z' e( d
d d d g � Z) d � Z* d � Z+ d � Z, d � Z- d � Z. d � Z/ d � Z0 d � Z1 d � Z2 e e d � Z3 e e d � Z4 d � Z5 d � Z6 dB d � Z7 dB d � Z8 dB d � Z9 d! � Z: d" � Z; dB d# � Z< d$ � Z= d% � Z> e? d& � � Z@ e? d' � � ZA e? d( � � ZB e? d) � � ZC e? d* � � ZD eE jF d+ � � ZG eE jF dB d, � � ZH eE jF dB d- � � ZI eE jF dB d. � � ZJ eE jF dB d/ � � ZK eE jF dB d0 � � ZL eE jF dB d1 � � ZM d2 � ZN eE jF dB d3 � � ZO eE jF dB d4 � � ZP eE jF dB d5 � � ZQ eE jF dB d6 � � ZR eE jF dB d7 � � ZS dB d8 � ZT eU jV d9 � � ZW eE jF dB d: � � ZX d; � ZY d< � ZZ d= � Z[ d> � Z\ d? � Z] dB dB d@ � Z^ dB dB dA � Z_ RS(C sM Details of the MySQL dialect.
Not used directly in application code.
R i� i@ t formatt *R� R R t prefixR c K sB | j d d � t j j | | � | | _ | | _ | | _ d S( Nt use_ansiquotes( t popRv R- t DefaultDialectRq t isolation_levelt _json_serializert _json_deserializer( RT R� t json_serializert json_deserializerR� ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyRq V s
c s* � j d k r" � f d � } | Sd Sd S( Nc s � j | � j � d S( N( t set_isolation_levelR� ( t conn( RT ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt connectf s ( R� Rv ( RT R� ( ( RT sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt
on_connectc s t SERIALIZABLEs READ UNCOMMITTEDs READ COMMITTEDs REPEATABLE READc C sA | j d d � } t | d � r- | j } n | j | | � d S( NR� R� t
connection( R� t hasattrR� t _set_isolation_level( RT R� t level( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR� v s c C su | | j k r= t j d | | j d j | j � f � � n | j � } | j d | � | j d � | j � d S( NsL Invalid value '%s' for isolation_level. Valid isolation levels for %s are %ss , s* SET SESSION TRANSACTION ISOLATION LEVEL %st COMMIT( t _isolation_lookupR' t
ArgumentErrorR� R� RY t executet close( RT R� R� RY ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR� � s %
c C s� | j � } | j r4 | j d k r4 | j d � n
| j d � | j � d } | j � t j r� t | t � r� | j
� } n | j � j d d � S(
Ni i i s SELECT @@transaction_isolations SELECT @@tx_isolationi t -R� ( i i i (
RY t _is_mysqlt server_version_infoR� t fetchoneR� R, t py3kRz t bytest decodeR� R� ( RT R� RY R� ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt get_isolation_level� s
c C sp | j } | j � } | j d � | j � d } | j � t j rc t | t � rc | j � } n | j
| � S( Ns SELECT VERSION()i ( R� RY R� R� R� R, R� Rz R� R� t _parse_server_version( RT R� t dbapi_conRY R� ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt _get_server_version_info� s
c C s� g } t j d � } x� | j | � D]v } y | j t | � � Wq% t k
r� t j d | � } | r� | j d � | j � D� � q� | j | � q% Xq% Wt | � S( Ns [.\-]s (.*)(MariaDB)(.*)c s s | ] } | r | Vq d S( N( ( Rk t g( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pys <genexpr>� s (
t ret compilet splitR� R� t
ValueErrorR� t extendR3 Rs ( RT R� t versiont rt nt mariadb( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR� � s
c C sh y | j � WnS t k
rc | j d k r] t j � d j } | r] | d d k r] d Sn � n Xd S( s Execute a COMMIT.i i i i i i( N( i i i ( t committ ExceptionR� t syst exc_infot args( RT t dbapi_connectionR� ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt do_commit� s
c C sh y | j � WnS t k
rc | j d k r] t j � d j } | r] | d d k r] d Sn � n Xd S( s Execute a ROLLBACK.i i i i i i( N( i i i ( t rollbackR� R� R� R� R� ( RT R� R� ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt do_rollback� s
c C s | j t j d � d | �d S( Ns
XA BEGIN :xidt xid( R� R* RN ( RT R� R� ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt do_begin_twophase� s c C s< | j t j d � d | �| j t j d � d | �d S( Ns XA END :xidR� s XA PREPARE :xid( R� R* RN ( RT R� R� ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt do_prepare_twophase� s c C sE | s% | j t j d � d | �n | j t j d � d | �d S( Ns XA END :xidR� s XA ROLLBACK :xid( R� R* RN ( RT R� R� t is_preparedt recover( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt do_rollback_twophase� s c C s9 | s | j | | � n | j t j d � d | �d S( Ns XA COMMIT :xidR� ( R� R� R* RN ( RT R� R� R� R� ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt do_commit_twophase� s c C s5 | j d � } g | D] } | d d | d !^ q S( Ns
XA RECOVERt datai t gtrid_length( R� ( RT R� t resultsetR@ ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt do_recover_twophase� s c C sm t | | j j | j j f � r4 | j | � d k St | | j j | j j f � re d t | � k St Sd S( Ni� i� i� i� i s (0, '')( i� i� i� i� i ( Rz t dbapit OperationalErrort ProgrammingErrort _extract_error_codet InterfaceErrort
InternalErrort strRy ( RT Rf R� RY ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt
is_disconnect� s c C s& g | j � D] } t | | � ^ q
S( sM Proxy result rows to smooth over MySQL-Python driver
inconsistencies.( t fetchallt _DecodingRowProxy( RT t rpR3 R@ ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt _compat_fetchall s c C s' | j � } | r t | | � Sd Sd S( sN Proxy a result row to smooth over MySQL-Python driver
inconsistencies.N( R� R� Rv ( RT R� R3 R@ ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt _compat_fetchone s
c C s' | j � } | r t | | � Sd Sd S( sN Proxy a result row to smooth over MySQL-Python driver
inconsistencies.N( t firstR� Rv ( RT R� R3 R@ ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt
_compat_first s
c C s
t � � d S( N( R[ ( RT t exception( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR� s c C s | j d � j � S( Ns SELECT DATABASE()( R� t scalar( RT R� ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt _get_default_schema_name s c C s� d j | j j | | � � } d | } d } z{ y? | j d t � j | � } | j � d k } | j � | SWn5 t j
k
r� } | j | j � d k r� t
S� n XWd | r� | j � n Xd S( Nt .s DESCRIBE %st skip_user_error_eventsiz ( R� t identifier_preparerRw Rv t execution_optionsR� R� R� R� R' t
DBAPIErrorR� t origRy ( RT R� t
table_nameR) t full_namet stt rst haveRf ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt has_table s&
c C s� | j | � | _ | j | � | j | � | j | � | j r` | j | d | j �| _ n t j j
| | � | j o� | j d k | _
| j � d S( NRr i ( i ( t _detect_charsett _connection_charsett _detect_sql_modet _detect_ansiquotest _detect_casingt _server_ansiquotesR R� R- R� t
initializeR$ R� t _needs_correct_for_88718t _warn_for_known_db_issues( RT R� ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR� C s
c C sH | j rD | j } | d k rD | d k rD t j d | f � qD n d S( Ni
i i s` MariaDB %r before 10.2.9 has known issues regarding CHECK constraints, which impact handling of NULL values with SQLAlchemy's boolean datatype (MDEV-13596). An additional issue prevents proper migrations of columns with CHECK constraints (MDEV-11114). Please upgrade to MariaDB 10.2.9 or greater, or use the MariaDB 10.1 series, to avoid these issues.( i
i ( i
i i ( R$ t _mariadb_normalized_version_infoR, R� ( RT t mdb_version( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR� W s c C s | j o d | j k S( Nt MariaDB( R� ( RT ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR$ e s c C s | j S( N( R$ ( RT ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR� k s c C s | j o | j d k S( Ni
i ( i
i ( R$ R� ( RT ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt _is_mariadb_102o s c C s8 | j r- | j j d � } | j | d | !S| j Sd S( NR� i ( R$ R� R� ( RT R� ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR� v s c C s | j d k p | j d k S( Ni i i ( i i i ( R� Rv ( RT ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR� � s c K s* | j d � } g | D] } | d ^ q S( Ns SHOW schemasi ( R� ( RT R� Rd R� R� ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt get_schema_names� s c K s� | d k r | } n | j } | j } | j d
k r | j d | j j | � � } g | j | d | �D] } | d ^ qk S| j d | j j | � � } g | j | d | �D] } | d d k r� | d ^ q� Sd S( s1 Return a Unicode SHOW TABLES from a given schema.i i i s SHOW TABLES FROM %sR3 s SHOW FULL TABLES FROM %si s
BASE TABLEN( i i i ( Rv t default_schema_nameR� R� R� R� Rt R� ( RT R� R) Rd t current_schemaR3 R� R@ ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt get_table_names� s *c K s� | j d k r t � n | d k r0 | j } n | j d
k rO | j | | � S| j } | j d | j j | � � } g | j | d | �D] } | d d k r� | d ^ q� S( Ni i i s SHOW FULL TABLES FROM %sR3 i t VIEWs SYSTEM VIEW( i i i ( i i i ( R� s SYSTEM VIEW(
R� R[ Rv R� R� R� R� R� Rt R� ( RT R� R) Rd R3 R� R@ ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt get_view_names� s c K s | j | | | | � } | j S( N( t _parsed_state_or_createt
table_options( RT R� R� R) Rd t parsed_state( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt get_table_options� s c K s | j | | | | � } | j S( N( R� R ( RT R� R� R) Rd R� ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt get_columns� s c K s� | j | | | | � } xT | j D]I } | d d k r" g | d D] } | d ^ qC } i | d 6d d 6Sq" Wi g d 6d d 6S( NRw t PRIMARYR i t constrained_columnsR� ( R� R� Rv ( RT R� R� R) Rd R� R� t sR� ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt get_pk_constraint� s !c K sX | j | | | | � } d } g } x| j D]} | d d } t | d � d k rf | d d pi | }
|
s� | d k r� | j j } n | | k r� | }
q� n | d } | d } i }
x1 d D]) } | j | t � r� | | |
| <q� q� Wi | d d 6| d
6|
d 6| d 6| d
6|
d 6} | j | � q. W| j rT| j
| | � n | S( NR� i����i i����t localR} t onupdatet ondeleteR� R� t referred_schemat referred_tablet referred_columnst options( R� R� ( R� Rv t fk_constraintsR� RW R� R Ry R� R� t _correct_for_mysql_bug_88718( RT R� R� R) Rd R� t default_schemat fkeysR/ t ref_namet
ref_schemat loc_namest ref_namest con_kwR t fkey_d( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt get_foreign_keys� s: *
c C sl | j d k r d � } n d � } | j j } g | D]@ } | d D]/ } | | d p[ | � | | d � | f ^ qE q7 } | rh| j t j d � j t j d d
t �� d | �} t t
� } x= | D]5 \ }
} } | | | |
� | | � f | j � <q� Wx` | D]U }
g |
d D]: } | | |
d p6| � | |
d � f | j � ^ q |
d <q Wn d S( Ni i c S s
| j � S( N( t lower( R� ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR
s c S s | S( N( ( R� ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR
s R� R� R� s�
select table_schema, table_name, column_name
from information_schema.columns
where (table_schema, table_name, lower(column_name)) in
:table_data;
t
table_datat expanding( i i ( t _casingRW R� R� R* RN t
bindparamst bindparamR� R R� R ( RT R R� R R� t rect col_namet
col_tuplest correct_for_wrong_fk_caset dR) t tnamet cnamet fkeyRl ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR�
s&
@
*
c K sH | j | | | | � } g | j D]" } i | d d 6| d d 6^ q" S( NR� t sqltext( R� t ck_constraints( RT R� R� R) Rd R� R/ ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt get_check_constraintsM
s c K s2 | j | | | | � } i | j j d d � d 6S( Nt
mysql_commentRN ( R� R� R Rv ( RT R� R� R) Rd R� ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt get_table_commentX
s c
K s? | j | | | | � } g } x| j D]} i } t } | d }
|
d k rV q( n |
d k rk t } n; |
d k r� |
| d <n" |
d k r� n | j j d |
� | d r� | d | d <n i } | r� | | d
<n | d | d <g | d D] } | d
^ q� | d <| | d <|
r*|
| d <n | j | � q( W| S( NRw R� t UNIQUEt FULLTEXTt SPATIALR
s- Converting unknown KEY type %s to a plain KEYR t mysql_with_parserR R� R i t column_namesR� ( R R ( R� R� Ry R� Rv t loggert infoR� (
RT R� R� R) Rd R� t indexesR/ R R� t flavort index_dR� ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt get_indexes_
s:
%
c K sz | j | | | | � } g | j D]T } | d d k r" i | d d 6g | d D] } | d ^ qQ d 6| d d 6^ q" S( NRw R R� R i R t duplicates_index( R� R� ( RT R� R� R) Rd R� R� Rl ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt get_unique_constraints�
s
c K sF | j } d j | j j | | � � } | j | d | d | �} | S( NR� R� ( R� R� R� Rw t _show_create_tableRv ( RT R� t view_nameR) Rd R3 R� R* ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt get_view_definition�
s c K s% | j | | | d | j d d � �S( Nt
info_cache( t
_setup_parserR Rv ( RT R� R� R) Rd ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR� �
s
c C sI | j d k r0 | j r0 | j | d t �} n | j } t j | | � S( s� return the MySQLTableDefinitionParser, generate if needed.
The deferred creation ensures that the dialect has
retrieved server version information first.
i i Rr ( i i ( R� R� R Ry R� R t MySQLTableDefinitionParser( RT R ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt _tabledef_parser�
s c
K s� | j } | j } d j | j j | | � � } | j | d | d | �} t j d | � r� | j | d | d | �} | j
| | � } n | j | | � S( NR� R� s ^CREATE (?:ALGORITHM)?.* VIEW( R� R/ R� R� Rw R) Rv R� R� t _describe_tablet _describe_to_createt parse(
RT R� R� R) Rd R3 R R� R* R ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR- �
s c C s
t � � d S( N( R[ ( RT R� ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR� �
s c C s� | j } | j | j d � d | �} | s6 d } nB | d d k rO d } n) | d d k rh d } n t | d � } | | _ | S( s� Sniff out identifier case sensitivity.
Cached per-connection. This value can not change without a server
restart.
s, SHOW VARIABLES LIKE 'lower_case_table_names'R3 i i t OFFt ON( R� R� R� R� R ( RT R� R3 R@ t cs( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR� �
s c C sc i } | j d k r nG | j } | j d � } x, | j | | � D] } | d | | d <qC W| S( sY Pull the active COLLATIONS list from the server.
Cached per-connection.
i i i s SHOW COLLATION( i i i ( R� R� R� R� ( RT R� t
collationsR3 R� R@ ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt _detect_collations�
s c C sW | j | j d � d | j �} | s@ t j d � d | _ n | d pM d | _ d S( Ns SHOW VARIABLES LIKE 'sql_mode'R3 s[ Could not retrieve SQL_MODE; please ensure the MySQL user has permissions to SHOW VARIABLESR� i ( R� R� R� R, R� t _sql_mode( RT R� R@ ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR� s c C sq | j } | s d } n7 | j � rO t | � } | d B| k rF d pI d } n d | k | _ d | k | _ d S( s/ Detect and adjust for the ANSI_QUOTES sql mode.R� i t ANSI_QUOTESt NO_BACKSLASH_ESCAPESN( R8 t isdigitR� R� R� ( RT R� t modet mode_no( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR� s c C s� | d k r! | j j | � } n d | } d } y | j d t � j | � } WnC t j k
r� } | j | j � d k r� t j
| � � q� � n X| j | d | �} | s� t j
| � � n | d j � S( s& Run SHOW CREATE TABLE for a ``Table``.s SHOW CREATE TABLE %sR� iz R3 i N( Rv R� R R� R� R� R' R� R� R� t NoSuchTableErrorR� t stripR* ( RT R� R� R3 R� R� R� Rf R@ ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR) ! s"
c
C s� | d k r! | j j | � } n d | } d \ } } z� y | j d t � j | � } Wnq t j k
r� } | j | j � } | d k r� t j
| � � q� | d k r� t j d | | f � � q� � n X| j | d | �} Wd | r� | j
� n X| S( s7 Run DESCRIBE for a ``Table`` and return processed rows.s DESCRIBE %sR� iz iL s1 Table or view named %s could not be reflected: %sR3 N( NN( Rv R� R R� R� R� R' R� R� R� R> t UnreflectableTableErrorR� R� (
RT R� R� R3 R� R� R� RA Rf t code( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR0 ; s,
N(` R] R^ t __doc__R� R� t supports_alterRy t supports_native_booleant max_identifier_lengtht max_index_name_lengtht supports_native_enumt supports_sane_rowcountt supports_sane_multi_rowcountt supports_multivalues_insertt supports_commentst inline_commentst default_paramstylet colspecst cte_follows_insertR_ t statement_compilerR� t ddl_compilerR- R� t
ischema_namesRl R R� R� R t TableRv R* t UpdateR! t Indext construct_argumentsRq R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� t propertyR$ R� R� R� R� R t cacheR� R� R� R� R� R� R R� R R R& R( R+ R� R, t memoized_propertyR/ R- R� R� R7 R� R� R) R0 ( ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyRz s�
# * J
) R� c B sR e Z d Z i d d 6d d 6d d 6d d 6d d
6Z d � Z d � Z d
� Z RS( s� Return unicode-decoded values based on type inspection.
Smooth over data type issues (esp. with alpha driver versions) and
normalize strings as Unicode regardless of user-configured driver
encoding settings.
t koi8_rt koi8rt koi8_ut koi8us utf-16-bet utf16t utf8t utf8mb4t ujist eucjpmsc C s% | | _ | j j | | � | _ d S( N( t rowproxyt _encoding_compatR R3 ( RT Rc R3 ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyRq o s c C s^ | j | } t | t � r+ | j � } n | j rV t | t j � rV | j | j � S| Sd S( N( Rc Rz t _arrayt tostringR3 R, t binary_typeR� ( RT R� t item( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt __getitem__s s
c C sc t | j | � } t | t � r0 | j � } n | j r[ t | t j � r[ | j | j � S| Sd S( N( R� Rc Rz Re Rf R3 R, Rg R� ( RT R2 Rh ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt __getattr__} s ( R] R^ RB Rd Rq Ri Rj ( ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyR� Z s
(} RB R Re t collectionsR R� R� R� R R t
enumeratedR R RK R R R R+ R R R
R R R
R R R R R R R R R R R R R R R R R R R R! R" R# R$ R% R& R' R( R) R R* R� R, t engineR- R. R/ R0 R1 R2 R3 R4 R5 R� Rx R� t IR7 RS t SET_REt MSTimet MSSett MSEnumt
MSLongBlobt MSMediumBlobt
MSTinyBlobt MSBlobt MSBinaryt MSVarBinaryt MSNChart
MSNVarChart MSChart MSStringt
MSLongTextt MSMediumTextt
MSTinyTextt MSTextt MSYeart MSTimeStampt MSBitt MSSmallIntegert
MSTinyIntegert MSMediumIntegert MSBigIntegert MSNumerict MSDecimalt MSDoublet MSRealt MSFloatt MSIntegert Numerict FloatR� t Enumt MatchTypeRN RR t DefaultExecutionContextRR R� R_ t DDLCompilerR� t GenericTypeCompilerR- t IdentifierPreparerRl t class_loggerR� Rz t objectR� ( ( ( sQ /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyt <module>� sf
� ,� � 3 � � � ?
Mini Shell