frozen queries initial concept

Author: dantownsend

piccolo/apps/user/tables.py

@@ -41,9 +41,7 @@ class BaseUser(Table, tablename="piccolo_user"):
     )
 
     def __init__(self, **kwargs):
-        """
-        Generating passwords upfront is expensive, so might need reworking.
-        """
+        # Generating passwords upfront is expensive, so might need reworking.
         password = kwargs.get("password", None)
         if password:
             kwargs["password"] = self.__class__.hash_password(password)

piccolo/query/base.py

@@ -22,10 +22,15 @@ def __exit__(self, exception_type, exception, traceback):
 
 class Query:
 
-    __slots__ = ("table",)
+    __slots__ = ("table", "_frozen_querystrings")
 
-    def __init__(self, table: t.Type[Table]):
+    def __init__(
+        self,
+        table: t.Type[Table],
+        frozen_querystrings: t.Optional[t.Sequence[QueryString]] = None,
+    ):
         self.table = table
+        self._frozen_querystrings = frozen_querystrings
 
     @property
     def engine_type(self) -> str:
@@ -156,6 +161,9 @@ def querystrings(self) -> t.Sequence[QueryString]:
         """
         Calls the correct underlying method, depending on the current engine.
         """
+        if self._frozen_querystrings is not None:
+            return self._frozen_querystrings
+
         engine_type = self.engine_type
         if engine_type == "postgres":
             try:
@@ -174,5 +182,68 @@ def querystrings(self) -> t.Sequence[QueryString]:
 
     ###########################################################################
 
+    def freeze(self) -> FrozenQuery:
+        """
+        This is a performance optimisation when the same query is run
+        repeatedly. For example:
+
+        .. code-block: python
+
+            TOP_BANDS = Band.select(
+                Band.name
+            ).order_by(
+                Band.popularity,
+                ascending=False
+            ).limit(
+                10
+            ).output(
+                as_json=True
+            ).freeze()
+
+            # In the corresponding view/endpoint of whichever web framework
+            # you're using:
+            async def top_bands(self, request):
+                return await TOP_BANDS.run()
+
+        It means that Piccolo doesn't have to work as hard each time the query
+        is run to generate the corresponding SQL - some of it is cached. If the
+        query is defined within the endpoint, it has to generate the SQL from
+        scratch each time.
+
+        Once a query is frozen, you can't apply any more clauses to it (where,
+        limit, output etc).
+
+        """
+        # Copy the query, so we don't store any references to the original.
+        query = self.__class__(
+            table=self.table, frozen_querystrings=self.querystrings
+        )
+        return FrozenQuery(query=query)
+
+    ###########################################################################
+
     def __str__(self) -> str:
         return "; ".join([i.__str__() for i in self.querystrings])
+
+
+class FrozenQuery:
+    def __init__(self, query: Query):
+        self.query = query
+
+    async def run(self, *args, **kwargs):
+        return await self.query.run(*args, **kwargs)
+
+    def run_sync(self, *args, **kwargs):
+        return self.query.run_sync(*args, **kwargs)
+
+    def __getattr__(self, name: str):
+        if hasattr(self.query, name):
+            raise AttributeError(
+                f"This query is frozen - {name} is only available on "
+                "unfrozen queries."
+            )
+        else:
+            raise AttributeError("Unrecognised attribute name.")
+
+    def __str__(self) -> str:
+        return self.query.__str__()

piccolo/query/methods/alter.py

@@ -506,7 +506,7 @@ def set_digits(
         return self
 
     @property
-    def querystrings(self) -> t.Sequence[QueryString]:
+    def default_querystrings(self) -> t.Sequence[QueryString]:
         if self._drop_table is not None:
             return [self._drop_table.querystring]
 

piccolo/query/methods/count.py

@@ -27,7 +27,7 @@ async def response_handler(self, response) -> bool:
         return response[0]["count"]
 
     @property
-    def querystrings(self) -> t.Sequence[QueryString]:
+    def default_querystrings(self) -> t.Sequence[QueryString]:
         select = Select(self.table)
         select.where_delegate._where = self.where_delegate._where
         return [

piccolo/query/methods/create.py

@@ -27,7 +27,7 @@ def __init__(
         self.only_default_columns = only_default_columns
 
     @property
-    def querystrings(self) -> t.Sequence[QueryString]:
+    def default_querystrings(self) -> t.Sequence[QueryString]:
         prefix = "CREATE TABLE"
         if self.if_not_exists:
             prefix += " IF NOT EXISTS"

piccolo/query/methods/delete.py

@@ -40,7 +40,7 @@ def _validate(self):
             )
 
     @property
-    def querystrings(self) -> t.Sequence[QueryString]:
+    def default_querystrings(self) -> t.Sequence[QueryString]:
         query = f"DELETE FROM {self.table._meta.tablename}"
         if self.where_delegate._where:
             query += " WHERE {}"

piccolo/query/methods/drop_index.py

@@ -27,7 +27,7 @@ def column_names(self) -> t.List[str]:
         ]
 
     @property
-    def querystrings(self) -> t.Sequence[QueryString]:
+    def default_querystrings(self) -> t.Sequence[QueryString]:
         column_names = self.column_names
         index_name = self.table._get_index_name(column_names)
         query = "DROP INDEX"

piccolo/query/methods/exists.py

@@ -29,7 +29,7 @@ async def response_handler(self, response) -> bool:
         return bool(response[0]["exists"])
 
     @property
-    def querystrings(self) -> t.Sequence[QueryString]:
+    def default_querystrings(self) -> t.Sequence[QueryString]:
         select = Select(table=self.table)
         select.where_delegate._where = self.where_delegate._where
         return [

piccolo/query/methods/objects.py

@@ -81,7 +81,7 @@ async def response_handler(self, response):
             return response
 
     @property
-    def querystrings(self) -> t.Sequence[QueryString]:
+    def default_querystrings(self) -> t.Sequence[QueryString]:
         select = Select(table=self.table)
 
         for attr in (

piccolo/query/methods/raw.py

@@ -20,5 +20,5 @@ def __init__(
         self.querystring = querystring
 
     @property
-    def querystrings(self) -> t.Sequence[QueryString]:
+    def default_querystrings(self) -> t.Sequence[QueryString]:
         return [self.querystring]