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

dapper_sqls/builders/stored.py

@@ -15,8 +15,15 @@ class StoredBuilder:
 
     @classmethod
     def update(cls, model: Type[BaseModel], where: Type[BaseModel]):
-        update_data = {k: int(v) if isinstance(v, bool) else v for k, v in model.model_dump(exclude_none=True).items()}
-        where_data = {k: int(v) if isinstance(v, bool) else v for k, v in where.model_dump(exclude_none=True).items()}
+        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()}
+
+        for key in where_data:
+            if key in update_data:
+                update_data.pop(key, None)
+       
         where_clause, where_params = cls._build_where_clause(**where_data)
 
         set_clause = ", ".join([f"{key} = ?" for key in update_data.keys()])
@@ -26,7 +33,8 @@ class StoredBuilder:
 
     @classmethod
     def insert(cls, model : Type[BaseModel], name_column_id = 'Id'):
-        insert_data = {k: int(v) if isinstance(v, bool) else v for k, v in model.model_dump(exclude_none=True).items()}
+        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()}
         columns = ", ".join(insert_data.keys())
         values = ", ".join(["?" for _ in insert_data.values()])
         sql_query = f"""
@@ -38,8 +46,9 @@ class StoredBuilder:
 
     @classmethod
     def select(cls, model : Type[BaseModel], 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(exclude_none=True).items()}
+        select_data = {k: int(v) if isinstance(v, bool) else v for k, v in model.model_dump(mode="json", exclude_none=True).items()}
         where_clause, parameters = cls._build_where_clause(**select_data)
 
         sql_query = f"SELECT {top_clause} FROM {model.TABLE_NAME}" 
@@ -50,7 +59,8 @@ class StoredBuilder:
 
     @classmethod
     def delete(cls, model : Type[BaseModel]):
-        delete_data = {k: int(v) if isinstance(v, bool) else v for k, v in model.model_dump(exclude_none=True).items()}
+        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()}
         where_clause, parameters = cls._build_where_clause(**delete_data)
         if not where_clause:
             raise ValueError("DELETE operation requires at least one condition.")

dapper_sqls/builders/stp.py

@@ -61,6 +61,7 @@ class StpBuilder(StpBaseBuilder):
         with self.dapper.stored(args.attempts, args.wait_timeout) as db:
             result = db.fetchone(self.query, self.params)
             if args.model:
+                args.model._reset_defaults()
                 return self.dapper.load(args.model, result)
             return result
 
@@ -78,7 +79,8 @@ class StpBuilder(StpBaseBuilder):
         with self.dapper.stored(args.attempts, args.wait_timeout) as db:
             result = db.fetchall(self.query, self.params)
             if args.model:
-                    return self.dapper.load(args.model, result)
+                args.model._reset_defaults()
+                return self.dapper.load(args.model, result)
             return result
 
 
@@ -110,6 +112,7 @@ class AsyncStpBuilder(StpBaseBuilder):
         async with await self.async_dapper.stored(args.attempts, args.wait_timeout) as db:
             result = await db.fetchone(self.query, self.params)
             if args.model:
+                args.model._reset_defaults()
                 return self.async_dapper.load(args.model, result)
             return result
 
@@ -127,7 +130,8 @@ class AsyncStpBuilder(StpBaseBuilder):
         async with await self.async_dapper.stored(args.attempts, args.wait_timeout) as db:
             result = await db.fetchall(self.query, self.params)
             if args.model:
-                    return self.async_dapper.load(args.model, result)
+                args.model._reset_defaults()
+                return self.async_dapper.load(args.model, result)
             return result
 
 

dapper_sqls/config.py

@@ -1,6 +1,7 @@
 # coding: utf-8
 from .models import ConnectionStringData
 import sys
+import subprocess
 
 class Config(object):
     def __init__(self, server: str, database: str, username: str, password: str, sql_version: int = None, api_environment=False, default_attempts=1, default_wait_timeout=2):
@@ -72,41 +73,49 @@ class Config(object):
 
     @staticmethod
     def get_all_odbc_driver_versions():
-        driver_versions = []
 
+        driver_versions = []
         # Verificar se o sistema é Windows e o módulo winreg está disponível
-        if sys.platform == "win32":
+        platform : str = sys.platform
+        if platform:
+             try:
+                 import winreg  # Importar o módulo winreg se estiver disponível
+
+                 # Abrir a chave onde as informações sobre os drivers ODBC estão armazenadas
+                 key_path = r"SOFTWARE\ODBC\ODBCINST.INI"
+                 key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, key_path)
+
+                 # Iterar sobre as subchaves para encontrar os drivers específicos
+                 i = 0
+                 while True:
+                     try:
+                         subkey_name = winreg.EnumKey(key, i)
+                         subkey = winreg.OpenKey(key, subkey_name)
+
+                         # Verificar se a subchave contém o valor 'Driver'
+                         try:
+                             driver_name, _ = winreg.QueryValueEx(subkey, "Driver")
+                             if subkey_name.startswith('ODBC Driver'):
+                                 driver_versions.append(subkey_name)
+
+                         except FileNotFoundError:
+                             pass  # A subchave não possui a entrada 'Driver'
+
+                         i += 1
+                     except OSError:
+                         break
+
+             except Exception as e:
+                 print(f"Erro ao acessar o registro: {e}")
+        else:
             try:
-                import winreg  # Importar o módulo winreg se estiver disponível
-
-                # Abrir a chave onde as informações sobre os drivers ODBC estão armazenadas
-                key_path = r"SOFTWARE\ODBC\ODBCINST.INI"
-                key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, key_path)
-
-                # Iterar sobre as subchaves para encontrar os drivers específicos
-                i = 0
-                while True:
-                    try:
-                        subkey_name = winreg.EnumKey(key, i)
-                        subkey = winreg.OpenKey(key, subkey_name)
-
-                        # Verificar se a subchave contém o valor 'Driver'
-                        try:
-                            driver_name, _ = winreg.QueryValueEx(subkey, "Driver")
-                            if subkey_name.startswith('ODBC Driver'):
-                                driver_versions.append(subkey_name)
-
-                        except FileNotFoundError:
-                            pass  # A subchave não possui a entrada 'Driver'
-
-                        i += 1
-                    except OSError:
-                        break
-
+                result = subprocess.run(['odbcinst', '-q', '-d'], stdout=subprocess.PIPE, text=True)
+                for line in result.stdout.splitlines():
+                    line = line.strip()
+                    if line.startswith("[ODBC Driver") and "SQL Server" in line:
+                        driver_versions.append(line.strip("[]"))
             except Exception as e:
-                print(f"Erro ao acessar o registro: {e}")
-        else:
-            print("A funcionalidade de obtenção de versões de drivers ODBC não é suportada neste sistema operacional.")
+                print(f"Erro ao detectar drivers ODBC no Linux: {e}")
 
         return sorted(driver_versions, key=lambda x: int(x.split()[-4]), reverse=True) if driver_versions else []
 

dapper_sqls/dapper/executors.py

@@ -4,9 +4,8 @@ from time import sleep
 from datetime import datetime
 from typing import overload
 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
 
@@ -14,6 +13,7 @@ class BaseExecutor(ABC, object):
     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_error : Exception = None
         self._connection = None
         self._wait_timeout = wait_timeout 
         self._attempts = attempts 
@@ -25,19 +25,19 @@ class BaseExecutor(ABC, object):
         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 = pyodbc.connect(connection_string)
                 self._cursor = 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')
                 sleep(self._wait_timeout)
 
         return self
@@ -81,7 +81,7 @@ class BaseExecutor(ABC, object):
         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):
@@ -92,7 +92,7 @@ class BaseExecutor(ABC, object):
         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
     def _exec_(self, connection, operation_sql, exec_type):
@@ -120,41 +120,79 @@ class Query(BaseExecutor):
     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
+    def count(self, query : str) -> Result.Count:
+        pass
+
+    @overload
+    def count(self, model : T, additional_sql : str = "", select_top : int = None) -> Result.Count:
+        pass
+
+    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 = 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
     def fetchone(self, query : str) -> Result.Fetchone:
         pass
 
     @overload
-    def fetchone(self, model : T, additional_sql : str = "") -> T:
+    def fetchone(self, model : T, additional_sql : str = "") -> Result.FetchoneModel[T]:
         pass
           
-    def fetchone(self, *args, **kwargs) -> T | Result.Fetchone:
+    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 = 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 
+    
+    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 = self._exec_(self._connection, query, ExecType.fetchone)
+        result._organize_joined_tables(joins)
+        return result
 
     @overload
     def fetchall(self, query : str) -> Result.Fetchall:
         pass
 
     @overload
-    def fetchall(self, model : T, additional_sql : str = "", select_top : int = None) -> list[T]:
+    def fetchall(self, model : T, additional_sql : str = "", select_top : int = None) -> Result.FetchallModel[T]:
         pass
 
-    def fetchall(self, *args, **kwargs) -> list[T] | Result.Fetchall:
+    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 = 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 
+    
+    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 = self._exec_(self._connection, query, ExecType.fetchall)
+        result._organize_joined_tables(joins)
+        return result
 
     def execute(self, query : str) -> Result.Send:
         return self._exec_(self._connection, query, ExecType.send)
@@ -174,21 +212,21 @@ class Query(BaseExecutor):
         query = QueryBuilder.insert(model, name_column_id)
         result : Result.Fetchone = 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)
         
-    def _exec_(self, connection, query_sql : str, exec_type : ExecType) -> Result.Send:
+    def _exec_(self, connection, query_sql : str, exec_type : ExecType):
 
         if not self._cursor:
             if self._api_environment:
                 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)
             
         try:
             # executar
@@ -196,23 +234,23 @@ class Query(BaseExecutor):
 
             # ober resultado se nessesario
             if exec_type == ExecType.fetchone:
-                result = Result.Fetchone(self._cursor, response.fetchone())
+                result = Result.Fetchone(query_sql, self._cursor, response.fetchone())
             elif exec_type == ExecType.fetchall:
-                result = Result.Fetchall(self._cursor, response.fetchall())
+                result = Result.Fetchall(query_sql, self._cursor, response.fetchall())
             elif exec_type == ExecType.send:
-                result = Result.Send(True)
+                result = Result.Send(query_sql, True)
 
             # fazer o commit 
             connection.commit()
 
         except Exception as ex:
             if exec_type == ExecType.fetchone:
-                return Result.Fetchone(None, None, 503, str(ex))
+                return Result.Fetchone(query_sql, None, None, ex)
             elif exec_type == ExecType.fetchall:
-                return Result.Fetchall(None, None, 503, str(ex))
+                return Result.Fetchall(query_sql, None, None, ex)
             elif exec_type == ExecType.send:
-                return Result.Send(False, 503, str(ex))
-
+                return Result.Send(query_sql, False, str(ex))
+        
         # retorna o resultado
         return result
 
@@ -229,6 +267,30 @@ class Stored(BaseExecutor):
     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
+    def count(self, query : str) -> Result.Count:
+        pass
+
+    @overload
+    def count(self, model : T, additional_sql : str = "", select_top : int = None) -> Result.Count:
+        pass
+
+    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 = 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
     def fetchone(self, query : str, params : list | tuple) -> Result.Fetchone:
         pass
@@ -238,17 +300,18 @@ class Stored(BaseExecutor):
         pass
 
     @overload
-    def fetchone(self, model : T, additional_sql : str = "") -> T:
+    def fetchone(self, model : T, additional_sql : str = "") -> Result.FetchoneModel[T]:
         pass
           
-    def fetchone(self, *args, **kwargs) -> T | Result.Fetchone:
+    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 = 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
@@ -260,17 +323,18 @@ class Stored(BaseExecutor):
         pass
 
     @overload
-    def fetchall(self, model : T, additional_sql : str = "", select_top : int = None) -> list[T]:
+    def fetchall(self, model : T, additional_sql : str = "", select_top : int = None) -> Result.FetchallModel[T]:
         pass
 
-    def fetchall(self, *args, **kwargs) -> list[T] | Result.Fetchall:
+    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 = 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
@@ -301,10 +365,11 @@ class Stored(BaseExecutor):
             name_column_id = next(iter(insert_data.keys())) 
 
         query, params = StoredBuilder.insert(model, name_column_id)
-        result = self._exec_(self._connection, (query,  *params), ExecType.fetchone)
+        stored_procedure = (query,  *params)
+        result = 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)
 
     def _exec_(self, connection , stored_procedure : tuple, exec_type : ExecType):
  
@@ -313,29 +378,39 @@ class Stored(BaseExecutor):
                 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(stored_procedure, None, None, self._connection_error)
+            elif exec_type == ExecType.send:
+                return Result.Send(stored_procedure, False, self._connection_error)
+            
+        try:
+            # executar
+            response = self._cursor.execute(*stored_procedure)
+
+            # ober resultado se nessesario
+            if exec_type == ExecType.fetchone:
+                result = Result.Fetchone(stored_procedure, self._cursor, response.fetchone())
             elif exec_type == ExecType.fetchall:
-                return Result.Fetchall(None, None, 503)
+                result = Result.Fetchall(stored_procedure, self._cursor, response.fetchall())
             elif exec_type == ExecType.send:
-                return Result.Send(False, 503)
-
-        # executar
-        response = self._cursor.execute(*stored_procedure)
-      
-        # ober resultado se nessesario
-        if exec_type == ExecType.fetchone:
-            result = Result.Fetchone(self._cursor, response.fetchone())
-        elif exec_type == ExecType.fetchall:
-            result = Result.Fetchall(self._cursor, response.fetchall())
-        elif exec_type == ExecType.send:
-            result = Result.Send(True)
-
-        # fazer o commit 
-        connection.commit()
+                result = Result.Send(stored_procedure, True)
+
+            # fazer o commit 
+            connection.commit()
 
+        except Exception as ex:
+            if exec_type == ExecType.fetchone:
+                return Result.Fetchone(stored_procedure, None, None, ex)
+            elif exec_type == ExecType.fetchall:
+                return Result.Fetchall(stored_procedure, None, None, ex)
+            elif exec_type == ExecType.send:
+                return Result.Send(stored_procedure, False, ex)
+        
         # retorna o resultado
         return result
 
+       
 
 
 

dapper_sqls/http/__init__.py

@@ -0,0 +1,4 @@
+from .aiohttp import AioHttp, HttpMethod, DataFetchHttp
+from .request import Request
+
+