velocity-python 0.0.109__py3-none-any.whl → 0.0.161__py3-none-any.whl

velocity/db/servers/sqlserver/types.py

@@ -0,0 +1,114 @@
+import decimal
+import datetime
+from ..base.types import BaseTypes
+
+
+class TYPES(BaseTypes):
+    """
+    SQL Server-specific type mapping implementation.
+    """
+
+    TEXT = "NVARCHAR(MAX)"
+    VARCHAR = "VARCHAR"
+    NVARCHAR = "NVARCHAR"
+    INTEGER = "INT"
+    BIGINT = "BIGINT"
+    SMALLINT = "SMALLINT"
+    TINYINT = "TINYINT"
+    NUMERIC = "DECIMAL"
+    DECIMAL = "DECIMAL"
+    FLOAT = "FLOAT"
+    REAL = "REAL"
+    MONEY = "MONEY"
+    DATETIME = "DATETIME"
+    DATETIME2 = "DATETIME2"
+    DATE = "DATE"
+    TIME = "TIME"
+    TIMESTAMP = "ROWVERSION"
+    BOOLEAN = "BIT"
+    BINARY = "VARBINARY(MAX)"
+    UNIQUEIDENTIFIER = "UNIQUEIDENTIFIER"
+
+    @classmethod
+    def get_type(cls, v):
+        """
+        Returns a suitable SQL type string for a Python value/object (SQL Server).
+        """
+        is_special, special_val = cls._handle_special_values(v)
+        if is_special:
+            return special_val
+            
+        if isinstance(v, str) or v is str:
+            return cls.TEXT
+        if isinstance(v, bool) or v is bool:
+            return cls.BOOLEAN
+        if isinstance(v, int) or v is int:
+            return cls.BIGINT
+        if isinstance(v, float) or v is float:
+            return f"{cls.DECIMAL}(19, 6)"
+        if isinstance(v, decimal.Decimal) or v is decimal.Decimal:
+            return f"{cls.DECIMAL}(19, 6)"
+        if isinstance(v, datetime.datetime) or v is datetime.datetime:
+            return cls.DATETIME2
+        if isinstance(v, datetime.date) or v is datetime.date:
+            return cls.DATE
+        if isinstance(v, datetime.time) or v is datetime.time:
+            return cls.TIME
+        if isinstance(v, bytes) or v is bytes:
+            return cls.BINARY
+        return cls.TEXT
+
+    @classmethod
+    def get_conv(cls, v):
+        """
+        Returns a base SQL type for expression usage (SQL Server).
+        """
+        is_special, special_val = cls._handle_special_values(v)
+        if is_special:
+            return special_val
+            
+        if isinstance(v, str) or v is str:
+            return cls.NVARCHAR
+        if isinstance(v, bool) or v is bool:
+            return cls.BOOLEAN
+        if isinstance(v, int) or v is int:
+            return cls.BIGINT
+        if isinstance(v, float) or v is float:
+            return cls.DECIMAL
+        if isinstance(v, decimal.Decimal) or v is decimal.Decimal:
+            return cls.DECIMAL
+        if isinstance(v, datetime.datetime) or v is datetime.datetime:
+            return cls.DATETIME2
+        if isinstance(v, datetime.date) or v is datetime.date:
+            return cls.DATE
+        if isinstance(v, datetime.time) or v is datetime.time:
+            return cls.TIME
+        if isinstance(v, bytes) or v is bytes:
+            return cls.BINARY
+        return cls.NVARCHAR
+
+    @classmethod
+    def py_type(cls, v):
+        """
+        Returns the Python type that corresponds to an SQL type string (SQL Server).
+        """
+        v = str(v).upper()
+        if v in (cls.INTEGER, cls.SMALLINT, cls.BIGINT, cls.TINYINT):
+            return int
+        if v in (cls.NUMERIC, cls.DECIMAL, cls.MONEY) or "DECIMAL" in v:
+            return decimal.Decimal
+        if v in (cls.FLOAT, cls.REAL):
+            return float
+        if v in (cls.TEXT, cls.VARCHAR, cls.NVARCHAR) or "VARCHAR" in v or "CHAR" in v:
+            return str
+        if v == cls.BOOLEAN or v == "BIT":
+            return bool
+        if v == cls.DATE:
+            return datetime.date
+        if v == cls.TIME:
+            return datetime.time
+        if v in (cls.DATETIME, cls.DATETIME2):
+            return datetime.datetime
+        if v == cls.BINARY or "BINARY" in v:
+            return bytes
+        raise Exception(f"Unmapped SQL Server type {v}")

velocity/db/servers/tablehelper.py

@@ -9,21 +9,21 @@ class TableHelper:
     """
     A helper class used to build SQL queries with joined/aliased tables,
     including foreign key expansions, pointer syntax, etc.
-    
+
     This class is database-agnostic. Database-specific reserved words and operators
     should be set as class attributes by the database implementation modules.
     """
 
     # Reserved words that need quoting - set by database implementation
     reserved = []
-    
-    # SQL operators with their symbols - set by database implementation  
+
+    # SQL operators with their symbols - set by database implementation
     operators = {}
 
     def __init__(self, tx, table: str):
         """
         Initialize TableHelper.
-        
+
         Args:
             tx: Database transaction object
             table: The main table name for this query
@@ -44,20 +44,20 @@ class TableHelper:
     def split_columns(self, query: str) -> List[str]:
         """
         Splits a string of comma-separated column expressions into a list, keeping parentheses balanced.
-        
+
         Args:
             query: Comma-separated column expression string
-            
+
         Returns:
             List of individual column expressions
         """
         if not isinstance(query, str):
             raise TypeError(f"Query must be a string, got {type(query)}")
-            
+
         columns = []
         balance = 0
         current = []
-        
+
         for char in query:
             if char == "," and balance == 0:
                 column = "".join(current).strip()
@@ -70,13 +70,13 @@ class TableHelper:
                 elif char == ")":
                     balance -= 1
                 current.append(char)
-                
+
         # Add the last column
         if current:
             column = "".join(current).strip()
             if column:
                 columns.append(column)
-                
+
         return columns
 
     def requires_joins(self) -> bool:
@@ -86,65 +86,67 @@ class TableHelper:
     def has_pointer(self, column: str) -> bool:
         """
         Checks if there's an '>' in the column that indicates a pointer reference, e.g. 'local_column>foreign_column'.
-        
+
         Args:
             column: The column string to check
-            
+
         Returns:
             bool: True if column contains pointer syntax
-            
+
         Raises:
             ValueError: If column format is invalid
         """
         if not isinstance(column, str):
             raise ValueError(f"Column must be a string, got {type(column)}")
-        
+
         if not re.search(r"^[a-zA-Z0-9_>*]", column):
             raise ValueError(f"Invalid column specified: {column}")
-            
+
         return bool(re.search(r"[a-zA-Z0-9_]+>[a-zA-Z0-9_]+", column))
 
     def __fetch_foreign_data(self, key: str) -> Dict[str, Any]:
         """
         Fetch foreign key information for a given key.
-        
+
         Args:
             key: The foreign key string in format 'local_column>foreign_column'
-            
+
         Returns:
             Dict containing foreign key metadata
-            
+
         Raises:
             ValueError: If foreign key is not properly defined
         """
         if key in self.foreign_keys:
             return self.foreign_keys[key]
-            
+
         if ">" not in key:
-            raise ValueError(f"Invalid foreign key format: {key}. Expected 'local>foreign'")
-            
+            raise ValueError(
+                f"Invalid foreign key format: {key}. Expected 'local>foreign'"
+            )
+
         local_column, foreign_column = key.split(">", 1)  # Split only on first >
-        
+
         try:
             foreign = self.tx.table(self.current_table).foreign_key_info(local_column)
         except Exception as e:
             raise ValueError(f"Error fetching foreign key info for {local_column}: {e}")
-            
+
         if not foreign:
             raise ValueError(
                 f"Foreign key `{self.current_table}.{local_column}>{foreign_column}` not defined."
             )
-            
+
         ref_table = foreign["referenced_table_name"]
         ref_schema = foreign["referenced_table_schema"]
         ref_column = foreign["referenced_column_name"]
-        
+
         if ref_table not in self.table_aliases:
             if self.letter > 90:  # Z is ASCII 90
                 raise ValueError("Too many table aliases - limit of 26 tables exceeded")
             self.table_aliases[ref_table] = chr(self.letter)
             self.letter += 1
-            
+
         alias = self.table_aliases[ref_table]
         data = {
             "alias": alias,
@@ -156,21 +158,23 @@ class TableHelper:
         self.foreign_keys[key] = data
         return data
 
-    def resolve_references(self, key: str, options: Optional[Dict[str, Any]] = None) -> str:
+    def resolve_references(
+        self, key: str, options: Optional[Dict[str, Any]] = None
+    ) -> str:
         """
         Resolves pointer syntax or table alias references.
-        
+
         Args:
             key: The column key that may contain pointer syntax (e.g., 'local>foreign')
             options: Dictionary controlling aliasing behavior:
                 - alias_column: Whether to add column aliases
-                - alias_table: Whether to prefix with table aliases  
+                - alias_table: Whether to prefix with table aliases
                 - alias_only: Whether to return only the alias name
                 - bypass_on_error: Whether to return original key on errors
-                
+
         Returns:
             Resolved column reference with appropriate aliasing
-            
+
         Raises:
             ValueError: If key is invalid and bypass_on_error is False
         """
@@ -178,10 +182,10 @@ class TableHelper:
             if options and options.get("bypass_on_error"):
                 return key or ""
             raise ValueError(f"Invalid key: {key}")
-            
+
         if options is None:
             options = {"alias_column": True, "alias_table": False, "alias_only": False}
-            
+
         # Remove operator first, then extract column name
         key_without_operator = self.remove_operator(key)
         column = self.extract_column_name(key_without_operator)
@@ -193,7 +197,11 @@ class TableHelper:
         alias = self.get_table_alias("current_table")
         if not self.has_pointer(column):
             # Standard column - no pointer syntax
-            if options.get("alias_table") and alias and alias != self.table_aliases.get("current_table", "A"):
+            if (
+                options.get("alias_table")
+                and alias
+                and alias != self.table_aliases.get("current_table", "A")
+            ):
                 name = f"{alias}.{self.quote(column)}"
             else:
                 name = self.quote(column)
@@ -206,33 +214,35 @@ class TableHelper:
             if options.get("bypass_on_error"):
                 return key
             raise ValueError(f"Invalid pointer syntax in column: {column}")
-            
+
         local_column, foreign_column = pointer_parts
         local_column = local_column.strip()
         foreign_column = foreign_column.strip()
-        
+
         if not local_column or not foreign_column:
             if options.get("bypass_on_error"):
                 return key
             raise ValueError(f"Invalid pointer syntax - empty parts in: {column}")
-        
+
         if options.get("alias_only"):
             return f"{local_column}_{foreign_column}"
-            
+
         try:
             data = self.__fetch_foreign_data(column)
         except Exception as e:
             if options.get("bypass_on_error"):
                 return key
             raise ValueError(f"Failed to resolve foreign key reference '{column}': {e}")
-            
+
         # Build the foreign table reference
         if options.get("alias_table"):
-            foreign_alias = self.get_table_alias(data['ref_table'])
+            foreign_alias = self.get_table_alias(data["ref_table"])
             if not foreign_alias:
                 if options.get("bypass_on_error"):
                     return key
-                raise ValueError(f"No alias found for foreign table: {data['ref_table']}")
+                raise ValueError(
+                    f"No alias found for foreign table: {data['ref_table']}"
+                )
             name = f"{foreign_alias}.{self.quote(foreign_column)}"
         else:
             name = f"{data['ref_table']}.{self.quote(foreign_column)}"
@@ -241,33 +251,33 @@ class TableHelper:
         result = self.remove_operator(key).replace(column, name, 1)
         if options.get("alias_column"):
             result += f" AS {local_column}_{foreign_column}"
-            
+
         return result
 
     def get_operator(self, key: str, val: Any) -> str:
         """
         Determines the SQL operator from the start of `key` or defaults to '='.
-        
+
         Args:
             key: The key string that may contain an operator prefix
             val: The value (used for context in operator determination)
-            
+
         Returns:
             str: The SQL operator to use
-            
+
         Raises:
             ValueError: If key is invalid or operator is unsafe
         """
         if not isinstance(key, str):
             raise ValueError(f"Key must be a string, got {type(key)}")
-            
+
         # Sanitize the key to prevent injection
         sanitized_key = " ".join(key.replace('"', "").split())
-        
+
         for symbol, operator in self.operators.items():
             if sanitized_key.startswith(symbol):
                 # Basic validation that the operator is safe
-                if not re.match(r'^[A-Z\s<>=!]+$', operator):
+                if not re.match(r"^[A-Z\s<>=!]+$", operator):
                     raise ValueError(f"Unsafe operator detected: {operator}")
                 return operator
         return "="
@@ -275,16 +285,16 @@ class TableHelper:
     def remove_operator(self, key: str) -> str:
         """
         Strips recognized operator symbols from the start of `key`.
-        
+
         Args:
             key: The key string that may contain an operator prefix
-            
+
         Returns:
             Key with operator prefix removed
         """
         if not isinstance(key, str):
             return key
-            
+
         for symbol in self.operators.keys():
             if key.startswith(symbol):
                 return key.replace(symbol, "", 1)
@@ -344,14 +354,14 @@ class TableHelper:
         # Handle asterisk separately since \b doesn't work with non-word characters
         if expr.strip() == "*":
             return "*"
-        
+
         # Check for pointer syntax (>)
         if ">" in expr:
             # For pointer syntax, return the whole expression
             pointer_match = re.search(r"([a-zA-Z_][\w]*>[a-zA-Z_][\w]*)", expr)
             if pointer_match:
                 return pointer_match.group(1)
-        
+
         match = re.search(
             r"\b([a-zA-Z_][\w]*\.\*|[a-zA-Z_][\w]*(?:\.[a-zA-Z_][\w]*)?)\b", expr
         )
@@ -360,10 +370,10 @@ class TableHelper:
     def are_parentheses_balanced(self, expression: str) -> bool:
         """
         Checks if parentheses in `expression` are balanced.
-        
+
         Args:
             expression: The expression to check
-            
+
         Returns:
             bool: True if parentheses are balanced
         """
@@ -371,7 +381,7 @@ class TableHelper:
         opening = "({["
         closing = ")}]"
         matching = {")": "(", "}": "{", "]": "["}
-        
+
         for char in expression:
             if char in opening:
                 stack.append(char)
@@ -383,30 +393,32 @@ class TableHelper:
     def get_table_alias(self, table: str) -> Optional[str]:
         """
         Get the alias for a table.
-        
+
         Args:
             table: The table name
-            
+
         Returns:
             The table alias or None if not found
         """
         return self.table_aliases.get(table)
 
-    def make_predicate(self, key: str, val: Any, options: Optional[Dict[str, Any]] = None) -> Tuple[str, Any]:
+    def make_predicate(
+        self, key: str, val: Any, options: Optional[Dict[str, Any]] = None
+    ) -> Tuple[str, Any]:
         """
         Builds a piece of SQL and corresponding parameters for a WHERE/HAVING predicate based on `key`, `val`.
-        
+
         Args:
             key: The column key (may include operator prefix)
             val: The value to compare against
             options: Dictionary of options for reference resolution
-            
+
         Returns:
             Tuple of (sql_string, parameters)
         """
         if options is None:
             options = {"alias_table": True, "alias_column": False}
-            
+
         column = self.resolve_references(key, options=options)
         op = self.get_operator(key, val)
 
@@ -434,16 +446,16 @@ class TableHelper:
                     val = tuple(int(v) for v in val)
                 except ValueError:
                     pass  # Keep as strings if conversion fails
-                    
+
             # Convert to tuple for better parameter handling
             val_tuple = tuple(val)
-            
+
             if not val_tuple:  # Empty list/tuple
                 if "!" in key:
                     return "1=1", None  # Empty NOT IN is always true
                 else:
                     return "1=0", None  # Empty IN is always false
-            
+
             # Use IN/NOT IN for better type compatibility
             if "!" in key:
                 placeholders = ",".join(["%s"] * len(val_tuple))
@@ -459,50 +471,56 @@ class TableHelper:
         # Between operators
         if op in ["BETWEEN", "NOT BETWEEN"]:
             if not isinstance(val, (list, tuple)) or len(val) != 2:
-                raise ValueError(f"BETWEEN operator requires exactly 2 values, got {val}")
+                raise ValueError(
+                    f"BETWEEN operator requires exactly 2 values, got {val}"
+                )
             return f"{column} {op} %s and %s", tuple(val)
 
         # Default single-parameter predicate
         return f"{column} {op} %s", val
 
-    def make_where(self, where: Union[Dict[str, Any], List[Tuple[str, Any]], str, None]) -> Tuple[str, Tuple[Any, ...]]:
+    def make_where(
+        self, where: Union[Dict[str, Any], List[Tuple[str, Any]], str, None]
+    ) -> Tuple[str, Tuple[Any, ...]]:
         """
         Converts various WHERE clause formats into SQL string and parameter values.
-        
+
         Args:
             where: WHERE conditions in one of these formats:
                 - Dict: {column: value} pairs that become "column = value" predicates
                 - List of tuples: [(predicate_sql, params), ...] for pre-built predicates
                 - String: Raw SQL WHERE clause (parameters not extracted)
                 - None: No WHERE clause
-                
+
         Returns:
             Tuple of (sql_string, parameter_tuple):
                 - sql_string: Complete WHERE clause including "WHERE" keyword, or empty string
                 - parameter_tuple: Tuple of parameter values for placeholder substitution
-                
+
         Raises:
             ValueError: If where format is invalid or predicate generation fails
             TypeError: If where is an unsupported type
         """
         if not where:
             return "", tuple()
-            
+
         # Convert dict to list of predicates
         if isinstance(where, Mapping):
             if not where:  # Empty dict
                 return "", tuple()
-                
+
             predicate_list = []
             for key, val in where.items():
                 if not isinstance(key, str):
-                    raise ValueError(f"WHERE clause keys must be strings, got {type(key)}: {key}")
+                    raise ValueError(
+                        f"WHERE clause keys must be strings, got {type(key)}: {key}"
+                    )
                 try:
                     predicate_list.append(self.make_predicate(key, val))
                 except Exception as e:
                     raise ValueError(f"Failed to create predicate for '{key}': {e}")
             where = predicate_list
-            
+
         # Handle string WHERE clause (pass through as-is)
         elif isinstance(where, str):
             where_clause = where.strip()
@@ -512,39 +530,45 @@ class TableHelper:
             if not where_clause.upper().startswith("WHERE"):
                 where_clause = f"WHERE {where_clause}"
             return where_clause, tuple()
-            
+
         # Validate list format
         elif isinstance(where, (list, tuple)):
             if not where:  # Empty list
                 return "", tuple()
-                
+
             # Validate each predicate tuple
             for i, item in enumerate(where):
                 if not isinstance(item, (list, tuple)) or len(item) != 2:
-                    raise ValueError(f"WHERE predicate {i} must be a 2-element tuple (sql, params), got: {item}")
+                    raise ValueError(
+                        f"WHERE predicate {i} must be a 2-element tuple (sql, params), got: {item}"
+                    )
                 sql_part, params = item
                 if not isinstance(sql_part, str):
-                    raise ValueError(f"WHERE predicate {i} SQL must be a string, got {type(sql_part)}: {sql_part}")
+                    raise ValueError(
+                        f"WHERE predicate {i} SQL must be a string, got {type(sql_part)}: {sql_part}"
+                    )
         else:
-            raise TypeError(f"WHERE clause must be dict, list, string, or None, got {type(where)}: {where}")
+            raise TypeError(
+                f"WHERE clause must be dict, list, string, or None, got {type(where)}: {where}"
+            )
 
         # Build final SQL and collect parameters
         sql_parts = ["WHERE"]
         vals = []
-        
+
         for i, (pred_sql, pred_val) in enumerate(where):
             if i > 0:  # Add AND between predicates
                 sql_parts.append("AND")
-                
+
             sql_parts.append(pred_sql)
-            
+
             # Handle parameter values
             if pred_val is not None:
                 if isinstance(pred_val, tuple):
                     vals.extend(pred_val)
                 else:
                     vals.append(pred_val)
-                    
+
         return " ".join(sql_parts), tuple(vals)
 
     @classmethod
@@ -552,10 +576,10 @@ class TableHelper:
         """
         Class method version of quote for backward compatibility.
         Quotes identifiers (columns/tables) if needed, especially if they match reserved words or contain special chars.
-        
+
         Args:
             data: String identifier or list of identifiers to quote
-            
+
         Returns:
             Quoted identifier(s)
         """
@@ -571,22 +595,24 @@ class TableHelper:
 
         parts = data.split(".")
         quoted_parts = []
-        
+
         for part in parts:
             if not part:  # Skip empty parts
                 continue
-                
+
             # Skip if already quoted
             if part.startswith('"') and part.endswith('"'):
                 quoted_parts.append(part)
             # Quote if reserved word, contains special chars, or starts with digit
-            elif (part.upper() in cls.reserved or 
-                  re.search(r'[/\-\s]', part) or 
-                  (part and part[0].isdigit())):
+            elif (
+                part.upper() in cls.reserved
+                or re.search(r"[/\-\s]", part)
+                or (part and part[0].isdigit())
+            ):
                 # Escape any existing quotes in the identifier
                 escaped_part = part.replace('"', '""')
                 quoted_parts.append(f'"{escaped_part}"')
             else:
                 quoted_parts.append(part)
-                
+
         return ".".join(quoted_parts)

velocity/db/tests/__init__.py

@@ -0,0 +1 @@
+# Database module tests

velocity/db/tests/postgres/__init__.py

@@ -0,0 +1 @@
+# PostgreSQL tests