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

velocity/db/servers/sqlite/types.py

@@ -0,0 +1,92 @@
+import decimal
+import datetime
+from ..base.types import BaseTypes
+
+
+class TYPES(BaseTypes):
+    """
+    SQLite-specific type mapping implementation.
+    Note: SQLite has dynamic typing, but we still define these for consistency.
+    """
+
+    TEXT = "TEXT"
+    INTEGER = "INTEGER"
+    NUMERIC = "NUMERIC"
+    REAL = "REAL"
+    BLOB = "BLOB"
+    # SQLite doesn't have separate date/time types - they're stored as TEXT, REAL, or INTEGER
+    DATE = "TEXT"
+    TIME = "TEXT"
+    DATETIME = "TEXT"
+    TIMESTAMP = "TEXT"
+    BOOLEAN = "INTEGER"  # SQLite stores booleans as integers
+
+    @classmethod
+    def get_type(cls, v):
+        """
+        Returns a suitable SQL type string for a Python value/object (SQLite).
+        """
+        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.INTEGER
+        if isinstance(v, float) or v is float:
+            return cls.REAL
+        if isinstance(v, decimal.Decimal) or v is decimal.Decimal:
+            return cls.NUMERIC
+        if isinstance(v, (datetime.datetime, datetime.date, datetime.time)) or v in (datetime.datetime, datetime.date, datetime.time):
+            return cls.TEXT  # SQLite stores dates as text
+        if isinstance(v, bytes) or v is bytes:
+            return cls.BLOB
+        return cls.TEXT
+
+    @classmethod
+    def get_conv(cls, v):
+        """
+        Returns a base SQL type for expression usage (SQLite).
+        """
+        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.INTEGER
+        if isinstance(v, float) or v is float:
+            return cls.REAL
+        if isinstance(v, decimal.Decimal) or v is decimal.Decimal:
+            return cls.NUMERIC
+        if isinstance(v, (datetime.datetime, datetime.date, datetime.time)) or v in (datetime.datetime, datetime.date, datetime.time):
+            return cls.TEXT
+        if isinstance(v, bytes) or v is bytes:
+            return cls.BLOB
+        return cls.TEXT
+
+    @classmethod
+    def py_type(cls, v):
+        """
+        Returns the Python type that corresponds to an SQL type string (SQLite).
+        """
+        v = str(v).upper()
+        if v == cls.INTEGER:
+            return int
+        if v in (cls.NUMERIC, cls.REAL):
+            return float  # SQLite doesn't distinguish, but float is common
+        if v == cls.TEXT:
+            return str
+        if v == cls.BOOLEAN:
+            return bool
+        if v == cls.BLOB:
+            return bytes
+        # For date/time stored as TEXT in SQLite, we'll return str
+        # The application layer needs to handle conversion
+        return str

velocity/db/servers/sqlserver/__init__.py

@@ -0,0 +1,73 @@
+import os
+from ..base.initializer import BaseInitializer
+from velocity.db.core import engine
+from .sql import SQL
+
+
+class SQLServerInitializer(BaseInitializer):
+    """SQL Server database initializer."""
+
+    @staticmethod
+    def initialize(config=None, schema_locked=False, **kwargs):
+        """
+        Initialize SQL Server engine with pytds driver.
+        
+        Args:
+            config: Configuration dictionary
+            schema_locked: Boolean to lock schema modifications
+            **kwargs: Additional configuration parameters
+            
+        Returns:
+            Configured Engine instance
+        """
+        try:
+            import pytds
+        except ImportError:
+            raise ImportError(
+                "SQL Server connector not available. Install with: pip install python-tds"
+            )
+        
+        # Base configuration from environment (if available)
+        base_config = {
+            "database": os.environ.get("DBDatabase"),
+            "server": os.environ.get("DBHost"),  # SQL Server uses 'server' instead of 'host'
+            "port": os.environ.get("DBPort"),
+            "user": os.environ.get("DBUser"),
+            "password": os.environ.get("DBPassword"),
+        }
+        
+        # Remove None values
+        base_config = {k: v for k, v in base_config.items() if v is not None}
+        
+        # Set SQL Server-specific defaults
+        sqlserver_defaults = {
+            "server": "localhost",
+            "port": 1433,
+            "autocommit": False,
+            "timeout": 30,
+        }
+        
+        # Merge configurations: defaults < env < config < kwargs
+        final_config = sqlserver_defaults.copy()
+        final_config.update(base_config)
+        final_config = SQLServerInitializer._merge_config(final_config, config, **kwargs)
+        
+        # Validate required configuration
+        required_keys = ["database", "server", "user"]
+        SQLServerInitializer._validate_required_config(final_config, required_keys)
+        
+        # Check for environment variable override for schema locking
+        if os.environ.get("VELOCITY_SCHEMA_LOCKED", "").lower() in ('true', '1', 'yes'):
+            schema_locked = True
+        
+        return engine.Engine(pytds, final_config, SQL, schema_locked=schema_locked)
+
+
+# Maintain backward compatibility
+def initialize(config=None, schema_locked=False, **kwargs):
+    """Backward compatible initialization function."""
+    # Check for environment variable override for schema locking
+    if os.environ.get("VELOCITY_SCHEMA_LOCKED", "").lower() in ('true', '1', 'yes'):
+        schema_locked = True
+        
+    return SQLServerInitializer.initialize(config, schema_locked, **kwargs)

velocity/db/servers/sqlserver/operators.py

@@ -0,0 +1,47 @@
+from ..base.operators import BaseOperators
+
+
+class SQLServerOperators(BaseOperators):
+    """
+    SQL Server-specific operator mappings.
+    """
+
+    @classmethod
+    def get_operators(cls):
+        """Returns SQL Server-specific operator mappings."""
+        return OPERATORS
+
+    @classmethod
+    def supports_case_insensitive_like(cls):
+        """SQL Server LIKE case sensitivity depends on collation."""
+        return False  # Depends on database collation
+
+    @classmethod
+    def supports_regex(cls):
+        """SQL Server doesn't have built-in regex operators (until recent versions)."""
+        return False
+
+    @classmethod
+    def get_regex_operators(cls):
+        """Returns SQL Server regex operators (none in older versions)."""
+        return {}
+
+
+OPERATORS = {
+    "<>": "<>",
+    "!=": "<>",
+    "!><": "NOT BETWEEN",
+    ">!<": "NOT BETWEEN",
+    "><": "BETWEEN",
+    "%%": "LIKE",  # SQL Server doesn't have ILIKE
+    "!%%": "NOT LIKE",
+    "==": "=",
+    "<=": "<=",
+    ">=": ">=",
+    "<": "<",
+    ">": ">",
+    "%": "LIKE",
+    "!%": "NOT LIKE",
+    "=": "=",
+    "!": "<>",
+}

velocity/db/servers/sqlserver/reserved.py

@@ -0,0 +1,32 @@
+reserved_words = [
+    "ADD", "ALL", "ALTER", "AND", "ANY", "AS", "ASC", "AUTHORIZATION",
+    "BACKUP", "BEGIN", "BETWEEN", "BREAK", "BROWSE", "BULK", "BY",
+    "CASCADE", "CASE", "CHECK", "CHECKPOINT", "CLOSE", "CLUSTERED",
+    "COALESCE", "COLLATE", "COLUMN", "COMMIT", "COMPUTE", "CONSTRAINT",
+    "CONTAINS", "CONTAINSTABLE", "CONTINUE", "CONVERT", "CREATE", "CROSS",
+    "CURRENT", "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP",
+    "CURRENT_USER", "CURSOR", "DATABASE", "DBCC", "DEALLOCATE", "DECLARE",
+    "DEFAULT", "DELETE", "DENY", "DESC", "DISK", "DISTINCT", "DISTRIBUTED",
+    "DOUBLE", "DROP", "DUMP", "ELSE", "END", "ERRLVL", "ESCAPE", "EXCEPT",
+    "EXEC", "EXECUTE", "EXISTS", "EXIT", "EXTERNAL", "FETCH", "FILE",
+    "FILLFACTOR", "FOR", "FOREIGN", "FREETEXT", "FREETEXTTABLE", "FROM",
+    "FULL", "FUNCTION", "GOTO", "GRANT", "GROUP", "HAVING", "HOLDLOCK",
+    "IDENTITY", "IDENTITY_INSERT", "IDENTITYCOL", "IF", "IN", "INDEX",
+    "INNER", "INSERT", "INTERSECT", "INTO", "IS", "JOIN", "KEY", "KILL",
+    "LEFT", "LIKE", "LINENO", "LOAD", "MERGE", "NATIONAL", "NOCHECK",
+    "NONCLUSTERED", "NOT", "NULL", "NULLIF", "OF", "OFF", "OFFSETS",
+    "ON", "OPEN", "OPENDATASOURCE", "OPENQUERY", "OPENROWSET", "OPENXML",
+    "OPTION", "OR", "ORDER", "OUTER", "OVER", "PERCENT", "PIVOT", "PLAN",
+    "PRECISION", "PRIMARY", "PRINT", "PROC", "PROCEDURE", "PUBLIC",
+    "RAISERROR", "READ", "READTEXT", "RECONFIGURE", "REFERENCES",
+    "REPLICATION", "RESTORE", "RESTRICT", "RETURN", "REVERT", "REVOKE",
+    "RIGHT", "ROLLBACK", "ROWCOUNT", "ROWGUIDCOL", "RULE", "SAVE",
+    "SCHEMA", "SECURITYAUDIT", "SELECT", "SEMANTICKEYPHRASETABLE",
+    "SEMANTICSIMILARITYDETAILSTABLE", "SEMANTICSIMILARITYTABLE",
+    "SESSION_USER", "SET", "SETUSER", "SHUTDOWN", "SOME", "STATISTICS",
+    "SYSTEM_USER", "TABLE", "TABLESAMPLE", "TEXTSIZE", "THEN", "TO",
+    "TOP", "TRAN", "TRANSACTION", "TRIGGER", "TRUNCATE", "TRY_CONVERT",
+    "TSEQUAL", "UNION", "UNIQUE", "UNPIVOT", "UPDATE", "UPDATETEXT",
+    "USE", "USER", "VALUES", "VARYING", "VIEW", "WAITFOR", "WHEN",
+    "WHERE", "WHILE", "WITH", "WITHIN", "WRITETEXT"
+]