dapper-sqls 1.2.2__py3-none-any.whl → 1.2.4__py3-none-any.whl

dapper_sqls/builders/model/model.py

@@ -4,7 +4,7 @@ from itertools import groupby
 import os
 from .utils import (create_content_orm, TableInformation, ColumnInformation, InformationSchemaRoutines, create_field, create_content_async_orm,
                     create_params_routine, get_parameters_with_defaults, create_queue_update, create_table_description, create_arg,
-                    SqlTable)
+                    SqlTable, SqlStored)
 from ...models import TableBaseModel
 
 class TableBuilderData:
@@ -294,24 +294,26 @@ class ModelBuilder(object):
         """
 
         self.query_routines = f"""
-            SELECT 
-                p.SPECIFIC_NAME,
-                p.PARAMETER_NAME,
-                p.DATA_TYPE,
-                p.SPECIFIC_CATALOG,
-                p.SPECIFIC_SCHEMA,
-                p.ORDINAL_POSITION,
-                sm.definition AS PROCEDURE_DEFINITION
-            FROM 
-                INFORMATION_SCHEMA.PARAMETERS p
-            JOIN 
-                INFORMATION_SCHEMA.ROUTINES r ON p.SPECIFIC_NAME = r.SPECIFIC_NAME
-            JOIN 
-                sys.sql_modules sm ON OBJECT_NAME(sm.object_id) = r.SPECIFIC_NAME
-            WHERE 
-                r.ROUTINE_TYPE = 'PROCEDURE'
-            ORDER BY 
-                p.SPECIFIC_NAME, p.ORDINAL_POSITION;
+            SELECT  
+                r.SPECIFIC_CATALOG,
+                r.SPECIFIC_SCHEMA,
+                r.SPECIFIC_NAME,
+                sm.definition AS PROCEDURE_DEFINITION,
+                (
+                    SELECT 
+                        p.ORDINAL_POSITION,
+                        p.PARAMETER_NAME,
+                        p.DATA_TYPE
+                    FROM INFORMATION_SCHEMA.PARAMETERS p
+                    WHERE p.SPECIFIC_NAME = r.SPECIFIC_NAME
+                    ORDER BY p.ORDINAL_POSITION
+                    FOR JSON PATH
+                ) AS PARAMETERS
+            FROM INFORMATION_SCHEMA.ROUTINES r
+            JOIN sys.sql_modules sm 
+                ON OBJECT_NAME(sm.object_id) = r.SPECIFIC_NAME
+            WHERE r.ROUTINE_TYPE = 'PROCEDURE'
+            ORDER BY r.SPECIFIC_NAME;
         """
 
     @property
@@ -358,19 +360,12 @@ class ModelBuilder(object):
             return False
         return grouped_list
 
-    def get_routines_data(self):
+    def get_routines_data(self) -> list[SqlStored]:
         with self.dapper.query() as db:
-            information_schema_routines = db.fetchall(self.query_routines)
-            if not information_schema_routines:
+            rows = db.fetchall(self.query_routines)
+            if not rows.success:
                 return []
-            information_schema_routines = self.dapper.load(InformationSchemaRoutines, information_schema_routines)
-
-        information_schema_routines.sort(key=lambda x: x.SPECIFIC_NAME)
-        grouped_data = groupby(information_schema_routines, lambda  x: x.SPECIFIC_NAME)
-        grouped_list : list[list[InformationSchemaRoutines]] = [[obj for obj in group] for _, group in grouped_data]
-        if not grouped_list:
-            return []
-        return grouped_list
+        return self.dapper.load(SqlStored, rows)
     
     def get_models_db(self, tables : dict[str, SqlTable]):
         models : list[TableBaseModel] = []
@@ -410,7 +405,7 @@ class ModelBuilder(object):
             if d.CHARACTER_MAXIMUM_LENGTH is not None and d.CHARACTER_MAXIMUM_LENGTH > 0 and d.available
         }
 
-        table_alias = f'_alias_{table_name.lower()}_alias_'
+        table_alias = table_name.lower()
 
         content_model = f'''# coding: utf-8
 class {class_name}(TableBaseModel):
@@ -533,7 +528,7 @@ class {class_name}(TableBaseModel):
                 if d.CHARACTER_MAXIMUM_LENGTH is not None and d.CHARACTER_MAXIMUM_LENGTH > 0
             }
 
-            table_alias = f'_alias_{table_name.lower()}_alias_'
+            table_alias = table_name.lower()
             
             content_model = f'''# coding: utf-8
 
@@ -581,36 +576,36 @@ class {class_name}(TableBaseModel):
         for data in information_routines:
 
             if table_catalog != "all":
-                if data[0].SPECIFIC_CATALOG not in table_catalog :
+                if data.SPECIFIC_CATALOG not in table_catalog :
                     continue
 
             if table_schema != "all":
-                if data[0].SPECIFIC_SCHEMA not in table_schema :
+                if data.SPECIFIC_SCHEMA not in table_schema :
                     continue
 
-            routine_oprions = dict_routines_options.get(data[0].SPECIFIC_NAME)
+            routine_oprions = dict_routines_options.get(data.SPECIFIC_NAME)
             if routine_oprions:
                 if routine_oprions.ignore_routine:
                     continue
             
-            defaults_values = get_parameters_with_defaults(data[0].PROCEDURE_DEFINITION)
+            defaults_values = get_parameters_with_defaults(data.PROCEDURE_DEFINITION)
             params_routine = [create_params_routine(row, defaults_values) for row in data]
             params_routine_str = ", ".join(params_routine)
 
-            stp_name = data[0].SPECIFIC_NAME.replace('STP_', '')
+            stp_name = data.SPECIFIC_NAME.replace('STP_', '')
             content_routine = f'''
     def {stp_name}(self, *, {params_routine_str}):
-        return StpBuilder(self.dapper, '[{data[0].SPECIFIC_SCHEMA}].[{data[0].SPECIFIC_NAME}]',locals())'''
+        return StpBuilder(self.dapper, '[{data.SPECIFIC_SCHEMA}].[{data.SPECIFIC_NAME}]',locals())'''
 
             content_async_routine = f'''
     def {stp_name}(self, *, {params_routine_str}):
-        return AsyncStpBuilder(self.async_dapper, '[{data[0].SPECIFIC_SCHEMA}].[{data[0].SPECIFIC_NAME}]', locals())'''
+        return AsyncStpBuilder(self.async_dapper, '[{data.SPECIFIC_SCHEMA}].[{data.SPECIFIC_NAME}]', locals())'''
             
-            catalog = data[0].SPECIFIC_CATALOG
+            catalog = data.SPECIFIC_CATALOG
             if catalog not in builder_data:
                 builder_data[catalog] = BuilderData(catalog)
 
-            builder_data[catalog].routines.append(RoutineBuilderData(data[0].SPECIFIC_SCHEMA, data[0].SPECIFIC_NAME, content_routine, content_async_routine))
+            builder_data[catalog].routines.append(RoutineBuilderData(data.SPECIFIC_SCHEMA, data.SPECIFIC_NAME, content_routine, content_async_routine))
 
         for catalog, data in builder_data.items():
             import_init_db += f"from .{catalog} import {catalog}\n"

dapper_sqls/builders/model/utils.py

@@ -161,13 +161,27 @@ class SqlTable(TableInformation):
     COLUMNS : list[ColumnInformation] = []
 
 class InformationSchemaRoutines(BaseModel):
-    SPECIFIC_CATALOG : str = Field("", description="")
-    SPECIFIC_SCHEMA : str = Field("", description="")
-    SPECIFIC_NAME : str = Field("", description="")
-    ORDINAL_POSITION : int = Field(None, description="")
-    PARAMETER_NAME : str = Field("", description="")
-    DATA_TYPE : str = Field("", description="")
-    PROCEDURE_DEFINITION : str = Field("", description="")
+    ORDINAL_POSITION: int | None = None
+    PARAMETER_NAME: str = ""
+    DATA_TYPE: str = ""
+
+class SqlStored(BaseModel):
+    SPECIFIC_CATALOG: str
+    SPECIFIC_SCHEMA: str
+    SPECIFIC_NAME: str
+    PROCEDURE_DEFINITION: str
+    PARAMETERS: list[InformationSchemaRoutines] = []
+
+    @model_validator(mode="before")
+    @classmethod
+    def parse_json_fields(cls, data):
+        if isinstance(data, dict):
+            if isinstance(data.get("PARAMETERS"), str):
+                try:
+                    data["PARAMETERS"] = json.loads(data["PARAMETERS"])
+                except Exception:
+                    data["PARAMETERS"] = []
+        return data
     
 def create_database_description(tables: List[TableInformation]) -> str:
     lines = []

dapper_sqls/builders/query.py

@@ -2,11 +2,12 @@
 from typing import Union
 from datetime import datetime, date
 from ..models import TableBaseModel, QueryFieldBase, BaseJoinConditionField, SearchTable, JoinSearchTable
+import json
 
 class QueryBuilder(object):
 
     @classmethod
-    def build_where_clause(cls, model: TableBaseModel, table_alias: str = "", base_table_alias : str = "") -> str:
+    def build_where_clause(cls, model: TableBaseModel, table_alias: str = "") -> str:
         clause_parts = []
 
         for field_name, field_value in model:
@@ -18,9 +19,7 @@ class QueryBuilder(object):
             qualified_field = f"{table_alias}.{field_name}" if table_alias.strip() else field_name
 
             if  isinstance(field_value, BaseJoinConditionField):
-                sql = field_value.to_sql(base_table_alias, qualified_field)
-                if sql:
-                    clause_parts.append(sql)
+                continue
 
             elif isinstance(field_value, QueryFieldBase):
                 sql = field_value.to_sql(qualified_field)
@@ -34,16 +33,20 @@ class QueryBuilder(object):
                 elif isinstance(field_value, bool):
                     clause_parts.append(f"{qualified_field} = {'1' if field_value else '0'}")
                 elif isinstance(field_value, datetime):
-                    clause_parts.append(f"{qualified_field} = '{field_value.strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]}'")
+                    ms = field_value.microsecond // 1000
+                    formatted = field_value.strftime(f"%Y-%m-%d %H:%M:%S.{ms:03d}")
+                    clause_parts.append(f"{qualified_field} = '{formatted}'")
                 elif isinstance(field_value, date):
                     clause_parts.append(f"{qualified_field} = '{field_value.strftime('%Y-%m-%d')}'")
                 elif isinstance(field_value, bytes):
                     # Converte os bytes em uma string hexadecimal para SQL (ex: 0x4E6574)
                     hex_value = field_value.hex()
                     clause_parts.append(f"{qualified_field} = 0x{hex_value}")
+                elif isinstance(field_value, dict):
+                    clause_parts.append(f"{qualified_field} = '{json.dumps(field_value, ensure_ascii=False)}'")
                 else:
-                    clause_parts.append(f"{qualified_field} = {field_value}")
-
+                    clause_parts.append(f"{qualified_field} = '{str(field_value)}'")
+  
         return " AND ".join(clause_parts)
     
     @staticmethod
@@ -54,15 +57,19 @@ class QueryBuilder(object):
         elif isinstance(value, bool):
             return '1' if value else '0'
         elif isinstance(value, datetime):
-            return f"'{value.strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]}'"
+            ms = value.microsecond // 1000
+            formatted = value.strftime(f"%Y-%m-%d %H:%M:%S.{ms:03d}")
+            return f"'{formatted}'"
         elif isinstance(value, date):
             return f"'{value.strftime('%Y-%m-%d')}'"
         elif isinstance(value, bytes):
             return f"0x{value.hex()}"
+        elif isinstance(value, dict):
+            return f"'{json.dumps(value, ensure_ascii=False)}'"
         elif value is None:
             return "NULL"
         else:
-            return str(value)
+            return f"'{str(value)}'"
     
     @staticmethod
     def build_select_fields(search_table: SearchTable, table_alias: str, rename_fields: bool = True) -> str:
@@ -91,10 +98,10 @@ class QueryBuilder(object):
     @classmethod
     def update(cls, model: TableBaseModel, where : Union[str , TableBaseModel]):
         model._reset_defaults()
-        update_data = {k: int(v) if isinstance(v, bool) else v for k, v in model.model_dump(mode="json", exclude_none=True).items()}
+        update_data = model.model_dump(exclude_none=True)
         if not isinstance(where, str):
             where._reset_defaults()
-            for key in where.model_dump(mode="json", exclude_none=True):
+            for key in where.model_dump(exclude_none=True):
                 if key in update_data:
                     update_data.pop(key, None)
             where = cls.build_where_clause(where)
@@ -111,7 +118,7 @@ class QueryBuilder(object):
         model._reset_defaults()
         insert_data = {
             k: int(v) if isinstance(v, bool) else v
-            for k, v in model.model_dump(mode="json", exclude_none=True).items()
+            for k, v in model.model_dump(exclude_none=True).items()
         }
         columns = ", ".join(insert_data.keys())
         values = ", ".join(cls.format_sql_value(v) for v in insert_data.values())
@@ -157,6 +164,7 @@ class QueryBuilder(object):
 
         # JOINs
         join_clauses = []
+        join_where_clauses : list[str] = []
         for join_search in joins:
             join_model = join_search.model
             join_model._reset_defaults()
@@ -172,13 +180,19 @@ class QueryBuilder(object):
                 f"ON {on_conditions}"
             )
             join_clauses.append(join_clause)
-
+            
             # Campos SELECT do JOIN
             select_fields += ", " + cls.build_select_fields(join_search, join_table_alias)
 
+            join_where_clause = cls.build_where_clause(join_model, join_table_alias)
+            if join_where_clause.strip():
+                join_where_clauses.append(join_where_clause)
+
         # WHERE principal
         where_clause = cls.build_where_clause(main_model, main_table_alias)
         where_part = f"WHERE {where_clause}" if where_clause else ""
+        for join_where_clause in join_where_clauses:
+            where_part += f" AND {join_where_clause}"
 
         # SQL final
         sql_query = (

dapper_sqls/builders/stored.py

@@ -1,24 +1,49 @@
 # coding: utf-8
 from typing import Type
-from pydantic import BaseModel
+from datetime import datetime, date
+from ..models import TableBaseModel
+import json
 
 class StoredBuilder:
-    @staticmethod
-    def _build_where_clause(**kwargs):
+
+    @classmethod
+    def _build_where_clause(cls, **kwargs):
         conditions = []
         parameters = []
         for field, value in kwargs.items():
             if value is not None:
-                    conditions.append(f"{field} = ?")
-                    parameters.append(value)
+                conditions.append(f"{field} = ?")
+                parameters.append(cls.format_sql_value(value))
         return " AND ".join(conditions), tuple(parameters)
+    
+    @staticmethod
+    def format_sql_value(value):
+        if isinstance(value, str):
+            value = value.replace("'", "''")
+            return f"{value}"
+        elif isinstance(value, bool):
+            return 1 if value else 0
+        elif isinstance(value, datetime):
+            ms = value.microsecond // 1000
+            formatted = value.strftime(f"%Y-%m-%d %H:%M:%S.{ms:03d}")
+            return f"{formatted}"
+        elif isinstance(value, date):
+            return f"{value.strftime('%Y-%m-%d')}"
+        elif isinstance(value, bytes):
+            return f"0x{value.hex()}"
+        elif isinstance(value, dict):
+            return json.dumps(value, ensure_ascii=False)
+        elif value is None:
+            return "NULL"
+        else:
+            return str(value)
 
     @classmethod
-    def update(cls, model: Type[BaseModel], where: Type[BaseModel]):
+    def update(cls, model: Type[TableBaseModel], where: Type[TableBaseModel]):
         model._reset_defaults()
         where._reset_defaults()
-        update_data = {k: int(v) if isinstance(v, bool) else v for k, v in model.model_dump(mode="json", exclude_none=True).items()}
-        where_data = {k: int(v) if isinstance(v, bool) else v for k, v in where.model_dump(mode="json", exclude_none=True).items()}
+        update_data = model.model_dump(exclude_none=True)
+        where_data = where.model_dump(exclude_none=True)
 
         for key in where_data:
             if key in update_data:
@@ -32,9 +57,9 @@ class StoredBuilder:
         return sql_query, tuple(update_data.values()) + where_params
 
     @classmethod
-    def insert(cls, model : Type[BaseModel], name_column_id = 'Id'):
+    def insert(cls, model : Type[TableBaseModel], name_column_id = 'Id'):
         model._reset_defaults()
-        insert_data = {k: int(v) if isinstance(v, bool) else v for k, v in model.model_dump(mode="json", exclude_none=True).items()}
+        insert_data = {k: cls.format_sql_value(v) for k, v in model.model_dump(exclude_none=True).items()}
         columns = ", ".join(insert_data.keys())
         values = ", ".join(["?" for _ in insert_data.values()])
         sql_query = f"""
@@ -45,10 +70,10 @@ class StoredBuilder:
         return sql_query, tuple(insert_data.values())
 
     @classmethod
-    def select(cls, model : Type[BaseModel], additional_sql : str = "" ,select_top : int= None):
+    def select(cls, model : Type[TableBaseModel], additional_sql : str = "" ,select_top : int= None):
         model._reset_defaults()
         top_clause = f"TOP ({select_top}) * " if select_top else "*"
-        select_data = {k: int(v) if isinstance(v, bool) else v for k, v in model.model_dump(mode="json", exclude_none=True).items()}
+        select_data = model.model_dump(exclude_none=True)
         where_clause, parameters = cls._build_where_clause(**select_data)
 
         sql_query = f"SELECT {top_clause} FROM {model.TABLE_NAME}" 
@@ -58,9 +83,9 @@ class StoredBuilder:
         return sql_query, parameters
 
     @classmethod
-    def delete(cls, model : Type[BaseModel]):
+    def delete(cls, model : Type[TableBaseModel]):
         model._reset_defaults()
-        delete_data = {k: int(v) if isinstance(v, bool) else v for k, v in model.model_dump(mode="json", exclude_none=True).items()}
+        delete_data = model.model_dump(exclude_none=True)
         where_clause, parameters = cls._build_where_clause(**delete_data)
         if not where_clause:
             raise ValueError("DELETE operation requires at least one condition.")

dapper_sqls/dapper/executors.py

@@ -249,7 +249,7 @@ class Query(BaseExecutor):
             elif exec_type == ExecType.fetchall:
                 return Result.Fetchall(query_sql, None, None, ex)
             elif exec_type == ExecType.send:
-                return Result.Send(query_sql, False, str(ex))
+                return Result.Send(query_sql, False, ex)
         
         # retorna o resultado
         return result

dapper_sqls/models/base.py

@@ -235,9 +235,17 @@ class TableBaseModel(BaseModel, ABC):
 class SearchTable(BaseModel):
     model: TableBaseModel
     include: Optional[List[str]] = Field(default_factory=list)
- 
+
+    def model_dump_log(self):
+        model = self.model.model_dump(exclude_none=True, mode="json")
+        return {'model': model, 'include': self.include}
+
 class JoinSearchTable(SearchTable):
     join_type: Literal["INNER", "LEFT", "RIGHT", "FULL"] = "LEFT"
+
+    def model_dump_log(self,):
+        model = self.model.model_dump(exclude_none=True, mode="json")
+        return {'table': self.model.__class__.__name__, 'model': model, 'include': self.include, 'type': self.join_type}
     
 class BaseUpdate(ABC):
 

dapper_sqls/models/query_field.py

@@ -24,7 +24,9 @@ class QueryFieldBase(BaseModel, ABC):
         elif isinstance(val, bool):
             return '1' if val else '0'
         elif isinstance(val, datetime):
-            return f"'{val.strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]}'"
+            ms = val.microsecond // 1000
+            formatted = val.strftime(f"%Y-%m-%d %H:%M:%S.{ms:03d}")
+            return f"'{formatted}'"
         elif isinstance(val, date):
             return f"'{val.strftime('%Y-%m-%d')}'"
         return str(val)

dapper_sqls/models/result.py

@@ -4,6 +4,7 @@ from .._types import SqlErrorType, SQL_ERROR_HTTP_CODES, T
 from .base import SensitiveFields
 import json
 from collections import defaultdict
+import sqlparse
 
 def result_dict(cursor, result):
     return dict(
@@ -47,17 +48,28 @@ class Error(object):
         self.message =  str(exception) if isinstance(exception, Exception) else ""
         self.type = classify_error(self.message)
 
+def format_sql(query: str) -> str:
+    formatted_query = sqlparse.format(
+        query,
+        reindent=True,       
+        keyword_case='upper', 
+        identifier_case=None,
+        strip_comments=False,
+        use_space_around_operators=True
+    )
+    return formatted_query
+
 class BaseResult(object):
     def __init__(self, query : str | tuple):
         if isinstance(query, tuple):
             q_str, *params = query
             stored_procedure = {
-                "query": q_str,
+                "query": format_sql(q_str),
                 "params": [list(p) if isinstance(p, tuple) else p for p in params]
             }
             self._query = json.dumps(stored_procedure)
         else:
-            self._query = query
+            self._query = format_sql(query)
 
     @property
     def query(self):

dapper_sqls/sqlite/installer.py

@@ -34,9 +34,12 @@ class DataBaseInstall(object):
                with self.engine.connect() as conn:
                     self.tables.meta_data.create_all(self.engine)
                     if hasattr(self.tables, 'system'):
-                         ins = insert(self.tables.system).values(App=app_name, Tema='light')
-                         conn.execute(ins)
-                    conn.commit()
+                         try:
+                              ins = insert(self.tables.system).values(App=app_name, Tema='light')
+                              conn.execute(ins)
+                              conn.commit()
+                         except:
+                              ...
           else:
                if not self.are_tables_existing(self.engine):
                     try:

{dapper_sqls-1.2.2.dist-info → dapper_sqls-1.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dapper-sqls
-Version: 1.2.2
+Version: 1.2.4
 Summary: UNKNOWN
 Home-page: UNKNOWN
 Author: Samuel Semedo
@@ -36,6 +36,7 @@ Requires-Dist: typing-extensions
 Requires-Dist: urllib3
 Requires-Dist: wheel-filename
 Requires-Dist: yarl
+Requires-Dist: sqlparse
 
 UNKNOWN
 

{dapper_sqls-1.2.2.dist-info → dapper_sqls-1.2.4.dist-info}/RECORD

@@ -7,34 +7,34 @@ dapper_sqls/async_dapper/__init__.py,sha256=lBXRyXMCaiwgcK5TCw5rg-niwFS4GcZVW5Q2
 dapper_sqls/async_dapper/async_dapper.py,sha256=n9oDmgvRvB3TkuW3e-rcvy35VZfYespB9qn9qtCVa7s,2454
 dapper_sqls/async_dapper/async_executors.py,sha256=8P-tvoq45fuPrzwbESbwlmTvb0OjBAuEhhNj30AxzlY,17213
 dapper_sqls/builders/__init__.py,sha256=o_dGrHF09NOj3KFLpkpfaRzJMgYcddpQy-QTOJJTLPA,153
-dapper_sqls/builders/query.py,sha256=Qf2V4MSSrZsHsMoSjczrAga5gcRf6Vl-vhJxtcLGVBA,8345
-dapper_sqls/builders/stored.py,sha256=EHNRTLFYDVvqqWkmQggzJIbXfTKZN4Se8rbME7wLPHU,3131
+dapper_sqls/builders/query.py,sha256=HZvZk1bqL9cH29p8Csg5OAUsaJNWqYtg0CGJQ0VFynM,8935
+dapper_sqls/builders/stored.py,sha256=eRoQVvV9Np3mDiZh0M-mCpHg8Fm6yZa8ektf9X4Ii4E,3716
 dapper_sqls/builders/stp.py,sha256=LELylyG5tefcIk6kpsUTTuCkakRKTu93OwWCHB6mxU4,4915
 dapper_sqls/builders/model/__init__.py,sha256=9cAgoo-zu82YhtsmePseZhfeX94UMwfYuP9j-3d597Q,41
-dapper_sqls/builders/model/model.py,sha256=OULDuudqkj5oh1NlYzDJZwbQVDXh735LXhyCWiqpvWM,34668
-dapper_sqls/builders/model/utils.py,sha256=w-EBGxwltFFIw4jGvuQAvyCAnoDysqaPhfk86JLvCTs,27583
+dapper_sqls/builders/model/model.py,sha256=3Hq3wjpvCP6rzp-uSuHo2pbYpSjeQqXrEwvhb0UhJpM,34286
+dapper_sqls/builders/model/utils.py,sha256=PAT8HeQea-dIcJukFFlC2AFvRMWDPlo8DUZ4KDpy--I,27872
 dapper_sqls/dapper/__init__.py,sha256=AlQJ-QYMqKeerSQBM8Dc9_VQwUKCN4bl4ThKHsTlYms,38
 dapper_sqls/dapper/dapper.py,sha256=3sFRtgw_M3zZI8dyDJacVFwzAuH7jbyQehfCiYMymZs,2584
-dapper_sqls/dapper/executors.py,sha256=e6JZ2urLAMI3AyuxAquaQ9gficrtIxRswJnQS7pPTaM,16717
+dapper_sqls/dapper/executors.py,sha256=rcrkjF1lMXXdMaTFST1Hq3LNruXDxAVCMEe7JyvHDgU,16712
 dapper_sqls/http/__init__.py,sha256=-BkIvJqXqnzFIpsBlipLUj_Hvbx_qvFwDF_LekmXh7Y,91
 dapper_sqls/http/aiohttp.py,sha256=Z8ugmMI7YiowYwS3qArdmj_cq2neUo0cY3EY3n5CUos,6334
 dapper_sqls/http/decorators.py,sha256=zBWujQ8pbSYCl1CAvGJieXDu97fPN4hITRafTISajhU,3942
 dapper_sqls/http/models.py,sha256=dHWOZ_bo9EhRXFSIf1eHDe0zG6pY58_TWtif5Hr-xPg,1724
 dapper_sqls/http/request.py,sha256=dbiCv1gc3IbHolzZteF2dlVeVA8jdHnT_n-gqWqdjGQ,5690
 dapper_sqls/models/__init__.py,sha256=pRrgVBMx8_AHPBKr7Zv7a2Mr3gYJpVHl-lRXAKZ6cJE,496
-dapper_sqls/models/base.py,sha256=KmlbLa9_k0ioGDWVjISes4kIP8OgElAoCqXbr3VbSCE,8588
+dapper_sqls/models/base.py,sha256=26UC5erfkIKINZkqYeunZDgczdBibah71dqy94SUMyY,8976
 dapper_sqls/models/connection.py,sha256=z5OkYeY5Qp-dXdy1bvZHAlov-Kq-lgMxC6RqNdTiiq4,1745
 dapper_sqls/models/http.py,sha256=rCmf4Mj1bA_oc0k0vDxi2v1Cqd4oXDDU83P_6kNwTuA,356
-dapper_sqls/models/query_field.py,sha256=QOQlB6hlVm7fGZqsAFgWGznLEDSR03uTI_--xDyUEao,7763
-dapper_sqls/models/result.py,sha256=EsbgP7sY8QO5i-ddPwWH9mmRYGPLpQnwe89H1zWImqg,14728
+dapper_sqls/models/query_field.py,sha256=aJErQrRuXbvP21v_B6b3mwEeKm8Bgt7dBBS39Lnt3VE,7842
+dapper_sqls/models/result.py,sha256=lxC-Gic3jC8FdxTAhY6ABUqHwjcfqBbjzXVI0TLTYgk,15064
 dapper_sqls/sqlite/__init__.py,sha256=EUREulLqSlZ43_3pEYlDJ3rF7i0cSwROnqrlZX9ircI,247
 dapper_sqls/sqlite/async_local_database.py,sha256=VqMdAD2wdzqFMIKEpnOgbajEwwSmxLqtSkqWSipbu6o,7754
 dapper_sqls/sqlite/decorators.py,sha256=hvehaUi6uV3BkLNOcbGhv3-fV0VJD0hLomXznSSMJEA,2420
-dapper_sqls/sqlite/installer.py,sha256=nCDGRNUEvAEHx8Pw3izXx9miJJ3o5cjjPWA07nlqAD4,4781
+dapper_sqls/sqlite/installer.py,sha256=pHRXFn8gFPUj_d42ErKcMUDFmzc8tK1DabuhgqUIuSw,4901
 dapper_sqls/sqlite/local_database.py,sha256=kuEVRJvzUUQg3X1Abq9ZYslO9n5IMovaCj7jnB51qSs,5902
 dapper_sqls/sqlite/models.py,sha256=m1I0-iYDdv-4fVYMsAboRYHbMEcwI4GScZSdbs7_nUY,2232
 dapper_sqls/sqlite/utils.py,sha256=22n2ry7_7b7XGDjwv3sY8swADpXDAynR0-E8WQrvHzc,230
-dapper_sqls-1.2.2.dist-info/METADATA,sha256=2lH1re04pwj9ajjE1abq-J6MPUithv6VCHtERxwFcgU,964
-dapper_sqls-1.2.2.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-dapper_sqls-1.2.2.dist-info/top_level.txt,sha256=Pe1YqCPngnYbSVdhJyDrdFWHFCOqBvFW8WK7kTaIax4,12
-dapper_sqls-1.2.2.dist-info/RECORD,,
+dapper_sqls-1.2.4.dist-info/METADATA,sha256=Zt_7GVqTBlKNjswYV8J0tNNhFsgc3RSSKUA8TSAhEB4,989
+dapper_sqls-1.2.4.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+dapper_sqls-1.2.4.dist-info/top_level.txt,sha256=Pe1YqCPngnYbSVdhJyDrdFWHFCOqBvFW8WK7kTaIax4,12
+dapper_sqls-1.2.4.dist-info/RECORD,,