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

dapper_sqls/builders/model/utils.py

@@ -1,24 +1,9 @@
 # coding: utf-8
 import re
-from pydantic import Field, BaseModel
+from pydantic import Field, BaseModel, model_validator
+from typing import Optional, List, Set, Any
+import json
 
-class InformationSchemaTables(BaseModel):
-    TABLE_CATALOG : str = Field(None, description="")
-    TABLE_SCHEMA : str = Field(None, description="")
-    TABLE_NAME : str = Field(None, description="")
-    COLUMN_NAME : str = Field(None, description="")
-    DATA_TYPE : str = Field(None, description="")
-    IS_NULLABLE : str = Field(None, description="")
-
-class InformationSchemaRoutines(BaseModel):
-    SPECIFIC_CATALOG : str = Field(None, description="")
-    SPECIFIC_SCHEMA : str = Field(None, description="")
-    SPECIFIC_NAME : str = Field(None, description="")
-    ORDINAL_POSITION : int = Field(None, description="")
-    PARAMETER_NAME : str = Field(None, description="")
-    DATA_TYPE : str = Field(None, description="")
-    PROCEDURE_DEFINITION : str = Field(None, description="")
-    
 type_mapping = {
         'int': 'int',
         'bigint': 'int',
@@ -44,22 +29,318 @@ type_mapping = {
         'rowversion': 'bytes',  
     }
 
-def create_field(data : InformationSchemaTables, field = 'Field(None, description="")'):
+QUERY_FIELD_TYPES = {
+    'str': 'StringQueryField',
+    'int': 'NumericQueryField',
+    'float': 'NumericQueryField',
+    'bool': 'BoolQueryField',
+    'datetime': 'DateQueryField',
+    'datetime.time': 'DateQueryField',
+    'bytes': 'BytesQueryField',  
+}
+
+JOIN_CONDITIONAL_FIELD_TYPES = {
+    'str': 'JoinStringCondition',
+    'int': 'JoinNumericCondition',
+    'float': 'JoinNumericCondition',
+    'bool': 'JoinBooleanCondition',
+    'datetime': 'JoinDateCondition',
+    'datetime.time': 'JoinDateCondition',
+    'bytes': 'JoinBytesCondition',  
+}
+
+class Relation(BaseModel):
+    original : bool = True
+    table : str 
+    column : str 
+
+class SqlTableAuth(BaseModel):
+    table : str = ""
+    column : str = ""
+
+class TableSettings(BaseModel):
+    insert : bool = False
+    update : bool = False
+    delete : bool = False
+    search : bool = True
+ 
+class ForeignKey(BaseModel):
+    ref_table: str = ""
+    ref_column: str = ""
+    on_delete: str = ""
+    on_update: str = ""
+
+class AutoColumnDescription(BaseModel):
+    nullable: Optional[bool] = None
+    type: Optional[str] = None
+    identity: Optional[bool] = None
+    default: Optional[Any] = None
+    primary_key: Optional[bool] = None
+    unique: Optional[bool] = None
+    foreign_key: Optional[ForeignKey] = None
+
+class ColumnInformation(BaseModel):
+    TABLE_CATALOG : str = Field("", description="")
+    TABLE_SCHEMA : str = Field("", description="")
+    TABLE_NAME : str = Field("", description="")
+    COLUMN_NAME : str = Field("", description="")
+    DATA_TYPE : str = Field("", description="")
+    IS_NULLABLE : str = Field("", description="")
+    IS_IDENTITY : str = Field("", description="")
+    IS_PRIMARY_KEY : str = Field("", description="")
+    IS_UNIQUE : str = Field("", description="")
+    CHARACTER_MAXIMUM_LENGTH : Optional[int] = Field(None, description="")
+    COLUMN_DESCRIPTION : Optional[str] = Field("", description="")
+    AUTO_COLUMN_DESCRIPTION : Optional[AutoColumnDescription] = None
+
+    column_authentication : str = Field("", description="")
+    relation : Optional[Relation] = None
+    available : bool = True
+
+    @model_validator(mode="before")
+    @classmethod
+    def parse_json_fields(cls, data):
+        if isinstance(data, dict):
+            # Se o campo vier como string JSON, converte para dict e depois para AutoColumnDescription
+            if isinstance(data.get("AUTO_COLUMN_DESCRIPTION"), str):
+                try:
+                    auto_col_dict = json.loads(data["AUTO_COLUMN_DESCRIPTION"])
+                    if not auto_col_dict['foreign_key']:
+                        auto_col_dict['foreign_key'] = None
+                    data["AUTO_COLUMN_DESCRIPTION"] = auto_col_dict
+                    description : AutoColumnDescription = AutoColumnDescription(**auto_col_dict)
+                    if description.foreign_key:
+                        data['relation'] = Relation(table=description.foreign_key.ref_table, column=description.foreign_key.ref_column)
+
+                except json.JSONDecodeError:
+                    data["AUTO_COLUMN_DESCRIPTION"] = None
+        
+        return data
+   
+class ForeignKey(BaseModel):
+    name: str
+    column: str
+    ref_table: str
+    ref_column: str
+    on_delete: str
+    on_update: str
+
+class UniqueConstraint(BaseModel):
+    name: str
+    columns: List[str]
+
+class PrimaryKey(BaseModel):
+    name: str
+    columns: List[str]
+
+class AutoTableDescription(BaseModel):
+    columns: int
+    identity: List[str]
+    primary_keys: Optional[PrimaryKey]
+    unique_constraints: List[UniqueConstraint]
+    foreign_keys: List[ForeignKey]
+   
+class TableInformation(BaseModel):
+    TABLE_CATALOG : str = Field("", description="")
+    TABLE_SCHEMA : str = Field("", description="")
+    TABLE_NAME : str = Field("", description="")
+    AUTO_TABLE_DESCRIPTION : AutoTableDescription = Field(..., description="")
+    TABLE_DESCRIPTION : Optional[str] = Field("", description="")
+    settings : TableSettings = TableSettings()
+    available : bool = True
+
+    @model_validator(mode="before")
+    @classmethod
+    def parse_json_fields(cls, data):
+        if isinstance(data, dict):
+            if isinstance(data.get("AUTO_TABLE_DESCRIPTION"), str):
+                data["AUTO_TABLE_DESCRIPTION"] = json.loads(data["AUTO_TABLE_DESCRIPTION"])
+        return data
+
+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="")
     
-    sql_data_type = data.DATA_TYPE.lower()  
-    python_type = type_mapping.get(sql_data_type)
-    if python_type is None:
-        python_type = 'str'
+def create_database_description(tables: List[TableInformation]) -> str:
+    lines = []
+    for table in tables:
+        auto = table.AUTO_TABLE_DESCRIPTION
+        lines.append(f"\n[Tabela: {table.TABLE_NAME}]")
+
+        # Chave primária
+        if auto.primary_keys:
+            pk_cols = ", ".join(auto.primary_keys.columns or [])
+            lines.append(f"- PK: {pk_cols}")
+
+        # Restrições únicas
+        if auto.unique_constraints:
+            for uc in auto.unique_constraints:
+                cols = ", ".join(uc.columns or [])
+                lines.append(f"- UNIQUE ({uc.name}): {cols}")
+
+        # Chaves estrangeiras
+        if auto.foreign_keys:
+            for fk in auto.foreign_keys:
+                lines.append(
+                    f"- FK: {fk.column} → {fk.ref_table}.{fk.ref_column} "
+                    f"[ON DELETE {fk.on_delete}, ON UPDATE {fk.on_update}]"
+                )
+
+        # Colunas identidade
+        if auto.identity:
+            identity_cols = ", ".join(auto.identity)
+            lines.append(f"- Identity: {identity_cols}")
+
+    return "\n".join(lines)
+
+def create_table_description(table_info: TableInformation) -> str:
+    parts = []
+
+    # Identity columns
+    identity = table_info.AUTO_TABLE_DESCRIPTION.identity or []
+    if identity:
+        identity_cols = ", ".join(identity)
+        parts.append(f"Identity columns: {identity_cols}")
+
+    # Primary key
+    pk = table_info.AUTO_TABLE_DESCRIPTION.primary_keys
+    if pk:
+        pk_cols = ", ".join(pk.columns or [])
+        parts.append(f"Primary key ({pk.name}: {pk_cols})" if pk_cols else f"Primary key ({pk.name})")
+
+    # Unique constraints
+    unique_list = table_info.AUTO_TABLE_DESCRIPTION.unique_constraints or []
+    for uc in unique_list:
+        cols = ", ".join(uc.columns or [])
+        parts.append(f"Unique constraint ({uc.name}: {cols})" if cols else f"Unique constraint ({uc.name})")
+
+    # Foreign keys
+    # for fk in table_info.AUTO_TABLE_DESCRIPTION.foreign_keys or []:
+    #     ref = f"{fk.ref_table}.{fk.ref_column}"
+    #     action = f"ON DELETE {fk.on_delete}, ON UPDATE {fk.on_update}"
+    #     parts.append(f"Foreign key ({fk.column} → {ref}) [{action}]")
+
+    # Final assembly
+    auto_summary = "; ".join(parts)
+
+    if table_info.TABLE_DESCRIPTION and table_info.TABLE_DESCRIPTION.strip():
+        return f"{table_info.TABLE_DESCRIPTION.strip()} — [{auto_summary}]"
+    else:
+        return f"[{auto_summary}]"
+    
+def create_column_description(column_desc: Optional[str], auto_desc: Optional[AutoColumnDescription]) -> str:
+    if auto_desc is None:
+        return column_desc or ""
+
+    parts = []
+
+    # Nullable
+    if auto_desc.nullable is False:
+        parts.append("Required")
+    elif auto_desc.nullable is True:
+        parts.append("Optional")
+
+    # Type
+    if auto_desc.type:
+        parts.append(f"Type: {auto_desc.type}")
+
+    # Identity (Auto Increment)
+    if auto_desc.identity:
+        parts.append("Identity (auto increment)")
+
+    # Default value
+    if auto_desc.default is not None and str(auto_desc.default).lower() != 'null':
+        parts.append(f"Default: {auto_desc.default}")
+
+    # Primary key
+    if auto_desc.primary_key:
+        parts.append("Primary key")
+
+    # Unique
+    if auto_desc.unique:
+        parts.append("Unique")
+
+    # Foreign key
+    # if auto_desc.foreign_key:
+    #     fk = auto_desc.foreign_key
+    #     details = []
+    #     if fk.ref_table and fk.ref_column:
+    #         details.append(f"{fk.ref_table}.{fk.ref_column}")
+    #     if fk.on_delete:
+    #         details.append(f"ON DELETE {fk.on_delete}")
+    #     if fk.on_update:
+    #         details.append(f"ON UPDATE {fk.on_update}")
+    #     fk_info = " | ".join(details) if details else "Foreign key"
+    #     parts.append(f"Foreign key → {fk_info}")
+
+    auto_summary = "; ".join(parts)
+
+    if column_desc:
+        return f"{column_desc.strip()} — [{auto_summary}]"
+    else:
+        return f"[{auto_summary}]"
 
-    if field == 'Field(None, description="")':
-        if data.IS_NULLABLE:
-            if python_type != 'str' and python_type != 'bool':
-                return f'{data.COLUMN_NAME} : Union[{python_type}, str, None] = {field}'
-            return f'{data.COLUMN_NAME} : Union[{python_type}, None] = {field}'
-        
-    if python_type != 'str' and python_type != 'bool':
-        return f'{data.COLUMN_NAME} :  Union[{python_type}, str] = {field}'
-    return f'{data.COLUMN_NAME} : {python_type} = {field}'
+def create_field(data: ColumnInformation, all_optional=True):
+    sql_data_type = data.DATA_TYPE.lower()
+    python_type = type_mapping.get(sql_data_type, 'str')
+
+    field_args = [
+        f'description="{create_column_description(data.COLUMN_DESCRIPTION, data.AUTO_COLUMN_DESCRIPTION)}"'
+    ]
+
+    # Define QueryField type adicional
+    query_field_type = QUERY_FIELD_TYPES.get(python_type)
+
+    join_conditional_field_type = JOIN_CONDITIONAL_FIELD_TYPES.get(python_type)
+
+    # Combina os tipos
+    if python_type in ['datetime', 'datetime.time']:
+        annotated_type = f'Union[{python_type}, str]'
+    else:
+        annotated_type = python_type
+
+    if query_field_type:
+        annotated_type = f'Union[{annotated_type}, {query_field_type}, {join_conditional_field_type}]'
+
+    if data.IS_NULLABLE == "YES" or all_optional:
+        annotated_type = f'Optional[{annotated_type}]'
+        field_def = f'Field(None, {", ".join(field_args)})' if field_args else 'Field(None)'
+    else:
+        field_def = f'Field(..., {", ".join(field_args)})' if field_args else 'Field(...)'
+
+    return f'{data.COLUMN_NAME}: {annotated_type} = {field_def}'
+
+def create_arg(
+    data: ColumnInformation,
+    default_type: str = None,
+    default_value: str = "None",
+    with_query_field: bool = False
+):
+    sql_data_type = data.DATA_TYPE.lower()
+    python_type = default_type or type_mapping.get(sql_data_type, 'str')
+
+    # Define o tipo base
+    if python_type in ['datetime', 'datetime.time']:
+        annotated_type = f'Union[{python_type}, str]'
+    else:
+        annotated_type = python_type
+
+    # Adiciona o QueryField, se for solicitado
+    if with_query_field:
+        query_field_type = QUERY_FIELD_TYPES.get(python_type)
+        join_conditional_field_type = JOIN_CONDITIONAL_FIELD_TYPES.get(python_type)
+        if query_field_type:
+            annotated_type = f'Union[{annotated_type}, {query_field_type}, {join_conditional_field_type}]'
+
+    return f'{data.COLUMN_NAME}: {annotated_type} = {default_value}'
 
 def get_parameters_with_defaults(stored_procedure):
     # Regular expression to capture parameters and their default values
@@ -100,6 +381,17 @@ def get_parameters_with_defaults(stored_procedure):
 
     return params_with_defaults
 
+def create_queue_update(fields_args_str : str):
+    return f'''def queue_update(self, *, {fields_args_str}):
+        super().queue_update(**locals())
+'''
+
+def create_set_ignored_fields(fields_args_str : str):
+    return f'''@classmethod
+    def set_ignored_fields(cls, *, {fields_args_str}):
+        super().set_ignored_fields(**locals())
+'''
+
 def create_params_routine(data : InformationSchemaRoutines, defaults_values : dict[str, str | int | None]):
     sql_data_type = data.DATA_TYPE.lower()  
     python_type = type_mapping.get(sql_data_type)
@@ -139,10 +431,13 @@ class BaseExecutorORM(BaseExecutor):
     def executor(self):
         return self._executor
 
-    def fetchone(self, additional_sql : str = "", *, {fields_args_str}) -> {class_name}:
+    def count(self, additional_sql : str = "", *, {fields_args_str}):
+        return self.executor.count(self, {class_name}(**get_dict_args(locals(), ['additional_sql'])), additional_sql)
+
+    def fetchone(self, additional_sql : str = "", *, {fields_args_str}) -> Result.FetchoneModel[{class_name}]:
         return self.executor.fetchone(self, {class_name}(**get_dict_args(locals(), ['additional_sql'])), additional_sql)
 
-    def fetchall(self, additional_sql : str = "", select_top : int = None, *, {fields_args_str}) -> list[{class_name}]:
+    def fetchall(self, additional_sql : str = "", select_top : int = None, *, {fields_args_str}) -> Result.FetchallModel[{class_name}]:
         return self.executor.fetchall(self, {class_name}(**get_dict_args(locals(), ['additional_sql', 'select_top'])), additional_sql, select_top)
 
     def delete(self, *, {fields_args_str}) -> Result.Send:
@@ -212,9 +507,6 @@ class {class_name}ORM(object):
     def __init__(self, dapper : Dapper):
           self._dapper = dapper
 
-    class {class_name}({class_name}):
-        ...
-
     @property
     def dapper(self):
         return self._dapper
@@ -289,10 +581,13 @@ class AsyncBaseExecutorORM(AsyncBaseExecutor):
     def executor(self):
         return self._executor
 
-    async def fetchone(self, additional_sql : str = "", *, {fields_args_str}) -> {class_name}:
+    async def count(self, additional_sql : str = "", *, {fields_args_str}):
+        return await self.executor.count(self, {class_name}(**get_dict_args(locals(), ['additional_sql'])), additional_sql)
+
+    async def fetchone(self, additional_sql : str = "", *, {fields_args_str}) -> Result.FetchoneModel[{class_name}]:
         return await self.executor.fetchone(self, {class_name}(**get_dict_args(locals(), ['additional_sql'])), additional_sql)
 
-    async def fetchall(self, additional_sql : str = "", select_top : int = None, *, {fields_args_str}) -> list[{class_name}]:
+    async def fetchall(self, additional_sql : str = "", select_top : int = None, *, {fields_args_str}) -> Result.FetchallModel[{class_name}]:
         return await self.executor.fetchall(self, {class_name}(**get_dict_args(locals(), ['additional_sql', 'select_top'])), additional_sql, select_top)
 
     async def delete(self, *, {fields_args_str}) -> Result.Send:
@@ -362,9 +657,6 @@ class Async{class_name}ORM(object):
     def __init__(self, async_dapper : AsyncDapper):
           self._async_dapper = async_dapper
 
-    class {class_name}({class_name}):
-        ...
-
     @property
     def async_dapper(self):
         return self._async_dapper

dapper_sqls/builders/query.py

@@ -1,55 +1,120 @@
 # coding: utf-8
-from typing import Type, Union
-from pydantic import BaseModel
+from typing import Union
 from datetime import datetime, date
-import json
-
-class Value:
-    def __init__(self, value : Union[str, int, bytes, float, datetime, date, bool], 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 = {k: int(v) if isinstance(v, bool) else v for k, v in model.model_dump(exclude_none=True).items()}
+    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 = {k: int(v) if isinstance(v, bool) else v for k, v in where.model_dump(exclude_none=True).items()} 
-            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 = {k: int(v) if isinstance(v, bool) else v for k, v in model.model_dump(exclude_none=True).items()}
+    @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 = {k: int(v) if isinstance(v, bool) else v for k, v in model.model_dump(exclude_none=True).items()}
-        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 = {k: int(v) if isinstance(v, bool) else v for k, v in model.model_dump(exclude_none=True).items()}
-        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}"