velocity-python 0.0.131__py3-none-any.whl → 0.0.132__py3-none-any.whl

velocity/db/servers/base/types.py

@@ -0,0 +1,135 @@
+"""
+Abstract base class for database type mapping implementations.
+"""
+from abc import ABC, abstractmethod
+from typing import Any, Type, Union
+import datetime
+import decimal
+
+
+class BaseTypes(ABC):
+    """
+    Abstract base class that defines the interface for database type mappings.
+    
+    Each database implementation should provide concrete implementations of these
+    type mapping methods to handle conversion between Python types and SQL types.
+    """
+
+    # Basic SQL type constants - should be overridden by subclasses
+    TEXT: str = "TEXT"
+    INTEGER: str = "INTEGER"  
+    NUMERIC: str = "NUMERIC"
+    BOOLEAN: str = "BOOLEAN"
+    DATE: str = "DATE"
+    TIME: str = "TIME"
+    DATETIME: str = "DATETIME"
+    TIMESTAMP: str = "TIMESTAMP"
+    BINARY: str = "BINARY"
+    BIGINT: str = "BIGINT"
+    SMALLINT: str = "SMALLINT"
+
+    @classmethod
+    @abstractmethod
+    def get_type(cls, v: Any) -> str:
+        """
+        Returns a suitable SQL type string for a Python value/object.
+        
+        This method should handle conversion of Python types to appropriate
+        SQL column types for table creation and schema operations.
+        
+        Args:
+            v: Python value or type to convert
+            
+        Returns:
+            SQL type string appropriate for this database
+            
+        Examples:
+            get_type(str) -> "TEXT"
+            get_type("hello") -> "TEXT"
+            get_type(int) -> "INTEGER" 
+            get_type(123) -> "INTEGER"
+            get_type(datetime.datetime.now()) -> "TIMESTAMP"
+        """
+        pass
+
+    @classmethod
+    @abstractmethod  
+    def get_conv(cls, v: Any) -> str:
+        """
+        Returns a base SQL type for expression usage (e.g. CAST operations).
+        
+        This is typically used for CAST expressions and should return
+        the fundamental SQL type without precision/scale specifiers.
+        
+        Args:
+            v: Python value or type to convert
+            
+        Returns:
+            Base SQL type string for casting
+            
+        Examples:
+            get_conv(decimal.Decimal("123.45")) -> "NUMERIC"
+            get_conv(datetime.datetime.now()) -> "TIMESTAMP"
+        """
+        pass
+
+    @classmethod
+    @abstractmethod
+    def py_type(cls, sql_type: str) -> Type:
+        """
+        Returns the Python type that corresponds to an SQL type string.
+        
+        This method handles the reverse mapping from SQL types back to
+        Python types, typically used when reading schema information.
+        
+        Args:
+            sql_type: SQL type string from database schema
+            
+        Returns:
+            Corresponding Python type
+            
+        Examples:
+            py_type("INTEGER") -> int
+            py_type("TEXT") -> str
+            py_type("TIMESTAMP") -> datetime.datetime
+            
+        Raises:
+            Exception: If the SQL type is not recognized
+        """
+        pass
+
+    @classmethod
+    def _handle_special_values(cls, v: Any) -> tuple[bool, str]:
+        """
+        Helper method to handle special value prefixes like @@CURRENT_TIMESTAMP.
+        
+        Args:
+            v: Value to check
+            
+        Returns:
+            Tuple of (is_special, processed_value)
+        """
+        if isinstance(v, str) and v.startswith("@@"):
+            return True, v[2:] or cls.TEXT
+        return False, ""
+
+    @classmethod
+    def _get_basic_type_mapping(cls) -> dict[Type, str]:
+        """
+        Returns basic Python type to SQL type mappings.
+        Subclasses can override this to customize mappings.
+        
+        Returns:
+            Dictionary mapping Python types to SQL types
+        """
+        return {
+            str: cls.TEXT,
+            int: cls.INTEGER,
+            float: cls.NUMERIC,
+            bool: cls.BOOLEAN,
+            datetime.datetime: cls.DATETIME,
+            datetime.date: cls.DATE,
+            datetime.time: cls.TIME,
+            decimal.Decimal: cls.NUMERIC,
+            bytes: cls.BINARY,
+        }

velocity/db/servers/mysql/__init__.py

@@ -0,0 +1,64 @@
+import os
+from ..base.initializer import BaseInitializer
+from velocity.db.core import engine
+from .sql import SQL
+
+
+class MySQLInitializer(BaseInitializer):
+    """MySQL database initializer."""
+
+    @staticmethod
+    def initialize(config=None, **kwargs):
+        """
+        Initialize MySQL engine with mysql.connector driver.
+        
+        Args:
+            config: Configuration dictionary
+            **kwargs: Additional configuration parameters
+            
+        Returns:
+            Configured Engine instance
+        """
+        try:
+            import mysql.connector
+        except ImportError:
+            raise ImportError(
+                "MySQL connector not available. Install with: pip install mysql-connector-python"
+            )
+        
+        # Base configuration from environment (if available)
+        base_config = {
+            "database": os.environ.get("DBDatabase"),
+            "host": os.environ.get("DBHost"),
+            "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 MySQL-specific defaults
+        mysql_defaults = {
+            "host": "localhost",
+            "port": 3306,
+            "charset": "utf8mb4",
+            "autocommit": False,
+        }
+        
+        # Merge configurations: defaults < env < config < kwargs
+        final_config = mysql_defaults.copy()
+        final_config.update(base_config)
+        final_config = MySQLInitializer._merge_config(final_config, config, **kwargs)
+        
+        # Validate required configuration
+        required_keys = ["database", "host", "user"]
+        MySQLInitializer._validate_required_config(final_config, required_keys)
+        
+        return engine.Engine(mysql.connector, final_config, SQL)
+
+
+# Maintain backward compatibility
+def initialize(config=None, **kwargs):
+    """Backward compatible initialization function."""
+    return MySQLInitializer.initialize(config, **kwargs)

velocity/db/servers/mysql/operators.py

@@ -0,0 +1,54 @@
+from ..base.operators import BaseOperators
+
+
+class MySQLOperators(BaseOperators):
+    """
+    MySQL-specific operator mappings.
+    """
+
+    @classmethod
+    def get_operators(cls):
+        """Returns MySQL-specific operator mappings."""
+        return OPERATORS
+
+    @classmethod
+    def supports_case_insensitive_like(cls):
+        """MySQL LIKE is case-insensitive by default on case-insensitive collations."""
+        return False  # Depends on collation, but generally need to use LOWER()
+
+    @classmethod
+    def supports_regex(cls):
+        """MySQL supports REGEXP/RLIKE operators."""
+        return True
+
+    @classmethod
+    def get_regex_operators(cls):
+        """Returns MySQL regex operators."""
+        return {
+            "REGEXP": "REGEXP",
+            "RLIKE": "RLIKE",
+            "NOT REGEXP": "NOT REGEXP",
+        }
+
+
+OPERATORS = {
+    "<>": "<>",
+    "!=": "<>",
+    "!><": "NOT BETWEEN",
+    ">!<": "NOT BETWEEN",
+    "><": "BETWEEN",
+    "%%": "LIKE",  # MySQL doesn't have ILIKE, use LIKE with LOWER()
+    "!%%": "NOT LIKE",
+    "==": "=",
+    "<=": "<=",
+    ">=": ">=",
+    "<": "<",
+    ">": ">",
+    "%": "LIKE",
+    "!%": "NOT LIKE",
+    "=": "=",
+    "!": "<>",
+    "REGEXP": "REGEXP",
+    "!REGEXP": "NOT REGEXP",
+    "RLIKE": "RLIKE",
+}

velocity/db/servers/{mysql_reserved.py → mysql/reserved.py}

@@ -61,7 +61,6 @@ reserved_words = [
     "ELSEIF",
     "ENCLOSED",
     "ESCAPED",
-    "EXCEPT",
     "EXISTS",
     "EXIT",
     "EXPLAIN",
@@ -75,8 +74,6 @@ reserved_words = [
     "FOREIGN",
     "FROM",
     "FULLTEXT",
-    "GENERATED",
-    "GET",
     "GRANT",
     "GROUP",
     "HAVING",
@@ -105,7 +102,6 @@ reserved_words = [
     "IS",
     "ITERATE",
     "JOIN",
-    "JSON",
     "KEY",
     "KEYS",
     "KILL",
@@ -125,9 +121,7 @@ reserved_words = [
     "LONGTEXT",
     "LOOP",
     "LOW_PRIORITY",
-    "MASTER_SSL_VERIFY_SERVER_CERT",
     "MATCH",
-    "MAXVALUE",
     "MEDIUMBLOB",
     "MEDIUMINT",
     "MEDIUMTEXT",
@@ -150,7 +144,6 @@ reserved_words = [
     "OUT",
     "OUTER",
     "OUTFILE",
-    "PARTITION",
     "PRECISION",
     "PRIMARY",
     "PROCEDURE",
@@ -167,14 +160,11 @@ reserved_words = [
     "REPEAT",
     "REPLACE",
     "REQUIRE",
-    "RESIGNAL",
     "RESTRICT",
     "RETURN",
     "REVOKE",
     "RIGHT",
     "RLIKE",
-    "ROW",
-    "ROWS",
     "SCHEMA",
     "SCHEMAS",
     "SECOND_MICROSECOND",
@@ -183,7 +173,6 @@ reserved_words = [
     "SEPARATOR",
     "SET",
     "SHOW",
-    "SIGNAL",
     "SMALLINT",
     "SPATIAL",
     "SPECIFIC",
@@ -196,7 +185,6 @@ reserved_words = [
     "SQL_SMALL_RESULT",
     "SSL",
     "STARTING",
-    "STORED",
     "STRAIGHT_JOIN",
     "TABLE",
     "TERMINATED",
@@ -225,13 +213,13 @@ reserved_words = [
     "VARCHAR",
     "VARCHARACTER",
     "VARYING",
-    "VIRTUAL",
     "WHEN",
     "WHERE",
     "WHILE",
     "WITH",
     "WRITE",
+    "X509",
     "XOR",
     "YEAR_MONTH",
-    "ZEROFILL",
+    "ZEROFILL"
 ]