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

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"
+    )

dapper_sqls/models/result.py

@@ -1,27 +1,168 @@
-# -*- coding: latin -*-
+# coding: utf-8
+from typing import Generic, Any
+from .._types import SqlErrorType, SQL_ERROR_HTTP_CODES, T
+from .base import SensitiveFields
+import json
+from collections import defaultdict
 
 def result_dict(cursor, result):
-        return dict(
-                zip(
-                    [column[0] for column in cursor.description],
-                    result
-                )
-                )
+    return dict(
+            zip(
+                [column[0] for column in cursor.description],
+                result
+            )
+            )
 
-class Result(object):
+def classify_error(message: str) -> SqlErrorType:
+    msg = message.lower()
+
+    if "unique key constraint" in msg or "duplicate key" in msg:
+        return SqlErrorType.UNIQUE_VIOLATION
+    if "foreign key constraint" in msg:
+        return SqlErrorType.FOREIGN_KEY_VIOLATION
+    if "check constraint" in msg:
+        return SqlErrorType.CHECK_CONSTRAINT_VIOLATION
+    if "permission denied" in msg or "permission violation" in msg:
+        return SqlErrorType.PERMISSION_DENIED
+    if "syntax error" in msg:
+        return SqlErrorType.SYNTAX_ERROR
+    if "timeout" in msg:
+        return SqlErrorType.TIMEOUT
+    if any(kw in msg for kw in [
+        "could not connect", 
+        "connection failed", 
+        "server not found",
+        "network-related", 
+        "login failed", 
+        "connection timeout", 
+        "transport-level error", 
+        "communication link failure"
+    ]):
+        return SqlErrorType.CONNECTION_ERROR
     
-    class Fetchone(object):
-        def __init__(self, cursor, result, status_code = 200, message : str = ""):
+    return SqlErrorType.UNKNOWN
+
+class Error(object):
+    def __init__(self, exception: Exception = None):
+        self.message =  str(exception) if isinstance(exception, Exception) else ""
+        self.type = classify_error(self.message)
+
+class BaseResult(object):
+    def __init__(self, query : str | tuple):
+        if isinstance(query, tuple):
+            q_str, *params = query
+            stored_procedure = {
+                "query": q_str,
+                "params": [list(p) if isinstance(p, tuple) else p for p in params]
+            }
+            self._query = json.dumps(stored_procedure)
+        else:
+            self._query = query
+
+    @property
+    def query(self):
+        return self._query
+
+class Result(object):
+
+    class Count(BaseResult):
+        def __init__(self, query : str | tuple, result : int | str, status_code : int, error: Error):
+            super().__init__(query)
+            self._count = result
             self._status_code = status_code
-            self._message = message
-            if result:
+            self._success = bool(status_code == 200)
+            self._error = error
+
+        def model_dump(self):
+            if self.success:
+                return {'status_code': self.status_code, 'count': self.count}
+            else:
+                return {'status_code': self.status_code, 'message': self.error.message}
+            
+        @property
+        def count(self):
+            return self._count
+
+        @property
+        def status_code(self):
+            return self._status_code
+
+        @property
+        def success(self):
+            return self._success
+        
+        @property
+        def error(self):
+            return self._error
+    
+    class Fetchone(BaseResult):
+        def __init__(self, query : str | tuple, cursor, result, exception: Exception = None):
+            super().__init__(query)
+            self._error = Error(exception)
+            self._list = []
+            self._dict : dict[str, Any] = {}
+            if cursor != None:
+                self._status_code = 200
                 self._success = True
-                self._list = result
-                self._dict = dict(zip([column[0] for column in cursor.description], result))
+                if result:
+                    sensitive_fields = SensitiveFields.get()
+                    columns = [column[0] for column in cursor.description]
+                    raw_dict = dict(zip(columns, result))
+                    self._dict = {
+                        k: v for k, v in raw_dict.items()
+                        if k not in sensitive_fields
+                    }
+                    self._list = result
             else:
+                self._status_code = SQL_ERROR_HTTP_CODES.get(self._error.type, 500)
                 self._success = False
-                self._list = []
-                self._dict = {}
+        
+        def _organize_joined_tables(self, joins: list):
+            alias_to_table_name = {
+                join.model.TABLE_ALIAS: join.model.__class__.__name__ for join in joins
+            }
+
+            if not self._dict:
+                return
+
+            alias_data = defaultdict(dict)
+            keys_to_remove = []
+
+            for key, value in self._dict.items(): 
+                for alias_table, table_name in alias_to_table_name.items():
+                    if alias_table in key:
+                        column_name = key.replace(alias_table, '')
+                        alias_data[table_name][column_name] = value
+                        keys_to_remove.append(key)
+                        break
+
+            for key in keys_to_remove:
+                self._dict.pop(key)
+
+            if alias_data:
+                self._dict['joined_tables'] = dict(alias_data)
+
+            if self._list:
+                columns = [col for col in self._dict.keys() if col]
+                self._list = [self._dict[col] for col in columns]
+
+        def model_dump(self, *, include: set[str] = None):
+            if not self.success:
+                return {
+                    'status_code': self.status_code,
+                    'message': self.error.message
+                }
+
+            result_dict = self._dict.copy()
+
+            if include is not None:
+                include = set(include)
+                result_dict = {k: v for k, v in result_dict.items() if k in include  or k == 'joined_tables'}
+
+            return {
+                'status_code': self.status_code,
+                'data': result_dict
+            }
 
         @property
         def status_code(self):
@@ -40,24 +181,110 @@ class Result(object):
             return self._success
         
         @property
-        def message(self):
-            return self._message
+        def error(self):
+            return self._error
 
+    class FetchoneModel(Generic[T]):
+        def __init__(self, model_instance: T, fetchone_result: 'Result.Fetchone'):
+            self._model = model_instance
+            self._fetchone = fetchone_result
 
-    class Fetchall:
+        @property
+        def query(self):
+            return self._fetchone.query
 
-        def __init__(self, cursor, result, status_code = 200, message : str = ""):
-            self._status_code = status_code
-            self._message = message
-            if result:
+        @property
+        def model(self) -> T:
+            return self._model
+
+        @property
+        def success(self):
+            return self._fetchone.success
+
+        @property
+        def dict(self):
+            return self._fetchone.dict
+
+        @property
+        def list(self):
+            return self._fetchone.list
+
+        @property
+        def status_code(self):
+            return self._fetchone.status_code
+
+        @property
+        def error(self):
+            return self._fetchone.error
+
+        def model_dump(self, *, include: set[str] = None):
+            return self._fetchone.model_dump(include=include)
+
+
+    class Fetchall(BaseResult):
+
+        def __init__(self, query : str | tuple, cursor, result, exception: Exception = None):
+            super().__init__(query)
+            self._error = Error(exception)
+            self._list_dict : list[dict[str, Any]] = []
+            if cursor != None:
+                self._status_code = 200
                 self._success = True
-                self._list_dict = []
-                for r in result:
-                    self._list_dict.append(dict(zip([column[0] for column in cursor.description], r)))
+                if result:
+                    sensitive_fields = SensitiveFields.get()
+                    columns = [column[0] for column in cursor.description]
+                    for r in result:
+                        raw_dict = dict(zip(columns, r))
+                        clean_dict = {
+                            k: v for k, v in raw_dict.items()
+                            if k not in sensitive_fields
+                        }
+                        self._list_dict.append(clean_dict)
             else:
+                self._status_code = SQL_ERROR_HTTP_CODES.get(self._error.type, 500)
                 self._success = False
-                self._list_dict = []
 
+        def _organize_joined_tables(self, joins: list):
+            alias_to_table_name = {
+                join.model.TABLE_ALIAS: join.model.__class__.__name__ for join in joins
+            }
+
+            for item in self._list_dict:
+                alias_data = defaultdict(dict)
+                keys_to_remove = []
+
+                for key, value in item.items(): 
+                    for alias_table, table_name in alias_to_table_name.items():
+                        if alias_table in key:
+                            column_name = key.replace(alias_table, '')
+                            alias_data[table_name][column_name] = value
+                            keys_to_remove.append(key)
+                            break
+
+                for key in keys_to_remove:
+                    del item[key]
+
+                if alias_data:
+                    item['joined_tables'] = dict(alias_data)
+
+        def model_dump(self, *, include: set[str] = None):
+            if not self.success:
+                return {
+                    'status_code': self.status_code,
+                    'message': self.error.message
+                }
+
+            data = self._list_dict
+
+            if include is not None:
+                include = set(include)
+                data = [{k: v for k, v in d.items() if k in include or k == 'joined_tables'} for d in data]
+
+            return {
+                'status_code': self.status_code,
+                'data': data
+            }
+        
         @property
         def status_code(self):
             return self._status_code
@@ -66,24 +293,60 @@ class Result(object):
         def list_dict(self):
             return self._list_dict
 
-        @property
-        def dict(self):
-            return self._dict
-
         @property
         def success(self):
             return self._success
         
         @property
-        def message(self):
-            return self._message
+        def error(self):
+            return self._error
+        
+    class FetchallModel(Generic[T]):
+        def __init__(self, model_list: list[T], fetchall_result: 'Result.Fetchall'):
+            self._models = model_list
+            self._fetchall = fetchall_result
+
+        @property
+        def query(self):
+            return self._fetchall.query
+
+        @property
+        def models(self) -> list[T]:
+            return self._models
+
+        @property
+        def success(self):
+            return self._fetchall.success
+
+        @property
+        def list_dict(self):
+            return self._fetchall.list_dict
+
+        @property
+        def status_code(self):
+            return self._fetchall.status_code
+
+        @property
+        def error(self):
+            return self._fetchall.error
 
-    class Insert:
-        def __init__(self, result : int | str, status_code = 200, message : str = ""):
+        def model_dump(self, *, include: set[str] = None):
+            include = set(include)
+            return self._fetchall.model_dump(include=include)
+
+    class Insert(BaseResult):
+        def __init__(self, query : str | tuple, result : int | str, status_code : int, error: Error):
+            super().__init__(query)
             self._id = result
             self._status_code = status_code
-            self._success = bool(result)
-            self._message = message
+            self._success = bool(status_code == 200)
+            self._error = error
+
+        def model_dump(self):
+            if self.success:
+                return {'status_code': self.status_code, 'id': self.id}
+            else:
+                return {'status_code': self.status_code, 'message': self.error.message}
 
         @property
         def id(self):
@@ -98,15 +361,22 @@ class Result(object):
             return self._success
         
         @property
-        def message(self):
-            return self._message
+        def error(self):
+            return self._error
 
-    class Send:
-        def __init__(self, result : bool, status_code = 200, message : str = ""):
-            self._status_code = status_code
+    class Send(BaseResult):
+        def __init__(self, query : str | tuple, result : bool, exception: Exception = None):
+            super().__init__(query)
+            self._error = Error(exception)
+            self._status_code = 200 if result else SQL_ERROR_HTTP_CODES.get(self._error.type, 500)
             self._success = result
-            self._message = message
 
+        def model_dump(self):
+            if self.success:
+                return {'status_code': self.status_code}
+            else:
+                return {'status_code': self.status_code, 'message': self.error.message}
+            
         @property
         def status_code(self):
             return self._status_code
@@ -116,8 +386,8 @@ class Result(object):
             return self._success
         
         @property
-        def message(self):
-            return self._message
+        def error(self):
+            return self._error
 
 
 

dapper_sqls/sqlite/__init__.py

@@ -1,4 +1,8 @@
-from .local_database import LocalDatabase
+from .local_database import BaseLocalDatabase
+from .async_local_database import BaseAsyncLocalDatabase
+from .installer import DataBaseInstall
+from .models import BaseTables
+from .decorators import safe_sqlite_operation, SqliteErrorType