aiomysql 0.0.6

MySQL driver for asyncio.

aiomysql is a “driver” for accessing a MySQL database from the asyncio (PEP-3156/tulip) framework. It depends on and reuses most parts of PyMySQL . aiomysql tries to be like awesome aiopg library and preserve same api, look and feel.

Internally aiomysql is copy of PyMySQL, underlying io calls switched to async, basically yield from and asyncio.coroutine added in proper places)). sqlalchemy support ported from aiopg.

Documentation

http://aiomysql.readthedocs.org/

Mailing List

https://groups.google.com/forum/#!forum/aio-libs

Basic Example

aiomysql based on PyMySQL , and provides same api, you just need to use await conn.f() or yield from conn.f() instead of calling conn.f() for every method.

Properties are unchanged, so conn.prop is correct as well as conn.prop = val.

import asyncio
from aiomysql import create_pool


loop = asyncio.get_event_loop()

async def go():
    async with create_pool(host='127.0.0.1', port=3306,
                           user='root', password='',
                           db='mysql', loop=loop) as pool:
        async with pool.get() as conn:
            async with conn.cursor() as cur:
                await cur.execute("SELECT 42;")
                value = await cur.fetchone()
                print(value)


loop.run_until_complete(go())

Connection Pool

Connection pooling ported from aiopg :

import asyncio
import aiomysql


loop = asyncio.get_event_loop()


@asyncio.coroutine
def test_example():
    pool = yield from aiomysql.create_pool(host='127.0.0.1', port=3306,
                                           user='root', password='',
                                           db='mysql', loop=loop)
    with (yield from pool) as conn:
        cur = yield from conn.cursor()
        yield from cur.execute("SELECT 10")
        # print(cur.description)
        (r,) = yield from cur.fetchone()
        assert r == 10
    pool.close()
    yield from pool.wait_closed()

loop.run_until_complete(test_example())

Example of SQLAlchemy optional integration

Sqlalchemy support has been ported from aiopg so api should be very familiar for aiopg user.:

import asyncio
from aiomysql.sa import create_engine
import sqlalchemy as sa


metadata = sa.MetaData()

tbl = sa.Table('tbl', metadata,
    sa.Column('id', sa.Integer, primary_key=True),
    sa.Column('val', sa.String(255)))


@asyncio.coroutine
def go():
    engine = yield from create_engine(user='root',
                                      db='aiomysql',
                                      host='127.0.0.1',
                                      password='')

    with (yield from engine) as conn:
        yield from conn.execute(tbl.insert().values(val='abc'))

        res = yield from conn.execute(tbl.select())
        for row in res:
            print(row.id, row.val)


asyncio.get_event_loop().run_until_complete(go())

Requirements

• Python 3.3+

• asyncio or Python 3.4+

• PyMySQL

Changes

0.0.6 (2015-12-11)

• Fixed bug with SA rollback (Thanks @khlyestovillarion!)

• Fixed issue with default no_delay option (Thanks @khlyestovillarion!)

0.0.5 (2015-10-28)

• no_delay option is deprecated and True by default

• Add Cursor.mogrify() method

• Support for “LOAD LOCAL INFILE” query.

• Check connection inside pool, in case of timeout drop it, fixes #25

• Add support of python 3.5 features to pool, connection and cursor

0.0.4 (2015-05-23)

• Allow to call connection.wait_closed twice.

• Fixed sqlalchemy 1.0.0 support.

• Fix #11: Rename Connection.wait_closed() to .ensure_closed()

• Raise ResourceWarning on non-closed Connection

• Rename Connection.connect to _connect

0.0.3 (2015-03-10)

• Added support for PyMySQL up to 0.6.6.

• Ported improvements from PyMySQL.

• Added basic documentation.

• Fixed and added more examples.

0.0.2 (2015-02-17)

• Added MANIFEST.in.

0.0.1 (2015-02-17)

• Initial release.

• Implemented plain connections: connect, Connection, Cursor.

• Implemented database pools.

• Ported sqlalchemy optional support.