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

dapper_sqls/builders/query.py

@@ -1,55 +1,120 @@
-# -*- coding: latin -*-
-from typing import Type, Union
-from pydantic import BaseModel
+# coding: utf-8
+from typing import Union
 from datetime import datetime, date
-import json
-
-class Value:
-    def __init__(self, value : Union[str, int, bytes, float, datetime, date], prefix : str, suffix : str):
-        self.value = value
-        self.prefix = prefix
-        self.suffix = suffix
+from ..models import TableBaseModel, QueryFieldBase, BaseJoinConditionField, SearchTable, JoinSearchTable
 
 class QueryBuilder(object):
 
-    def value(value : Union[str, int, bytes, float, datetime, date], prefix = "=", suffix = ""):
-        json_value = json.dumps({'prefix': prefix, 'value': value, 'suffix': suffix})
-        return f"#QueryBuilderValue#{json_value}#QueryBuilderValue#"
-
     @classmethod
-    def _build_where_clause(cls, **kwargs):
-        conditions = []
-        for field, value in kwargs.items():
-            if value is not None:
-                if isinstance(value, str):
-                    if '#QueryBuilderValue#' in value:
-                        value = value.replace('#QueryBuilderValue#', '')
-                        value = Value(**json.loads(value.strip()))
-                        if isinstance(value.value, str):
-                            conditions.append(f"{field} {value.prefix} '{value.value}' {value.suffix}")
-                        else:
-                            conditions.append(f"{field} {value.prefix} {value.value} {value.suffix}")
-                    else:
-                        conditions.append(f"{field} = '{value}'")
+    def build_where_clause(cls, model: TableBaseModel, table_alias: str = "", base_table_alias : str = "") -> str:
+        clause_parts = []
+
+        for field_name, field_value in model:
+            
+            if field_value is None:
+                continue
+
+            # Constrói o nome qualificado com alias, se houver
+            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)
+
+            elif isinstance(field_value, QueryFieldBase):
+                sql = field_value.to_sql(qualified_field)
+                if sql:
+                    clause_parts.append(sql)
+
+            else:
+                if isinstance(field_value, str):
+                    escaped_value = field_value.replace("'", "''")
+                    clause_parts.append(f"{qualified_field} = '{escaped_value}'")
+                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]}'")
+                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}")
                 else:
-                    conditions.append(f"{field} = {value}")
-        return " AND ".join(conditions)
+                    clause_parts.append(f"{qualified_field} = {field_value}")
+
+        return " AND ".join(clause_parts)
+    
+    @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):
+            return f"'{value.strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]}'"
+        elif isinstance(value, date):
+            return f"'{value.strftime('%Y-%m-%d')}'"
+        elif isinstance(value, bytes):
+            return f"0x{value.hex()}"
+        elif value is None:
+            return "NULL"
+        else:
+            return str(value)
+    
+    @staticmethod
+    def build_select_fields(search_table: SearchTable, table_alias: str, rename_fields: bool = True) -> str:
+        model_fields = search_table.model.model_fields.keys()
+
+        if not rename_fields:
+            # Se include estiver presente, listar colunas com alias normal
+            if search_table.include:
+                fields = [f"{table_alias}.{f}" for f in search_table.include]
+            else:
+                # Nenhuma regra definida, usar '*'
+                return f"{table_alias}.*"
+            return ", ".join(fields)
+
+        # Caso rename_fields=True
+        if search_table.include:
+            fields = search_table.include
+        else:
+            fields = list(model_fields)
+
+        select_parts = [
+            f"{table_alias}.{field} AS {table_alias}{field}" for field in fields
+        ]
+        return ", ".join(select_parts)
 
     @classmethod
-    def update(cls, model: Type[BaseModel], where : Union[str , Type[BaseModel]]):
-        update_data = model.model_dump(exclude_none=True)
+    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()}
         if not isinstance(where, str):
-            where_data = where.model_dump(exclude_none=True)
-            where = cls._build_where_clause(**where_data)
+            where._reset_defaults()
+            for key in where.model_dump(mode="json", exclude_none=True):
+                if key in update_data:
+                    update_data.pop(key, None)
+            where = cls.build_where_clause(where)
 
-        set_clause = ", ".join([f"{key} = '{value}'" if isinstance(value, str) else f"{key} = {value}" for key, value in update_data.items()])
+        set_clause = ", ".join(
+            f"{key} = {cls.format_sql_value(value)}"
+            for key, value in update_data.items()
+        )
         sql_query = f"UPDATE {model.TABLE_NAME} SET {set_clause} WHERE {where}"
         return sql_query
 
-    def insert(model: Type[BaseModel], name_column_id = 'Id'):
-        insert_data = model.model_dump(exclude_none=True)
+    @classmethod
+    def insert(cls, model: 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()
+        }
         columns = ", ".join(insert_data.keys())
-        values = ", ".join([f"'{value}'" if isinstance(value, str) else str(value) for value in insert_data.values()])
+        values = ", ".join(cls.format_sql_value(v) for v in insert_data.values())
         sql_query = f"""
             INSERT INTO {model.TABLE_NAME} ({columns})
             OUTPUT INSERTED.{name_column_id} AS Id
@@ -58,21 +123,77 @@ class QueryBuilder(object):
         return sql_query
 
     @classmethod
-    def select(cls, model: Type[BaseModel], additional_sql : str = "" ,select_top : int= None):
+    def select(cls, model: TableBaseModel, additional_sql : str = "" ,select_top : int= None):
+        model._reset_defaults()
         top_clause = f"TOP ({select_top}) * " if select_top else "*"
-        select_data = model.model_dump(exclude_none=True)
-        where_clause = cls._build_where_clause(**select_data)
+        where_clause = cls.build_where_clause(model)
 
         sql_query = f"SELECT {top_clause} FROM {model.TABLE_NAME}"
         if where_clause:
             sql_query += f" WHERE {where_clause}"
         sql_query = f'{sql_query} {additional_sql}'
         return sql_query
+    
+    @staticmethod
+    def build_on_clause(join_model: TableBaseModel, join_alias: str, base_alias: str) -> str:
+        clause_parts = []
+        for field_name, field_value in join_model:
+            if isinstance(field_value, BaseJoinConditionField):
+                sql = field_value.to_sql(base_alias, f"{join_alias}.{field_name}")
+                if sql:
+                    clause_parts.append(sql)
+        return " AND ".join(clause_parts)
+    
+    @classmethod
+    def select_with_joins(cls, main_search: SearchTable, joins: list[JoinSearchTable] = [], additional_sql: str = "", select_top: int = None) -> str:
+        main_model = main_search.model
+        main_model._reset_defaults()
+        main_table = main_model.TABLE_NAME
+        main_table_alias = main_model.TABLE_ALIAS
+        top_clause = f"TOP ({select_top})" if select_top else ""
+
+        # Campos SELECT da tabela principal
+        select_fields = cls.build_select_fields(main_search, main_table_alias, False)
+
+        # JOINs
+        join_clauses = []
+        for join_search in joins:
+            join_model = join_search.model
+            join_model._reset_defaults()
+            join_table = join_model.TABLE_NAME
+            join_table_alias = join_model.TABLE_ALIAS
+
+            join_type = join_search.join_type.upper()
+            on_conditions = cls.build_on_clause(join_model, join_table_alias, main_table_alias)
 
+            # Usa o alias no JOIN
+            join_clause = (
+                f"{join_type} JOIN {join_table} AS {join_table_alias} "
+                f"ON {on_conditions}"
+            )
+            join_clauses.append(join_clause)
+
+            # Campos SELECT do JOIN
+            select_fields += ", " + cls.build_select_fields(join_search, join_table_alias)
+
+        # WHERE principal
+        where_clause = cls.build_where_clause(main_model, main_table_alias)
+        where_part = f"WHERE {where_clause}" if where_clause else ""
+
+        # SQL final
+        sql_query = (
+            f"SELECT {top_clause} {select_fields} "
+            f"FROM {main_table} AS {main_table_alias} "
+            + " ".join(join_clauses)
+            + f" {where_part} {additional_sql}"
+        ).strip()
+
+        return sql_query
+    
     @classmethod
-    def delete(cls, model: Type[BaseModel]):
-        delete_data = model.model_dump(exclude_none=True)
-        where_clause = cls._build_where_clause(**delete_data)
+    def delete(cls, model: TableBaseModel):
+        model._reset_defaults()
+        where_clause = cls.build_where_clause(model)
         if not where_clause:
             raise ValueError("DELETE operation requires at least one condition.")
         sql_query = f"DELETE FROM {model.TABLE_NAME} WHERE {where_clause}"

dapper_sqls/builders/stored.py

@@ -1,4 +1,4 @@
-# -*- coding: latin -*-
+# coding: utf-8
 from typing import Type
 from pydantic import BaseModel
 
@@ -9,18 +9,21 @@ class StoredBuilder:
         parameters = []
         for field, value in kwargs.items():
             if value is not None:
-                if isinstance(value, str):
-                    conditions.append(f"{field} = ?")
-                    parameters.append(value)
-                else:
                     conditions.append(f"{field} = ?")
                     parameters.append(value)
         return " AND ".join(conditions), tuple(parameters)
 
     @classmethod
     def update(cls, model: Type[BaseModel], where: Type[BaseModel]):
-        update_data = model.model_dump(exclude_none=True)
-        where_data = where.model_dump(exclude_none=True)
+        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()])
@@ -30,7 +33,8 @@ class StoredBuilder:
 
     @classmethod
     def insert(cls, model : Type[BaseModel], name_column_id = 'Id'):
-        insert_data = model.model_dump(exclude_none=True)
+        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"""
@@ -42,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 = model.model_dump(exclude_none=True)
+        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}" 
@@ -54,7 +59,8 @@ class StoredBuilder:
 
     @classmethod
     def delete(cls, model : Type[BaseModel]):
-        delete_data = model.model_dump(exclude_none=True)
+        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: latin -*-
+# 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/dapper.py

@@ -1,4 +1,4 @@
-# -*- coding: latin -*-
+# coding: utf-8
 from .._types import  T
 from ..config import Config
 from ..models import Result