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

dapper_sqls/builders/model/utils.py

@@ -1,24 +1,9 @@
-# -*- coding: latin -*-
+# 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)
@@ -118,7 +410,7 @@ def create_params_routine(data : InformationSchemaRoutines, defaults_values : di
 
 def create_content_orm(class_name : str, fields_args_str : str):
 
-    return f'''# -*- coding: latin -*-
+    return f'''# coding: utf-8
 
 from datetime import datetime
 from typing import overload, Union
@@ -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
@@ -268,7 +560,7 @@ class {class_name}ORM(object):
 
 def create_content_async_orm(class_name : str, fields_args_str : str):
 
-    return f'''# -*- coding: latin -*-
+    return f'''# coding: utf-8
 
 from datetime import datetime
 from typing import overload, Union
@@ -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