add bakery and fix tests

Author: wwwjfy

mysql_tests/test_bakery.py

@@ -0,0 +1,162 @@
+import pytest
+import sqlalchemy
+
+from gino import UninitializedError, create_engine, InitializedError
+from gino.bakery import Bakery, BakedQuery
+from .models import db, User, MYSQL_URL
+
+pytestmark = pytest.mark.asyncio
+
+
+@pytest.mark.parametrize(
+    "query",
+    [
+        User.query.where(User.id == db.bindparam("uid")),
+        sqlalchemy.text("SELECT * FROM gino_users WHERE id = :uid"),
+        "SELECT * FROM gino_users WHERE id = :uid",
+        lambda: User.query.where(User.id == db.bindparam("uid")),
+        lambda: sqlalchemy.text("SELECT * FROM gino_users WHERE id = :uid"),
+        lambda: "SELECT * FROM gino_users WHERE id = :uid",
+    ],
+)
+@pytest.mark.parametrize("options", [dict(return_model=False), dict(loader=User)])
+@pytest.mark.parametrize("api", [True, False])
+@pytest.mark.parametrize("timeout", [None, 1])
+async def test(query, options, sa_engine, api, timeout):
+    uid = sa_engine.execute(User.insert()).lastrowid
+    if timeout:
+        options["timeout"] = timeout
+
+    if api:
+        b = db._bakery
+        qs = [db.bake(query, **options)]
+        if callable(query):
+            qs.append(db.bake(**options)(query))
+    else:
+        b = Bakery()
+        qs = [b.bake(query, **options)]
+        if callable(query):
+            qs.append(b.bake(**options)(query))
+
+    for q in qs:
+        assert isinstance(q, BakedQuery)
+        assert q in list(b)
+        assert q.sql is None
+        assert q.compiled_sql is None
+
+        with pytest.raises(UninitializedError):
+            q.bind.first()
+        with pytest.raises(UninitializedError):
+            await q.first()
+
+        for k, v in options.items():
+            assert q.query.get_execution_options()[k] == v
+
+    if api:
+        e = await db.set_bind(MYSQL_URL, minsize=1)
+    else:
+        e = await create_engine(MYSQL_URL, bakery=b, minsize=1)
+
+    with pytest.raises(InitializedError):
+        b.bake("SELECT now()")
+
+    with pytest.raises(InitializedError):
+        await create_engine(MYSQL_URL, bakery=b, minsize=0)
+
+    try:
+        for q in qs:
+            assert q.sql is not None
+            assert q.compiled_sql is not None
+
+            if api:
+                assert q.bind is e
+            else:
+                with pytest.raises(UninitializedError):
+                    q.bind.first()
+                with pytest.raises(UninitializedError):
+                    await q.first()
+
+            if api:
+                rv = await q.first(uid=uid)
+            else:
+                rv = await e.first(q, uid=uid)
+
+            if options.get("return_model", True):
+                assert isinstance(rv, User)
+                assert rv.id == uid
+            else:
+                assert rv[0] == rv[User.id] == rv["id"] == uid
+
+            eq = q.execution_options(return_model=True, loader=User)
+            assert eq is not q
+            assert isinstance(eq, BakedQuery)
+            assert type(eq) is not BakedQuery
+            assert eq in list(b)
+            assert eq.sql == q.sql
+            assert eq.compiled_sql is not q.compiled_sql
+
+            if api:
+                assert q.bind is e
+            else:
+                with pytest.raises(UninitializedError):
+                    eq.bind.first()
+                with pytest.raises(UninitializedError):
+                    await eq.first()
+
+            assert eq.query.get_execution_options()["return_model"]
+            assert eq.query.get_execution_options()["loader"] is User
+
+            if api:
+                rv = await eq.first(uid=uid)
+                non = await eq.first(uid=uid + 1)
+                rvl = await eq.all(uid=uid)
+            else:
+                rv = await e.first(eq, uid=uid)
+                non = await e.first(eq, uid=uid + 1)
+                rvl = await e.all(eq, uid=uid)
+
+            assert isinstance(rv, User)
+            assert rv.id == uid
+
+            assert non is None
+
+            assert len(rvl) == 1
+            assert rvl[0].id == uid
+
+            # original query is not affected
+            if api:
+                rv = await q.first(uid=uid)
+            else:
+                rv = await e.first(q, uid=uid)
+
+            if options.get("return_model", True):
+                assert isinstance(rv, User)
+                assert rv.id == uid
+            else:
+                assert rv[0] == rv[User.id] == rv["id"] == uid
+
+    finally:
+        if api:
+            await db.pop_bind().close()
+        else:
+            await e.close()
+
+
+async def test_class_level_bake():
+    class BakeOnClass(db.Model):
+        __tablename__ = "bake_on_class_test"
+
+        name = db.Column(db.String(255), primary_key=True)
+
+        @db.bake
+        def getter(cls):
+            return cls.query.where(cls.name == db.bindparam("name"))
+
+    async with db.with_bind(MYSQL_URL, prebake=False, autocommit=True):
+        await db.gino.create_all()
+        try:
+            await BakeOnClass.create(name="exist")
+            assert (await BakeOnClass.getter.one(name="exist")).name == "exist"
+            assert (await BakeOnClass.getter.one_or_none(name="nonexist")) is None
+        finally:
+            await db.gino.drop_all()

mysql_tests/test_json.py

@@ -199,6 +199,7 @@ async def test_no_profile():
         class Test(db.Model):
             __tablename__ = "tests_no_profile"
 
+            id = db.Column(db.BigInteger(), primary_key=True)
             age = db.IntegerProperty(default=18)
 
 
@@ -213,11 +214,12 @@ def process_result_value(self, *_):
 
     class PropsTest(db.Model):
         __tablename__ = "props_test_291"
-        profile1 = db.Column(JSON(), nullable=False, default="{}")
-        profile2 = db.Column(CustomJSON(), nullable=False, default="{}")
+        profile = db.Column(JSON(), nullable=False, default={})
+        profile1 = db.Column(JSON(), nullable=False, default={})
+        profile2 = db.Column(CustomJSON(), nullable=False, default={})
 
-        bool = db.BooleanProperty(prop_name="profile1")
-        bool1 = db.BooleanProperty(prop_name="profile2")
+        bool = db.BooleanProperty()
+        bool1 = db.BooleanProperty(prop_name="profile1")
 
     await PropsTest.gino.create()
     try:

mysql_tests/test_schema.py

@@ -61,10 +61,3 @@ class Comment2(db.Model):
 
     await db.gino.create_all()
     await db.gino.drop_all()
-
-
-async def test_no_alter(engine, mocker):
-    engine.dialect.supports_alter = False
-    warn = mocker.patch("warnings.warn")
-    await test(engine, define=False)
-    assert warn.called

src/gino/__init__.py

@@ -19,6 +19,8 @@ def create_engine(*args, **kwargs):
        * **Pre-bake** immediately when connected to the database (default).
        * No **pre-bake** but create prepared statements lazily when needed for the first
          time.
+
+       Note: ``prebake`` has no effect in aiomysql
     """
 
     from sqlalchemy import create_engine

src/gino/declarative.py

@@ -365,8 +365,9 @@ def _init_table(cls, sub_cls):
                     json_col = getattr(
                         sub_cls.__dict__.get(v.prop_name), "column", None
                     )
-                    if not isinstance(json_col, sa.Column) or not isinstance(
-                        json_col.type, sa.JSON
+                    if not (
+                        isinstance(json_col, sa.Column) and
+                        isinstance(json_col.type, sa.JSON)
                     ):
                         raise AttributeError(
                             '{} "{}" requires a JSON[B] column "{}" '

src/gino/dialects/aiomysql.py

@@ -24,7 +24,7 @@
 JSON_COLTYPE = 245
 
 #: Regular expression for :meth:`Cursor.executemany`.
-#: executemany only suports simple bulk insert.
+#: executemany only supports simple bulk insert.
 #: You can use it to load large dataset.
 _RE_INSERT_VALUES = re.compile(
     r"\s*((?:INSERT|REPLACE)\s.+\sVALUES?\s+)"
@@ -158,6 +158,10 @@ async def async_execute(self, query, timeout, args, limit=0, many=False):
             self._async_executemany(conn, query, args), timeout=timeout
         )
 
+    async def execute_baked(self, baked_query, timeout, args, one):
+        # TODO: use prepare when it's supported
+        return await self.async_execute(baked_query.sql, timeout, args)
+
     async def _async_execute(self, conn, query, timeout, args):
         if args is not None:
             query = query % _escape_args(args, conn)
@@ -229,12 +233,14 @@ def iterate(self, context):
 
 
 class Pool(base.Pool):
-    def __init__(self, url, loop, init=None, **kwargs):
+    def __init__(self, url, loop, init=None, bakery=None, prebake=True, **kwargs):
         self._url = url
         self._loop = loop
         self._kwargs = kwargs
         self._pool = None
         self._conn_init = init
+        self._bakery = bakery
+        self._prebake = prebake
 
     async def _init(self):
         args = self._kwargs.copy()
@@ -366,6 +372,7 @@ class AiomysqlDialect(MySQLDialect, base.AsyncDialectMixin):
     cursor_cls = DBAPICursor
     init_kwargs = set(
         itertools.chain(
+            ("bakery", "prebake"),
             *[
                 inspect.getfullargspec(f).args
                 for f in [aiomysql.create_pool, aiomysql.connect]
@@ -376,24 +383,30 @@ class AiomysqlDialect(MySQLDialect, base.AsyncDialectMixin):
     }  # use SQLAlchemy's echo instead
     colspecs = util.update_copy(
         MySQLDialect.colspecs,
-        {ENUM: AsyncEnum, sqltypes.Enum: AsyncEnum, sqltypes.NullType: GinoNullType,},
+        {
+            ENUM: AsyncEnum,
+            sqltypes.Enum: AsyncEnum,
+            sqltypes.NullType: GinoNullType,
+        },
     )
     postfetch_lastrowid = False
     support_returning = False
     support_prepare = False
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, bakery=None, **kwargs):
         self._pool_kwargs = {}
         for k in self.init_kwargs:
             if k in kwargs:
                 self._pool_kwargs[k] = kwargs.pop(k)
         super().__init__(*args, **kwargs)
-        self._init_mixin()
+        self._init_mixin(bakery)
 
     async def init_pool(self, url, loop, pool_class=None):
         if pool_class is None:
             pool_class = Pool
-        return await pool_class(url, loop, init=self.on_connect(), **self._pool_kwargs)
+        return await pool_class(
+            url, loop, bakery=self._bakery, init=self.on_connect(), **self._pool_kwargs
+        )
 
     # noinspection PyMethodMayBeStatic
     def transaction(self, raw_conn, args, kwargs):