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

dapper_sqls/models/base.py

@@ -1,35 +1,261 @@
-from pydantic import BaseModel, BaseConfig
-from abc import ABC
+from pydantic import BaseModel, ConfigDict, PrivateAttr, Field, create_model
 from abc import ABC, abstractmethod
-from .result import Result
+from typing import Set, Any, ClassVar, get_origin, get_args, Union, Optional, Literal, get_type_hints, List
+from ..utils import get_dict_args
+from dataclasses import asdict
+import copy
+import datetime
+
+QUERY_FIELD_TYPES = {
+    'StringQueryField',
+    'NumericQueryField',
+    'BoolQueryField',
+    'DateQueryField',
+    'BytesQueryField',
+    'JoinStringCondition',
+    'JoinNumericCondition',
+    'JoinBooleanCondition',
+    'JoinDateCondition',
+    'JoinBytesCondition',  
+}
+
+def convert_datetime_date_to_str(annotation):
+    """Convert datetime/date or their unions with str to just str."""
+    if annotation in (datetime.datetime, datetime.date):
+        return str
+    origin_inner = get_origin(annotation)
+    args_inner = get_args(annotation)
+    if origin_inner is Union:
+        set_args = set(args_inner)
+        if str in set_args and (datetime.datetime in set_args or datetime.date in set_args):
+            return str
+    return annotation
+
+def remove_query_field_types(annotation):
+    """
+    Remove os tipos de QueryField (como StringQueryField) de uma Union ou substitui diretamente
+    """
+    origin = get_origin(annotation)
+    args = get_args(annotation)
+
+    def is_query_field(arg):
+        return getattr(arg, '__name__', '') in QUERY_FIELD_TYPES
+
+    if origin is Union:
+        new_args = tuple(arg for arg in args if not is_query_field(arg))
+        if len(new_args) == 1:
+            return new_args[0]
+        return Union[new_args]
+    elif is_query_field(annotation):
+        return str  # fallback para str caso algum passe isolado
+    return annotation
+
+def is_optional(annotation):
+    """Check if an annotation is Optional[...] or Union[..., None]."""
+    origin = get_origin(annotation)
+    args = get_args(annotation)
+    return origin is Union and type(None) in args
+
+def remove_optional(annotation):
+    """Remove NoneType from Union[...]"""
+    args = tuple(arg for arg in get_args(annotation) if arg is not type(None))
+    if len(args) == 1:
+        return args[0]
+    return Union[args]
+
+def make_optional(annotation):
+    """Make an annotation optional if not already."""
+    if is_optional(annotation):
+        return annotation
+    return Optional[annotation]
+
+class SensitiveFields(object):
+
+    _sensitive_fields : Set[str] = set()
+
+    @classmethod
+    def set(cls, new_sensitive_filds : Set[str]):
+        cls._sensitive_fields = new_sensitive_filds
+
+    @classmethod
+    def get(cls):
+        return cls._sensitive_fields
+    
 
 class TableBaseModel(BaseModel, ABC): 
-    class Config(BaseConfig):
+    class Config(ConfigDict):
         from_attributes = True
 
-    _TABLE_NAME: str = ''
+    TABLE_NAME: ClassVar[str] 
 
-    @property
-    def TABLE_NAME(cls) -> str:
-        return cls._TABLE_NAME
+    TABLE_ALIAS: ClassVar[str] 
+
+    DESCRIPTION : ClassVar[str] 
+    
+    IDENTITIES : ClassVar[Set[str]]
+
+    PRIMARY_KEYs : ClassVar[Set[str]]
+
+    OPTIONAL_FIELDS : ClassVar[Set[str]]
+
+    MAX_LENGTH_FIELDS: ClassVar[dict[str, int]] = {}
+
+    _explicit_fields:  Set[str] = PrivateAttr(default_factory=set)
+    _pending_updates: dict[str, Any] = PrivateAttr(default_factory=dict)
+    _initial_values: dict[str, Any] = PrivateAttr(default_factory=dict)
+   
+
+    def __init__(self, **data):
+        sensitive = SensitiveFields.get()
+        filtered_data = {k: v for k, v in data.items() if k not in sensitive}
+        
+        super().__init__(**filtered_data)
+        self._explicit_fields = set(filtered_data.keys())
+        self._initial_values = copy.deepcopy(self.model_dump())
+    
+    def _reset_defaults(self):
+        for field_name, model_field in self.model_fields.items():
+            if field_name not in self._explicit_fields:
+                setattr(self, field_name, None)
+
+    def reset_to_initial_values(self):
+        for key, value in self._initial_values.items():
+            setattr(self, key, copy.deepcopy(value))
+        self.clear_updates()
+
+    def equals(self, other: "TableBaseModel") -> bool:
+        return self.model_dump() == other.model_dump()
+
+    def clear_updates(self):
+        self._pending_updates.clear()
 
+    def has_updates(self) -> bool:
+        for key, new_value in self._pending_updates.items():
+            if key in self.model_fields:
+                current_value = getattr(self, key, None)
+
+            if isinstance(current_value, BaseModel) and isinstance(new_value, BaseModel):
+                if current_value.model_dump() != new_value.model_dump():
+                    return True
+                
+            elif hasattr(current_value, "__dataclass_fields__") and hasattr(new_value, "__dataclass_fields__"):
+                if asdict(current_value) != asdict(new_value):
+                    return True
+
+            elif hasattr(current_value, "__dict__") and hasattr(new_value, "__dict__"):
+                if vars(current_value) != vars(new_value):
+                    return True
+
+            elif new_value != current_value:
+                return True
+        return False
+
+    @staticmethod
+    def queue_update(self : 'TableBaseModel', **fields):
+        fields = get_dict_args(fields)
+        for key, value in fields.items():
+            if value != None and key in self.model_fields:
+                self._pending_updates[key] = value
+
+    def apply_updates(self):
+        for key, value in self._pending_updates.items():
+            if key in self.model_fields:
+                setattr(self, key, value)
+        self.clear_updates()
+
+    def alter_model_class(self, remove_fields: tuple[str] = (), mode: Literal['all_optional', 'all_required', 'original'] = 'all_optional', query_field = False):
+        fields = {}
+        
+        for field_name, field in self.model_fields.items():
+            if field_name in remove_fields:
+                continue
+
+            ann = convert_datetime_date_to_str(field.annotation)
+            if not query_field:
+                ann = remove_query_field_types(ann)
+
+            max_length = None
+            if mode in ('all_required', 'original'):
+                max_length = self.MAX_LENGTH_FIELDS.get(field_name)
+                if isinstance(max_length, int) and max_length < 1:
+                    max_length = None
+
+            default = field.default
+
+            if mode == 'all_optional':
+                ann = make_optional(ann)
+                default = None
+
+            elif mode == 'all_required':
+                if is_optional(ann):
+                    ann = remove_optional(ann)
+                default = ...
+
+            elif mode == 'original':
+                if field_name in self.OPTIONAL_FIELDS:
+                    ann = make_optional(ann)
+                    default = None
+                else:
+                    if is_optional(ann):
+                        ann = remove_optional(ann)
+                    default = ...
+
+            fields[field_name] = (ann, Field(default=default, description=field.description, max_length=max_length))
+
+        new_model_class = create_model(
+            self.__name__,
+            __config__=ConfigDict(extra='forbid'),
+            **fields
+        )
+        return new_model_class
+    
+    @classmethod
+    def get_field_type_names(cls) -> dict[str, set[str]]:
+        result = {}
+        type_hints = get_type_hints(cls, include_extras=True)
+
+        for field_name, hint in type_hints.items():
+            if field_name.startswith('_') or get_origin(hint) is ClassVar:
+                continue
+
+            args = get_args(hint)
+            if not args:
+                args = (hint,)
+
+            types = {
+                t.__name__ if hasattr(t, '__name__') else t._name if hasattr(t, '_name') else str(t)
+                for t in args
+                if t is not type(None)  
+            }
+
+            result[field_name] = types
+
+        return result
+    
+class SearchTable(BaseModel):
+    model: TableBaseModel
+    include: Optional[List[str]] = Field(default_factory=list)
+ 
+class JoinSearchTable(SearchTable):
+    join_type: Literal["INNER", "LEFT", "RIGHT", "FULL"] = "LEFT"
+    
 class BaseUpdate(ABC):
 
-        def __init__(self, executor , model):
-            self._set_data = model
-            self._executor = executor
+    def __init__(self, executor , model):
+        self._set_data = model
+        self._executor = executor
 
-        @property
-        def set_data(self):
-            return self._set_data
+    @property
+    def set_data(self):
+        return self._set_data
 
-        @property
-        def executor(self):
-            return self._executor
+    @property
+    def executor(self):
+        return self._executor
 
-        @abstractmethod
-        def where(self, *args)  -> Result.Send:
-            pass
+    @abstractmethod
+    def where(self, *args):
+        pass
 
 
 

dapper_sqls/models/connection.py

@@ -34,7 +34,7 @@ class ConnectionStringData(object):
     @username.setter
     def username(self, value: str):
         if not isinstance(value, str):
-            raise ValueError("O nome de usu�rio deve ser uma string.")
+            raise ValueError("O nome de usuário deve ser uma string.")
         self._username = value
 
     @property

dapper_sqls/models/query_field.py

@@ -0,0 +1,214 @@
+from typing import Union, List, Literal, Any, Optional
+from pydantic import BaseModel, Field, create_model
+from datetime import datetime, date
+from abc import ABC, abstractmethod
+
+class QueryFieldBase(BaseModel, ABC):
+
+    class Config:
+        extra = "forbid"
+
+    prefix: Optional[str] = Field(
+        default=..., 
+        description="Optional prefix to be prepended to the SQL condition (e.g., for parentheses or NOT)"
+    )
+    suffix: Optional[str] = Field(
+        default=..., 
+        description="Optional suffix to be appended to the SQL condition (e.g., for closing parentheses)"
+    )
+    
+    def quote(self, val):
+        if isinstance(val, str):
+            val = val.replace("'", "''")
+            return f"'{val}'"
+        elif isinstance(val, bool):
+            return '1' if val else '0'
+        elif isinstance(val, datetime):
+            return f"'{val.strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]}'"
+        elif isinstance(val, date):
+            return f"'{val.strftime('%Y-%m-%d')}'"
+        return str(val)
+
+    def format_sql(self, field_name: str, value_expr: str, operator: str) -> str:
+        prefix = self.prefix if isinstance(self.prefix, str) else ""
+        suffix = self.suffix if isinstance(self.suffix, str) else ""
+        return f"{prefix}{field_name} {operator} {value_expr}{suffix}"
+    
+    @abstractmethod
+    def to_sql(self, field_name: str):
+        ...
+    
+
+class StringQueryField(QueryFieldBase):
+    value: Union[str, List[str]] = Field(
+        default=...,
+        description="The value or list of values to compare against the string column"
+    )
+    operator: Literal['=', '!=', 'LIKE', 'IN', 'NOT IN'] = Field(
+        default=...,
+        description="SQL operator used for comparison"
+    )
+
+    case_insensitive: bool = Field(
+        default=..., 
+        description="Whether to apply case-insensitive matching (uses UPPER() on field and value)"
+    )
+
+    def apply_like_pattern(self, v: str) -> str:
+        if self.operator == 'LIKE':
+            return f"%{v}%"
+        return v
+
+    def to_sql(self, field_name: str) -> str:
+        field_expr = f"UPPER({field_name})" if self.case_insensitive else field_name
+
+        if isinstance(self.value, list):
+            values = [self.apply_like_pattern(v) for v in self.value]
+            values = [v.upper() if self.case_insensitive else v for v in values]
+            value_expr = "(" + ", ".join(self.quote(v) for v in values) + ")"
+        else:
+            val = self.apply_like_pattern(self.value)
+            val = val.upper() if self.case_insensitive else val
+            value_expr = self.quote(val)
+
+        return self.format_sql(field_expr, value_expr, self.operator)
+    
+class NumericQueryField(QueryFieldBase):
+    value: Union[int, float, List[Union[int, float]]] = Field(
+        default=...,
+        description="The numeric value or list of values to compare against the column"
+    )
+    operator: Literal['=', '!=', '>', '<', '>=', '<=', 'IN', 'NOT IN'] = Field(
+        default=...,
+        description="SQL operator used for numeric comparison"
+    )
+
+    def to_sql(self, field_name: str) -> str:
+        if isinstance(self.value, list):
+            value_expr = "(" + ", ".join(str(v) for v in self.value) + ")"
+        else:
+            value_expr = str(self.value)
+
+        return self.format_sql(field_name, value_expr, self.operator)
+    
+class BoolQueryField(QueryFieldBase):
+    value: bool = Field(
+        default=...,
+        description="Boolean value to compare against the column"
+    )
+    operator: Literal['=', '!='] = Field(
+        default=...,
+        description="SQL operator used for boolean comparison"
+    )
+
+    def to_sql(self, field_name: str) -> str:
+        value_expr = '1' if self.value else '0'
+        return self.format_sql(field_name, value_expr, self.operator)
+    
+
+class DateQueryField(QueryFieldBase):
+    value:Union[str, datetime, date] = Field(
+        default=...,
+        description="Date or datetime value to compare (can also be a string in ISO format)"
+    )
+    operator: Literal['=', '!=', '>', '<', '>=', '<='] = Field(
+        default=...,
+        description="SQL operator used for date/time comparison"
+    )
+
+    def to_sql(self, field_name: str) -> str:
+        if isinstance(self.value, str):
+            value_expr = f"'{self.value}'"
+        else:
+            value_expr = self.quote(self.value)
+        return self.format_sql(field_name, value_expr, self.operator)
+    
+
+class BytesQueryField(QueryFieldBase):
+    value: Union[bytes, List[bytes]] = Field(
+        default=...,
+        description="The bytes value or list of byte values to compare against the column"
+    )
+    operator: Literal['=', '!=', 'IN', 'NOT IN'] = Field(
+        default=...,
+        description="SQL operator used for byte comparison"
+    )
+
+    def to_sql(self, field_name: str) -> str:
+        def format_byte(b: bytes) -> str:
+            return "0x" + b.hex()  # SQL Server format
+
+        if isinstance(self.value, list):
+            value_expr = "(" + ", ".join(format_byte(v) for v in self.value) + ")"
+        else:
+            value_expr = format_byte(self.value)
+
+        return self.format_sql(field_name, value_expr, self.operator)
+    
+class BaseJoinConditionField(BaseModel):
+    class Config:
+        extra = "forbid"
+        
+    join_table_column: str = Field(
+        ...,
+        description="Join table column"
+    )
+    operator: Literal['=', '!=', '>', '<', '>=', '<=', 'IN', 'NOT IN', 'LIKE'] = Field(
+        default=...,
+        description="SQL operator used for join condition"
+    )
+
+    def to_sql(self, alias_table : str, field_name: str) -> str:
+        right = f"{alias_table}.{self.join_table_column}"
+        return f"{field_name} {self.operator} {right}"
+    
+    @classmethod
+    def with_join_table_column_type(cls, join_table_column_type: Any):
+        new_model = create_model(
+            cls.__name__,
+            __base__=cls,
+            join_table_column=(
+                join_table_column_type,
+                Field(
+                    ...,
+                    description=cls.model_fields['join_table_column'].description
+                )
+            ),
+        )
+        return new_model
+
+class JoinNumericCondition(BaseJoinConditionField):
+    operator: Literal['=', '!=', '>', '<', '>=', '<=', 'IN', 'NOT IN'] = Field(
+        default=...,
+        description="SQL operator used for numeric comparison"
+    )
+
+class JoinNumericCondition(BaseJoinConditionField):
+    operator: Literal['=', '!=', '>', '<', '>=', '<=', 'IN', 'NOT IN'] = Field(
+        default=...,
+        description="SQL operator used for numeric comparison in a join condition"
+    )
+
+class JoinStringCondition(BaseJoinConditionField):
+    operator: Literal['=', '!=', 'LIKE', 'IN', 'NOT IN'] = Field(
+        default=...,
+        description="SQL operator used for string comparison in a join condition"
+    )
+
+class JoinBooleanCondition(BaseJoinConditionField):
+    operator: Literal['=', '!='] = Field(
+        default=...,
+        description="SQL operator used for boolean comparison in a join condition"
+    )
+
+class JoinDateCondition(BaseJoinConditionField):
+    operator: Literal['=', '!=', '>', '<', '>=', '<='] = Field(
+        default=...,
+        description="SQL operator used for date/time comparison in a join condition"
+    )
+
+class JoinBytesCondition(BaseJoinConditionField):
+    operator: Literal['=', '!=', 'IN', 'NOT IN'] = Field(
+        default=...,
+        description="SQL operator used for byte comparison in a join condition"
+    )