Support for the MySQL database.
SQLAlchemy supports 6 major MySQL versions: 3.23, 4.0, 4.1, 5.0, 5.1 and 6.0, with capablities increasing with more modern servers.
Versions 4.1 and higher support the basic SQL functionality that SQLAlchemy uses in the ORM and SQL expressions. These versions pass the applicable tests in the suite 100%. 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.
Currently, the only DB-API driver supported is MySQL-Python (also referred to as MySQLdb). Either 1.2.1 or 1.2.2 are recommended. The alpha, beta and gamma releases of 1.2.1 and 1.2.2 should be avoided. Support for Jython and IronPython is planned.
Feature | Minimum Version |
---|---|
sqlalchemy.orm | 4.1.1 |
Table Reflection | 3.23.x |
DDL Generation | 4.1.1 |
utf8/Full Unicode Connections | 4.1.1 |
Transactions | 3.23.15 |
Two-Phase Transactions | 5.0.3 |
Nested Transactions | 5.0.3 |
See the official MySQL documentation for detailed information about features supported in any given server release.
Many MySQL server installations default to a latin1 encoding for client connections. All data sent through the connection will be converted into latin1, even if you have utf8 or another character set on your tables and columns. With versions 4.1 and higher, you can change the connection character set either through server configuration or by passing the charset parameter to create_engine. The charset option is passed through to MySQL-Python and has the side-effect of also enabling use_unicode in the driver by default. For regular encoded strings, also pass use_unicode=0 in the connection arguments.
Most MySQL server installations have a default table type of MyISAM, a non-transactional table type. During a transaction, non-transactional storage engines do not participate and continue to store table changes in autocommit mode. For fully atomic transactions, all participating tables must use a transactional engine such as InnoDB, Falcon, SolidDB, PBXT, etc. Storage engines can be elected when creating tables in SQLAlchemy by supplying a mysql_engine='whatever' to the Table constructor. Any MySQL table creation option can be specified in this syntax.
Not all MySQL storage engines support foreign keys. For MyISAM and similar engines, the information loaded by table reflection will not include foreign keys. For these tables, you may supply ForeignKeyConstraints at reflection time:
Table('mytable', metadata, autoload=True, ForeignKeyConstraint(['other_id'], ['othertable.other_id']))
When creating tables, SQLAlchemy will automatically set AUTO_INCREMENT on an integer primary key column:
>>> 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 supplying autoincrement=False in addition. This 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 SQL modes are supported. Modes that enable ANSI_QUOTES (such as ANSI) require an engine option to modify SQLAlchemy's quoting style. When using an ANSI-quoting mode, supply use_ansiquotes=True when creating your Engine:
create_engine('mysql://localhost/test', use_ansiquotes=True)
This is an engine-wide option and is not toggleable on a per-connection basis. SQLAlchemy does not presume to SET sql_mode for you with this option. For the best performance, set the quoting style server-wide in my.cnf or by supplying --sql-mode to mysqld. You can also use a Pool hook to issue a SET SESSION sql_mode='...' on connect to configure each connection.
If you do not specify 'use_ansiquotes', the regular MySQL quoting style is used by default. Table reflection operations will query the server
If you do issue a 'SET sql_mode' through SQLAlchemy, the dialect must be updated if the quoting style is changed. Again, this change will affect all connections:
connection.execute('SET sql_mode="ansi"') connection.dialect.use_ansiquotes = True
For normal SQLAlchemy usage, loading this module is unnescesary. It will be loaded on-demand when a MySQL connection is needed. The generic column types like String and Integer will automatically be adapted to the optimal matching MySQL column type.
But if you would like to use one of the MySQL-specific or enhanced column types when creating tables with your Table definitions, then you will need to import them from this module:
from sqlalchemy.databases import mysql Table('mytable', metadata, Column('id', Integer, primary_key=True), Column('ittybittyblob', mysql.MSTinyBlob), Column('biggy', mysql.MSBigInteger(unsigned=True)))
All standard MySQL column types are supported. The OpenGIS types are available for use via table reflection but have no special support or mapping to Python classes. If you're using these types and have opinions about how OpenGIS can be smartly integrated into SQLAlchemy please join the mailing list!
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 statement can be executed as a string rather than through the SQL expression language.
Some limited support for MySQL extensions to SQL expressions is currently available.
SELECT pragma:
select(..., prefixes=['HIGH_PRIORITY', 'SQL_SMALL_RESULT'])UPDATE with LIMIT:
update(..., mysql_limit=10)
If you have problems that seem server related, first check that you are using the most recent stable MySQL-Python package available. The Database Notes page on the wiki at http://www.sqlalchemy.org is a good resource for timely information affecting MySQL in SQLAlchemy.
MySQL BIGINTEGER type.
Construct a BIGINTEGER.
MySQL BINARY type, for fixed length binary data
Construct a BINARY. This is a fixed length type, and short values will be right-padded with a server-version-specific pad value.
MySQL BIT type.
This type is for MySQL 5.0.3 or greater for MyISAM, and 5.0.5 or greater for MyISAM, MEMORY, InnoDB and BDB. For older versions, use a MSTinyInteger(1) type.
Convert a MySQL's 64 bit, variable length binary string to a long.
MySQL BLOB type, for binary data up to 2^16 bytes
Construct a BLOB. Arguments are:
MySQL CHAR type, for fixed-length character data.
Construct an NCHAR.
MySQL DECIMAL type.
Construct a DECIMAL.
MySQL DOUBLE type.
Construct a DOUBLE.
MySQL ENUM type.
Construct an ENUM.
Example:
Column('myenum', MSEnum("'foo'", "'bar'", "'baz'"))
Arguments are:
MySQL FLOAT type.
Construct a FLOAT.
MySQL INTEGER type.
Construct an INTEGER.
MySQL LONGTEXT type, for text up to 2^32 characters.
Construct a LONGTEXT.
MySQL MEDIUMBLOB type, for binary data up to 2^24 bytes.
MySQL MEDIUMINTEGER type.
Construct a MEDIUMINTEGER
MySQL MEDIUMTEXT type, for text up to 2^24 characters.
Construct a MEDIUMTEXT.
MySQL NCHAR type.
For fixed-length character data in the server's configured national character set.
Construct an NCHAR. Arguments are:
MySQL NVARCHAR type.
For variable-length character data in the server's configured national character set.
Construct an NVARCHAR.
MySQL NUMERIC type.
Construct a NUMERIC.
MySQL SET type.
Construct a SET.
Example:
Column('myset', MSSet("'foo'", "'bar'", "'baz'"))
Arguments are:
MySQL SMALLINTEGER type.
Construct a SMALLINTEGER.
MySQL VARCHAR type, for variable-length character data.
Construct a VARCHAR.
MySQL TEXT type, for text up to 2^16 characters.
Construct a TEXT.
MySQL TIMESTAMP type.
To signal the orm to automatically re-select modified rows to retrieve the updated timestamp, add a PassiveDefault to your column specification:
from sqlalchemy.databases import mysql Column('updated', mysql.MSTimeStamp, PassiveDefault(sql.text('CURRENT_TIMESTAMP')))
The full range of MySQL 4.1+ TIMESTAMP defaults can be specified in the PassiveDefault:
PassiveDefault(sql.text('CURRENT TIMESTAMP ON UPDATE CURRENT_TIMESTAMP'))
MySQL TINYINT type.
Construct a TINYINT.
Note: following the usual MySQL conventions, TINYINT(1) columns reflected during Table(..., autoload=True) are treated as Boolean columns.
MySQL TINYTEXT type, for text up to 2^8 characters.
Construct a TINYTEXT.
MySQL VARBINARY type, for variable length binary data.
Construct a VARBINARY. Arguments are:
MySQL YEAR type, for single byte storage of years 1901-2155.