feat: resolve_wheres

Author: NightMarcher

.gitignore

@@ -1,3 +1,5 @@
 .vscode
 
+__pycache__
+
 Pipfile.lock

README.md

@@ -30,21 +30,26 @@ class AccountMgr(BaseManager, metaclass=DemoMetaclass):
 ### **select_custom_fields**
 **basic example**
 ```python
+aids = [1, 2, 3]
+
 await AccountMgr.select_custom_fields(
     fields=[
         "id", "extend ->> '$.last_login.ipv4' ipv4",
         "extend ->> '$.last_login.start_datetime' start_datetime",
         "CAST(extend ->> '$.last_login.online_sec' AS SIGNED) online_sec"
     ],
-    wheres=[f"id IN (1, 2, 3)"],
+    wheres=f"id IN ({', '.join(map(str, aids))}) AND gender = 1",  # These 4 ways of `wheres` can work equally
+    # wheres=Q(Q(id__in=aids), Q(gender=1), join_type="AND"),
+    # wheres={"id__in": aids, "gender": 1},
+    # wheres=[Q(id__in=aids), Q(gender=1)],
 )
 ```
 Generate sql and execute
 ```sql
     SELECT
         id, extend ->> '$.last_login.ipv4' ipv4, extend ->> '$.last_login.start_datetime' start_datetime, CAST(extend ->> '$.last_login.online_sec' AS SIGNED) online_sec
     FROM account
-    WHERE id IN (1, 2, 3)
+    WHERE `id` IN (1,2,3) AND `gender`=1
 ```
 
 **complex example**
@@ -53,9 +58,9 @@ await AccountMgr.select_custom_fields(
     fields=[
         "locale", "gender", "COUNT(1) cnt"
     ],
-    wheres=["id BETWEEN 1 AND 12"],
+    wheres="id BETWEEN 1 AND 12",
     groups=["locale", "gender"],
-    havings=["cnt > 0"],
+    having="cnt > 0",
     orders=["locale", "-gender"],
     limit=10,
 )
@@ -84,7 +89,7 @@ await AccountMgr.upsert_json_field(
         },
         "$.uuid": "fd04f7f2-24fc-4a73-a1d7-b6e99a464c5f",
     },
-    wheres=[f"id = 8"],
+    wheres=f"id = 8",
 )
 ```
 Generate sql and execute
@@ -119,7 +124,7 @@ Generate sql and execute
 ### **insert_into_select**
 ```python
 await AccountMgr.insert_into_select(
-    wheres=[f"id IN (4, 5, 6)"],
+    wheres=f"id IN (4, 5, 6)",
     remain_fields=["gender", "locale"],
     assign_field_dict={
         "active": False,

examples/service/routers/account.py

@@ -5,6 +5,7 @@
 from fastapi import APIRouter, Body, Query
 from fastapi_esql.utils.sqlizer import RawSQL
 from pydantic import BaseModel, Field
+from tortoise.expressions import Q
 
 from examples.service.constants.enums import GenderEnum, LocaleEnum
 from examples.service.managers.demo.account import AccountMgr
@@ -55,9 +56,9 @@ async def query_group_by_locale_view(
         fields=[
             "locale", "gender", "COUNT(1) cnt"
         ],
-        wheres=["id BETWEEN 1 AND 12"],
+        wheres="id BETWEEN 1 AND 12",
         groups=["locale", "gender"],
-        havings=["cnt > 0"],
+        having="cnt > 0",
         orders=["locale", "-gender"],
         limit=10,
     )
@@ -103,7 +104,10 @@ async def query_last_login_view(
             "extend ->> '$.last_login.start_datetime' start_datetime",
             "CAST(extend ->> '$.last_login.online_sec' AS SIGNED) online_sec"
         ],
-        wheres=[f"id IN ({', '.join(map(str, aids))})"],
+        wheres=f"id IN ({', '.join(map(str, aids))}) AND gender = 1",
+        # wheres=Q(Q(id__in=aids), Q(gender=1), join_type="AND"),
+        # wheres={"id__in": aids, "gender": 1},
+        # wheres=[Q(id__in=aids), Q(gender=1)],
     )
     return {"dicts": dicts}
 
@@ -123,7 +127,7 @@ async def update_last_login_view(
             },
             "$.uuid": faker.uuid4(),
         },
-        wheres=[f"id = {aid}"],
+        wheres=f"id = {aid}",
     )
     return {"row_cnt": row_cnt}
 
@@ -154,7 +158,7 @@ async def bulk_clone_view(
     aids: List[int] = Body(..., embed=True),
 ):
     ok = await AccountMgr.insert_into_select(
-        wheres=[f"id IN ({', '.join(map(str, aids))})"],
+        wheres=f"id IN ({', '.join(map(str, aids))})",
         remain_fields=["gender", "locale"],
         assign_field_dict={
             "active": False,

fastapi_esql/__init__.py

@@ -1,6 +1,6 @@
 from logging.config import dictConfig
 
-from .const.error import WrongParamsError
+from .const.error import QsParsingError, WrongParamsError
 from .orm.base_app import AppMetaclass
 from .orm.base_manager import BaseManager
 from .orm.base_model import BaseModel
@@ -17,6 +17,7 @@
     "CursorHandler",
     "RawSQL",
     "SQLizer",
+    "QsParsingError"
     "WrongParamsError",
     "timing",
 ]

fastapi_esql/const/error.py

@@ -1,2 +1,6 @@
 class WrongParamsError(Exception):
     ...
+
+
+class QsParsingError(Exception):
+    ...

fastapi_esql/orm/base_manager.py

@@ -1,7 +1,8 @@
 from logging import getLogger
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
 from tortoise.backends.base.client import BaseDBAsyncClient
+from tortoise.expressions import Q
 from tortoise.models import Model
 
 from .base_app import AppMetaclass
@@ -63,9 +64,9 @@ async def bulk_create_from_dicts(cls, dicts: List[Dict[str, Any]], **kwargs) ->
     async def select_custom_fields(
         cls,
         fields: List[str],
-        wheres: List[str],
+        wheres: Union[str, Q, Dict[str, Any], List[Q]],
         groups: Optional[List[str]] = None,
-        havings: Optional[List[str]] = None,
+        having: Optional[str] = None,
         orders: Optional[List[str]] = None,
         limit: int = 0,
         conn: Optional[BaseDBAsyncClient] = None,
@@ -75,9 +76,10 @@ async def select_custom_fields(
             fields,
             wheres,
             groups,
-            havings,
+            having,
             orders,
             limit,
+            cls.model,
         )
         conn = conn or cls.ro_conn
         return await CursorHandler.fetch_dicts(sql, conn, logger)
@@ -87,13 +89,14 @@ async def upsert_json_field(
         cls,
         json_field: str,
         path_value_dict: Dict[str, Any],
-        wheres: List[str],
+        wheres: Union[str, Q, Dict[str, Any], List[Q]],
     ):
         sql = SQLizer.upsert_json_field(
             cls.table,
             json_field,
             path_value_dict,
             wheres,
+            cls.model,
         )
         return await CursorHandler.calc_row_cnt(sql, cls.rw_conn, logger)
 
@@ -115,7 +118,7 @@ async def upsert_on_duplicated(
     @classmethod
     async def insert_into_select(
         cls,
-        wheres: List[str],
+        wheres: Union[str, Q, Dict[str, Any], List[Q]],
         remain_fields: List[str],
         assign_field_dict: Dict[str, Any],
     ):
@@ -124,6 +127,7 @@ async def insert_into_select(
             wheres,
             remain_fields,
             assign_field_dict,
+            cls.model,
         )
         return await CursorHandler.exec_if_ok(sql, cls.rw_conn, logger)
 

fastapi_esql/utils/sqlizer.py

@@ -1,8 +1,12 @@
 from logging import getLogger
 from json import dumps
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
-from ..const.error import WrongParamsError
+from tortoise.expressions import Q
+from tortoise.models import Model
+from tortoise.query_utils import QueryModifier
+
+from ..const.error import QsParsingError, WrongParamsError
 
 logger = getLogger(__name__)
 # ensure the functionality of the RawSQL
@@ -19,11 +23,35 @@ def __init__(self, sql: str):
 class SQLizer:
 
     @classmethod
-    def resolve_condition(cls, conditions: List[str]) -> str:
-        return " AND ".join(conditions)
+    def resolve_wheres(
+        cls,
+        wheres: Union[str, Q, Dict[str, Any], List[Q]],
+        model: Optional[Model] = None,
+    ) -> str:
+        if not model and not isinstance(wheres, str):
+            raise WrongParamsError("Parameter `wheres` only support str type if no model passed")
+
+        if isinstance(wheres, str):
+            return wheres
+        elif isinstance(wheres, Q):
+            qs = [wheres]
+        elif isinstance(wheres, dict):
+            qs = [Q(**{key: value}) for (key, value) in wheres.items()]
+        elif isinstance(wheres, list):
+            qs = [q for q in wheres if isinstance(q, Q)]
+        else:
+            raise WrongParamsError("Parameter `wheres` only supports str, dict and list type")
+
+        if not qs:
+            raise QsParsingError("Parsing `wheres` for qs failed!")
+
+        modifier = QueryModifier()
+        for q in qs:
+            modifier &= q.resolve(model, model._meta.basetable)
+        return modifier.where_criterion.get_sql(quote_char="`")
 
     @classmethod
-    def resolve_ordering(cls, orderings: List[str]) -> str:
+    def resolve_orders(cls, orderings: List[str]) -> str:
         orders = []
         for o in orderings:
             if o.startswith("-"):
@@ -59,23 +87,24 @@ def select_custom_fields(
         cls,
         table: str,
         fields: List[str],
-        wheres: List[str],
+        wheres: Union[str, Q, Dict[str, Any], List[Q]],
         groups: Optional[List[str]] = None,
-        havings: Optional[List[str]] = None,
+        having: Optional[str] = None,
         orders: Optional[List[str]] = None,
         limit: int = 0,
+        model: Optional[Model] = None,
     ) -> Optional[str]:
         if not all([table, fields, wheres]):
             raise WrongParamsError("Please check your params")
-        if havings and not groups:
-            raise WrongParamsError("Please check your params")
+        if having and not groups:
+            raise WrongParamsError("Parameter `groups` shoud be no empty when `having` isn't")
 
         group_by = f"    GROUP BY {', '.join(groups)}" if groups else ""
-        having = f"    HAVING {cls.resolve_condition(havings)}" if havings else ""
-        order_by = f"    ORDER BY {cls.resolve_ordering(orders)}" if orders else ""
+        having_ = f"    HAVING {having}" if having else ""
+        order_by = f"    ORDER BY {cls.resolve_orders(orders)}" if orders else ""
         limit_ = f"    LIMIT {limit}" if limit else ""
         # NOTE Doesn't support `offset` parameter due to it's bad performance
-        extras = [group_by, having, order_by, limit_]
+        extras = [group_by, having_, order_by, limit_]
 
         sql = """
     SELECT
@@ -85,8 +114,8 @@ def select_custom_fields(
 {}""".format(
         ", ".join(fields),
         table,
-        cls.resolve_condition(wheres),
-        "\n".join(extras) if extras else "",
+        cls.resolve_wheres(wheres, model),
+        "\n".join(i for i in extras if i),
     )
         logger.debug(sql)
         return sql
@@ -97,7 +126,8 @@ def upsert_json_field(
         table: str,
         json_field: str,
         path_value_dict: Dict[str, Any],
-        wheres: List[str],
+        wheres: Union[str, Q, Dict[str, Any], List[Q]],
+        model: Optional[Model] = None,
     ) -> Optional[str]:
         if not all([table, json_field, path_value_dict, wheres]):
             raise WrongParamsError("Please check your params")
@@ -110,7 +140,7 @@ def upsert_json_field(
         sql = f"""
     UPDATE {table}
     SET {json_field} = JSON_SET(COALESCE({json_field}, '{{}}'), {", ".join(params)})
-    WHERE {cls.resolve_condition(wheres)}"""
+    WHERE {cls.resolve_wheres(wheres, model)}"""
         logger.debug(sql)
         return sql
 
@@ -147,9 +177,10 @@ def upsert_on_duplicated(
     def insert_into_select(
         cls,
         table: str,
-        wheres: List[str],
+        wheres: Union[str, Q, Dict[str, Any], List[Q]],
         remain_fields: List[str],
         assign_field_dict: Dict[str, Any],
+        model: Optional[Model] = None,
     ) -> Optional[str]:
         if not all([table, wheres] or not any([remain_fields, assign_field_dict])):
             raise WrongParamsError("Please check your params")
@@ -166,7 +197,7 @@ def insert_into_select(
         ({", ".join(fields)})
     SELECT {", ".join(remain_fields + assign_fields)}
     FROM {table}
-    WHERE {cls.resolve_condition(wheres)}"""
+    WHERE {cls.resolve_wheres(wheres, model)}"""
         logger.debug(sql)
         return sql