add lazy baked prepared statement

Author: fantix

docs/how-to/bakery.rst

@@ -191,3 +191,24 @@ suffix, plus it is directly executable.
 .. seealso::
 
     Please see API document of :mod:`gino.bakery` for more information.
+
+
+I don't want the prepared statements.
+-------------------------------------
+
+If you don't need all the baked queries (``m``) to create prepared statements for all
+the active database connections (``n``) in the beginning, you could set
+``prebake=False`` in the engine initialization to prevent the default initial
+``m x n`` prepare calls::
+
+    e = await gino.create_engine("postgresql://...", bakery=bakery, prebake=False)
+
+Or if you're using bind::
+
+    await db.set_bind("postgresql://...", prebake=False)
+
+This is useful when you're depending on ``db.gino.create_all()`` to create the tables,
+because the prepared statements can only be created after the table creation.
+
+The prepared statements will then be created and cached lazily on demand.
+

src/gino/__init__.py

@@ -11,6 +11,14 @@ def create_engine(*args, **kwargs):
 
     .. versionchanged:: 1.1
        Added the ``bakery`` keyword argument, please see :class:`~.bakery.Bakery`.
+
+    .. versionchanged:: 1.1
+       Added the ``prebake`` keyword argument to choose when to create the prepared
+       statements for the queries in the bakery:
+
+       * **Pre-bake** immediately when connected to the database (default).
+       * No **pre-bake** but create prepared statements lazily when needed for the first
+         time.
     """
 
     from sqlalchemy import create_engine

src/gino/declarative.py

@@ -168,17 +168,17 @@ def __table_args__(cls):
 
         Added ``with_table`` parameter which works after the ``__table__`` is created::
 
-        class User(db.Model):
-            __tablename__ = "users"
+            class User(db.Model):
+                __tablename__ = "users"
 
-            ...
+                ...
 
-            @db.declared_attr(with_table=True)
-            def table_name(cls):
-                # this is called only once when defining the class
-                return cls.__table__.name
+                @db.declared_attr(with_table=True)
+                def table_name(cls):
+                    # this is called only once when defining the class
+                    return cls.__table__.name
 
-        assert User.table_name == "users"
+            assert User.table_name == "users"
 
     """
     if m is None:

src/gino/dialects/asyncpg.py

@@ -190,12 +190,19 @@ def executor(state, timeout_):
     async def execute_baked(self, baked_query, timeout, args, one):
         conn, timeout = await self._acquire(timeout)
         stmt = conn.baked_queries.get(baked_query)
-        if not stmt:
-            raise RuntimeError("query is not baked yet")
-
-        # work around prepared statement limit per connection acquisition
-        # https://github.com/MagicStack/asyncpg/issues/190
-        stmt._con_release_ctr = conn._pool_release_ctr
+        if stmt:
+            # work around prepared statement limit per connection acquisition
+            # https://github.com/MagicStack/asyncpg/issues/190
+            stmt._con_release_ctr = conn._pool_release_ctr
+        else:
+            if timeout:
+                before = time.monotonic()
+                stmt = await conn.prepare(baked_query.sql, timeout=timeout)
+                after = time.monotonic()
+                timeout -= after - before
+            else:
+                stmt = await conn.prepare(baked_query.sql)
+            conn.baked_queries[baked_query] = stmt
 
         if one:
             rv = await stmt.fetchrow(*args, timeout=timeout)
@@ -218,17 +225,17 @@ def get_statusmsg(self):
 
 
 class Pool(base.Pool):
-    def __init__(self, url, loop, bakery=None, **kwargs):
+    def __init__(self, url, loop, bakery=None, prebake=True, **kwargs):
         self._url = url
         self._loop = loop
         self._kwargs = kwargs
         self._pool = None
         self._bakery = bakery
         self._init_hook = None
+        self._prebake = prebake
 
     async def _init(self):
         args = self._kwargs.copy()
-        self._init_hook = args.pop("init", None)
 
         class Connection(args.pop("connection_class", asyncpg.Connection)):
             __slots__ = ("baked_queries",)
@@ -244,9 +251,11 @@ def __init__(self, *pargs, **kwargs):
             user=self._url.username,
             database=self._url.database,
             password=self._url.password,
-            init=self._bake,
             connection_class=Connection,
         )
+        if self._prebake and self._bakery:
+            self._init_hook = args.pop("init", None)
+            args["init"] = self._bake
         self._pool = await asyncpg.create_pool(**args)
         return self
 
@@ -474,10 +483,11 @@ class AsyncpgDialect(PGDialect, base.AsyncDialectMixin):
     cursor_cls = DBAPICursor
     init_kwargs = set(
         itertools.chain(
+            ("bakery", "prebake"),
             *[
                 inspect.getfullargspec(f).kwonlydefaults.keys()
                 for f in [asyncpg.create_pool, asyncpg.connect]
-            ]
+            ],
         )
     )
     colspecs = util.update_copy(
@@ -490,7 +500,7 @@ class AsyncpgDialect(PGDialect, base.AsyncDialectMixin):
         },
     )
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, bakery=None, **kwargs):
         self._pool_kwargs = {}
         self._init_hook = None
         for k in self.init_kwargs:
@@ -500,7 +510,7 @@ def __init__(self, *args, **kwargs):
                 else:
                     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:

src/gino/dialects/base.py

@@ -411,10 +411,20 @@ class AsyncDialectMixin:
     dbapi_class = BaseDBAPI
     _bakery = None
 
-    def _init_mixin(self):
+    def _init_mixin(self, bakery):
         self._sa_conn = _SAConnection(
             _SAEngine(self), _DBAPIConnection(self.cursor_cls)
         )
+        if bakery:
+            if bakery._closed:
+                raise InitializedError("Cannot reuse a closed bakery!")
+            self._bakery = bakery
+            for bq in bakery:
+                conn = self._sa_conn.execution_options(compiled_cache=bq)
+                context = conn.execute(bq.query, _bypass_no_param).context
+                # noinspection PyProtectedMember
+                bq._set_sql(context.statement)
+            bakery._closed = True
 
     @classmethod
     def dbapi(cls):
@@ -432,14 +442,3 @@ async def init_pool(self, url, loop):
 
     def transaction(self, raw_conn, args, kwargs):
         raise NotImplementedError
-
-    def set_bakery(self, bakery):
-        if bakery._closed:
-            raise InitializedError("Cannot reuse a closed bakery!")
-        self._bakery = bakery
-        for bq in bakery:
-            conn = self._sa_conn.execution_options(compiled_cache=bq)
-            context = conn.execute(bq.query, _bypass_no_param).context
-            # noinspection PyProtectedMember
-            bq._set_sql(context.statement)
-        bakery._closed = True

src/gino/strategies.py

@@ -51,11 +51,6 @@ async def create(self, name_or_url, loop=None, **kwargs):
         dialect_args["dbapi"] = dbapi
 
         dialect = dialect_cls(**dialect_args)
-
-        bakery = kwargs.pop("bakery", None)
-        if bakery:
-            dialect.set_bakery(bakery)
-
         pool_class = kwargs.pop("pool_class", None)
         pool = await dialect.init_pool(u, loop, pool_class=pool_class)
 

tests/test_bakery.py

@@ -173,12 +173,11 @@ class BakeOnClass(db.Model):
         def getter(cls):
             return cls.query.where(cls.name == db.bindparam("name"))
 
-    e = sqlalchemy.create_engine(PG_URL)
-    db.create_all(e)
-    try:
-        async with db.with_bind(PG_URL):
+    async with db.with_bind(PG_URL, prebake=False):
+        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:
-        db.drop_all(e)
+        finally:
+            await db.gino.drop_all()