dapper-sqls 1.1.3__py3-none-any.whl → 1.2.0__py3-none-any.whl

dapper_sqls/__init__.py

@@ -1,6 +1,8 @@
 from .dapper import Dapper
 from .async_dapper import AsyncDapper
-from .models import TableBaseModel
+from .models import (TableBaseModel, SensitiveFields, StringQueryField, NumericQueryField, BoolQueryField, DateQueryField, BytesQueryField, 
+                    BaseJoinConditionField, JoinNumericCondition, JoinStringCondition, JoinBooleanCondition, JoinDateCondition, JoinBytesCondition)
+from ._types import SQL_NULL, SqlErrorType
 from .builders import ModelBuilder, StpBuilder, AsyncStpBuilder
 
 

dapper_sqls/_types.py

@@ -1,15 +1,38 @@
 from typing import TypeVar
 from enum import Enum
 
-
+SQL_NULL = "SQL_NULL"
 T = TypeVar('T')
 
 class ExecType(Enum):
+    count = "count"
     send = "send"
     fetchone = "fetchone"
     fetchall = "fetchall"
 
-
+class SqlErrorType(str, Enum):
+    UNIQUE_VIOLATION = "UniqueConstraintViolation"
+    FOREIGN_KEY_VIOLATION = "ForeignKeyViolation"
+    CHECK_CONSTRAINT_VIOLATION = "CheckConstraintViolation"
+    PERMISSION_DENIED = "PermissionDenied"
+    SYNTAX_ERROR = "SyntaxError"
+    TIMEOUT = "Timeout"
+    CONNECTION_ERROR = "SqlConnectionError"
+    UNKNOWN = "UnknownError"
+
+SQL_ERROR_HTTP_CODES = {
+    SqlErrorType.UNIQUE_VIOLATION: 409,             # Conflict
+    SqlErrorType.FOREIGN_KEY_VIOLATION: 409,        # Conflict
+    SqlErrorType.CHECK_CONSTRAINT_VIOLATION: 400,   # Bad Request
+    SqlErrorType.PERMISSION_DENIED: 403,            # Forbidden
+    SqlErrorType.SYNTAX_ERROR: 400,                 # Bad Request
+    SqlErrorType.TIMEOUT: 504,                      # Gateway Timeout
+    SqlErrorType.CONNECTION_ERROR: 503,             # Service Unavailable
+    SqlErrorType.UNKNOWN: 500                       # Internal Server Error
+}
+
+
+    
 
 
 

dapper_sqls/async_dapper/async_executors.py

@@ -3,17 +3,18 @@ import aioodbc, asyncio
 from typing import overload
 from datetime import datetime
 from abc import ABC, abstractmethod
-from ..models import ConnectionStringData, Result, UnavailableServiceException, BaseUpdate
+from ..models import ConnectionStringData, Result, UnavailableServiceException, BaseUpdate, SearchTable, JoinSearchTable
 from .._types import T, ExecType
-from ..config import Config
 from ..builders import QueryBuilder, StoredBuilder
 from ..utils import Utils
+import pyodbc
 
 class AsyncBaseExecutor(ABC):
     def __init__(self, connectionStringData : ConnectionStringData, attempts : int, wait_timeout : int, sql_version : int | None, api_environment : bool):
         self._connectionStringData = connectionStringData
         self._cursor = None
         self._connection = None
+        self._connection_error : Exception = None
         self._wait_timeout = wait_timeout 
         self._attempts = attempts 
         self._sql_version = sql_version
@@ -24,19 +25,19 @@ class AsyncBaseExecutor(ABC):
         for n in range(self._attempts):
             odbc_version = f'ODBC Driver {self._sql_version} for SQL Server' 
             if not self._sql_version:
-                all_driver_versions = Config.get_all_odbc_driver_versions()
-                if all_driver_versions:
-                    odbc_version = all_driver_versions[0]
-                else:
-                    raise RuntimeError("Nenhuma vers�o do driver ODBC for SQL Server foi encontrada.")
+                drivers = [d for d in pyodbc.drivers() if 'SQL Server' in d]
+                if not drivers:
+                    raise RuntimeError("Nenhum driver ODBC do SQL Server encontrado. Instale o ODBC Driver 17 ou 18.")
+                odbc_version = drivers[-1]
             try:
                 connection_string = f'DRIVER={{{odbc_version}}};SERVER={cs_data.server};DATABASE={cs_data.database};UID={cs_data.username};PWD={cs_data.password}'
                 self._connection = await aioodbc.connect(dsn=connection_string)
                 self._cursor = await self._connection.cursor()
 
             except Exception as e:
+                self._connection_error = e
                 print(e)
-                print(f'Erro na conex�o com a base de dados, nova tentativa em {self._wait_timeout}s')
+                print(f'Erro na conexão com a base de dados, nova tentativa em {self._wait_timeout}s')
                 await asyncio.sleep(self._wait_timeout)
 
         return self
@@ -80,7 +81,7 @@ class AsyncBaseExecutor(ABC):
         if isinstance(value, int):
             self._attempts = value
         else:
-            raise ValueError("O n�mero de tentativas deve ser um n�mero inteiro.")
+            raise ValueError("O número de tentativas deve ser um número inteiro.")
 
     @property
     def wait_timeout(self):
@@ -91,7 +92,7 @@ class AsyncBaseExecutor(ABC):
         if isinstance(value, int):
             self._wait_timeout = value
         else:
-            raise ValueError("O tempo de espera deve ser um n�mero inteiro.")
+            raise ValueError("O tempo de espera deve ser um número inteiro.")
 
     @abstractmethod
     async def _exec_(self, connection, operation_sql, exec_type):
@@ -119,22 +120,53 @@ class AsyncQuery(AsyncBaseExecutor):
     def __init__(self, connectionStringData : ConnectionStringData, attempts : int, wait_timeout : int, sql_version : int | None, api_environment : bool):
         super().__init__(connectionStringData, attempts, wait_timeout, sql_version, api_environment)
 
+    @overload
+    async def count(self, query : str) -> Result.Count:
+        pass
+
+    @overload
+    async def count(self, model : T, additional_sql : str = "", select_top : int = None) -> Result.Count:
+        pass
+
+    async def count(self, *args, **kwargs) -> T | Result.Count:
+        args = Utils.args_query(*args, **kwargs)
+        if args.model:
+            args.query = QueryBuilder.select(args.model, args.additional_sql, args.select_top)
+
+        count_query = f"""
+        SELECT COUNT(*) AS Count FROM (
+            {args.query}
+        ) AS count_subquery
+        """
+
+        result : Result.Fetchone = await self._exec_(self._connection, count_query, ExecType.fetchone)
+        if result.success:
+            return Result.Count(count_query, result.dict.get('Count', 0), result.status_code, result.error)
+        return Result.Count(count_query, 0, result.status_code, result.error)
+
     @overload
     async def fetchone(self, query : str) -> Result.Fetchone:
         pass
 
     @overload
-    async def fetchone(self, model : T, additional_sql : str = "") -> T:
+    async def fetchone(self, model : T, additional_sql : str = "") -> Result.FetchoneModel[T]:
         pass
           
-    async def fetchone(self, *args, **kwargs) -> T | Result.Fetchone:
+    async def fetchone(self, *args, **kwargs) -> Result.FetchoneModel[T] | Result.Fetchone:
         args = Utils.args_query(*args, **kwargs)
         if args.model:
             args.query = QueryBuilder.select(args.model, args.additional_sql, args.select_top)
         
         result = await self._exec_(self._connection, args.query, ExecType.fetchone)
         if args.model:
-            return args.model.__class__(**result.dict) if result.success else args.model.__class__()
+            model_instance = args.model.__class__(**result.dict) if result.success else args.model.__class__()
+            return Result.FetchoneModel(model_instance, result)
+        return result
+    
+    async def fetchone_with_joins(self, main_search: SearchTable, joins: list[JoinSearchTable] = [], additional_sql: str = "", select_top: int = None) -> Result.Fetchone:
+        query = QueryBuilder.select_with_joins(main_search, joins, additional_sql, select_top)
+        result = await self._exec_(self._connection, query, ExecType.fetchone)
+        result._organize_joined_tables(joins)
         return result
 
     @overload
@@ -142,17 +174,24 @@ class AsyncQuery(AsyncBaseExecutor):
         pass
 
     @overload
-    async def fetchall(self, model : T, additional_sql : str = "", select_top : int = None) -> list[T]:
+    async def fetchall(self, model : T, additional_sql : str = "", select_top : int = None) -> Result.FetchallModel[T]:
         pass
 
-    async def fetchall(self, *args, **kwargs) -> list[T] | Result.Fetchall:
+    async def fetchall(self, *args, **kwargs) -> Result.FetchallModel[T] | Result.Fetchall:
         args = Utils.args_query(*args, **kwargs)
         if args.model:
             args.query = QueryBuilder.select(args.model, args.additional_sql, args.select_top)
 
         result = await self._exec_(self._connection, args.query, ExecType.fetchall)
         if args.model:
-            return [args.model.__class__(**r) for r in result.list_dict] if result.success else []
+            models = [args.model.__class__(**r) for r in result.list_dict] if result.success else []
+            return Result.FetchallModel(models, result)
+        return result
+    
+    async def fetchall_with_joins(self, main_search: SearchTable, joins: list[JoinSearchTable] = [], additional_sql: str = "", select_top: int = None) -> Result.Fetchall:
+        query = QueryBuilder.select_with_joins(main_search, joins, additional_sql, select_top)
+        result = await self._exec_(self._connection, query, ExecType.fetchall)
+        result._organize_joined_tables(joins)
         return result
 
     async def execute(self, query : str) -> Result.Send:
@@ -173,8 +212,8 @@ class AsyncQuery(AsyncBaseExecutor):
         query = QueryBuilder.insert(model, name_column_id)
         result : Result.Fetchone = await self._exec_(self._connection, query, ExecType.fetchone)
         if result.success:
-            return Result.Insert(result.dict.get('Id', 0), result.status_code, result.message)
-        return Result.Insert(0, result.status_code, result.message)
+            return Result.Insert(query, result.dict.get('Id', 0), result.status_code, result.error)
+        return Result.Insert(query, 0, result.status_code, result.error)
     
     async def _exec_(self, connection, query_sql : str, exec_type : ExecType):
  
@@ -183,26 +222,35 @@ class AsyncQuery(AsyncBaseExecutor):
                 raise UnavailableServiceException()
 
             if exec_type == ExecType.fetchone:
-                return Result.Fetchone(None, None, 503)
+                return Result.Fetchone(query_sql, None, None, self._connection_error)
             elif exec_type == ExecType.fetchall:
-                return Result.Fetchall(None, None, 503)
+                return Result.Fetchall(query_sql, None, None, self._connection_error)
             elif exec_type == ExecType.send:
-                return Result.Send(False, 503)
+                return Result.Send(query_sql, False, self._connection_error)
 
-        # executar
-        response = await self._cursor.execute(query_sql)
+        try:
+            # executar
+            response = await self._cursor.execute(query_sql)
+
+            # ober resultado se nessesario
+            if exec_type == ExecType.fetchone:
+                result = Result.Fetchone(query_sql, self._cursor, await response.fetchone())
 
-        # ober resultado se nessesario
-        if exec_type == ExecType.fetchone:
-            result = Result.Fetchone(self._cursor, await response.fetchone())
+            elif exec_type == ExecType.fetchall:
+                result = Result.Fetchall(query_sql, self._cursor, await response.fetchall())
+            elif exec_type == ExecType.send:
+                result = Result.Send(query_sql, True)
 
-        elif exec_type == ExecType.fetchall:
-            result = Result.Fetchall(self._cursor, await response.fetchall())
-        elif exec_type == ExecType.send:
-            result = Result.Send(True)
+            # fazer o commit 
+            await connection.commit()
 
-        # fazer o commit 
-        await connection.commit()
+        except Exception as ex:
+            if exec_type == ExecType.fetchone:
+                return Result.Fetchone(query_sql, None, None, ex)
+            elif exec_type == ExecType.fetchall:
+                return Result.Fetchall(query_sql, None, None, ex)
+            elif exec_type == ExecType.send:
+                return Result.Send(query_sql, False, ex)
 
         # retorna o resultado
         return result
@@ -222,6 +270,30 @@ class AsyncStored(AsyncBaseExecutor):
     def __init__(self, connectionStringData : ConnectionStringData, attempts : int, wait_timeout : int,sql_version : int | None,  api_environment : bool):
         super().__init__(connectionStringData, attempts, wait_timeout, sql_version, api_environment)
 
+    @overload
+    async def count(self, query : str) -> Result.Count:
+        pass
+
+    @overload
+    async def count(self, model : T, additional_sql : str = "", select_top : int = None) -> Result.Count:
+        pass
+
+    async def count(self, *args, **kwargs) -> T | Result.Count:
+        args = Utils.args_query(*args, **kwargs)
+        if args.model:
+            args.query = StoredBuilder.select(args.model, args.additional_sql, args.select_top)
+
+        count_query = f"""
+        SELECT COUNT(*) AS Count FROM (
+            {args.query}
+        ) AS count_subquery
+        """
+
+        result : Result.Fetchone = await self._exec_(self._connection, count_query, ExecType.fetchone)
+        if result.success:
+            return Result.Count(count_query, result.dict.get('Count', 0), result.status_code, result.error)
+        return Result.Count(count_query, 0, result.status_code, result.error)
+
     @overload
     async def fetchone(self, query : str, params : list | tuple) -> Result.Fetchone:
         pass
@@ -231,17 +303,18 @@ class AsyncStored(AsyncBaseExecutor):
         pass
 
     @overload
-    async def fetchone(self, model : T, additional_sql : str = "") -> T:
+    async def fetchone(self, model : T, additional_sql : str = "") -> Result.FetchoneModel[T]:
         pass
 
-    async def fetchone(self, *args, **kwargs) -> T | Result.Fetchone:
+    async def fetchone(self, *args, **kwargs) -> Result.FetchoneModel[T] | Result.Fetchone:
         args = Utils.args_stored(*args, **kwargs)
         if args.model:
             args.query, args.params = StoredBuilder.select(args.model, args.additional_sql, args.select_top)
 
-        result = await self._exec_(self._connection, (args.query, *args.params), ExecType.fetchone)
+        result : Result.Fetchone = await self._exec_(self._connection, (args.query, *args.params), ExecType.fetchone)
         if args.model:
-            return args.model.__class__(**result.dict) if result.success else args.model.__class__()
+            model_instance = args.model.__class__(**result.dict) if result.success else args.model.__class__()
+            return Result.FetchoneModel(model_instance, result)
         return result
 
     @overload
@@ -253,17 +326,18 @@ class AsyncStored(AsyncBaseExecutor):
         pass
 
     @overload
-    async def fetchall(self, model : T, additional_sql : str = "", select_top : int = None) -> list[T]:
+    async def fetchall(self, model : T, additional_sql : str = "", select_top : int = None) -> Result.FetchallModel[T]:
         pass
 
-    async def fetchall(self, *args, **kwargs) -> list[T] | Result.Fetchall:
+    async def fetchall(self, *args, **kwargs) -> Result.FetchallModel[T] | Result.Fetchall:
         args = Utils.args_stored(*args, **kwargs)
         if args.model:
             args.query, args.params = StoredBuilder.select(args.model, args.additional_sql, args.select_top)
 
-        result = await self._exec_(self._connection, (args.query, *args.params), ExecType.fetchall)
+        result : Result.Fetchall = await self._exec_(self._connection, (args.query, *args.params), ExecType.fetchall)
         if args.model:
-            return [args.model.__class__(**r) for r in result.list_dict] if result.success else []
+            models = [args.model.__class__(**r) for r in result.list_dict] if result.success else []
+            return Result.FetchallModel(models, result)
         return result
 
     @overload
@@ -294,10 +368,11 @@ class AsyncStored(AsyncBaseExecutor):
             name_column_id = next(iter(insert_data.keys()))
 
         query, params = StoredBuilder.insert(model, name_column_id)
-        result : Result.Fetchone = await self._exec_(self._connection, (query,  *params), ExecType.fetchone)
+        stored_procedure = (query,  *params)
+        result : Result.Fetchone = await self._exec_(self._connection, stored_procedure, ExecType.fetchone)
         if result.success:
-            return Result.Insert(result.dict.get('Id', 0), result.status_code, result.message)
-        return Result.Insert(0, result.status_code, result.message)
+            return Result.Insert(stored_procedure, result.dict.get('Id', 0), result.status_code, result.error)
+        return Result.Insert(stored_procedure, 0, result.status_code, result.error)
     
     async def _exec_(self, connection , stored_procedure : tuple, exec_type : ExecType):
  
@@ -306,11 +381,11 @@ class AsyncStored(AsyncBaseExecutor):
                 raise UnavailableServiceException()
 
             if exec_type == ExecType.fetchone:
-                return Result.Fetchone(None, None, 503)
+                return Result.Fetchone(stored_procedure, None, None, self._connection_error)
             elif exec_type == ExecType.fetchall:
-                return Result.Fetchall(None, None, 503)
+                return Result.Fetchall(stored_procedure, None, None, self._connection_error)
             elif exec_type == ExecType.send:
-                return Result.Send(False, 503)
+                return Result.Send(stored_procedure, False, self._connection_error)
 
         try:
             # executar
@@ -318,22 +393,22 @@ class AsyncStored(AsyncBaseExecutor):
 
             # ober resultado se nessesario
             if exec_type == ExecType.fetchone:
-                result = Result.Fetchone(self._cursor, await response.fetchone())
+                result = Result.Fetchone(stored_procedure, self._cursor, await response.fetchone())
             elif exec_type == ExecType.fetchall:
-                result = Result.Fetchall(self._cursor, await response.fetchall())
+                result = Result.Fetchall(stored_procedure, self._cursor, await response.fetchall())
             elif exec_type == ExecType.send:
-                result = Result.Send(True)
+                result = Result.Send(stored_procedure, True)
 
             # fazer o commit 
             await connection.commit()
             
         except Exception as ex:
             if exec_type == ExecType.fetchone:
-                return Result.Fetchone(None, None, 503, str(ex))
+                return Result.Fetchone(stored_procedure, None, None, ex)
             elif exec_type == ExecType.fetchall:
-                return Result.Fetchall(None, None, 503, str(ex))
+                return Result.Fetchall(stored_procedure, None, None, ex)
             elif exec_type == ExecType.send:
-                return Result.Send(False, 503, str(ex))
+                return Result.Send(stored_procedure, False, ex)
 
         # retorna o resultado
         return result