springbootAI 1.8.0__py3-none-any.whl

spring/orm/pymybatis/core/sql_session_factory.py

@@ -0,0 +1,76 @@
+"""
+PyMyBatis SqlSessionFactory模块
+
+SqlSessionFactory是SqlSession的工厂类，负责创建SqlSession实例
+"""
+
+from typing import Optional
+from ..configuration import Configuration
+from .sql_session import SqlSession, create_pool_from_configuration
+
+
+class SqlSessionFactory:
+    """
+    SqlSession工厂类
+
+    核心功能：
+    1. 创建SqlSession实例
+    2. 管理配置
+    """
+
+    def __init__(self, configuration: Optional[Configuration] = None):
+        """
+        初始化SqlSessionFactory
+
+        Args:
+            configuration: 配置对象，不指定则使用默认配置
+        """
+        self.configuration = configuration or Configuration()
+        self.connection_pool = create_pool_from_configuration(self.configuration)
+        self._closed = False
+
+    def open_session(self) -> SqlSession:
+        """
+        创建SqlSession实例
+
+        Returns:
+            SqlSession实例
+        """
+        if self._closed:
+            raise RuntimeError("SqlSessionFactory 已关闭")
+        return SqlSession(self.configuration, connection_pool=self.connection_pool)
+
+    def get_configuration(self) -> Configuration:
+        """
+        获取配置对象
+
+        Returns:
+            配置对象
+        """
+        return self.configuration
+
+    def set_configuration(self, configuration: Configuration) -> None:
+        """
+        设置配置对象
+
+        Args:
+            configuration: 配置对象
+        """
+        self.connection_pool.close()
+        self.configuration = configuration
+        self.connection_pool = create_pool_from_configuration(configuration)
+        self._closed = False
+
+    def close(self) -> None:
+        """关闭工厂拥有的共享连接池。"""
+        if self._closed:
+            return
+        self.connection_pool.close()
+        self._closed = True
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+        return False

spring/orm/pymybatis/dialect/__init__.py

@@ -0,0 +1,9 @@
+"""
+PyMyBatis数据库方言模块
+
+支持MySQL、PostgreSQL、SQLite、Oracle等数据库的SQL方言适配
+"""
+
+from .dialect import Dialect, MySQLDialect, PostgreSQLDialect, SQLiteDialect, OracleDialect, get_dialect
+
+__all__ = ['Dialect', 'MySQLDialect', 'PostgreSQLDialect', 'SQLiteDialect', 'OracleDialect', 'get_dialect']

spring/orm/pymybatis/dialect/dialect.py

@@ -0,0 +1,445 @@
+"""
+PyMyBatis数据库方言模块
+
+定义各数据库的SQL语法差异，实现SQL方言适配
+"""
+
+from abc import ABC, abstractmethod
+from typing import Optional, List, Tuple
+
+
+class Dialect(ABC):
+    """
+    数据库方言抽象基类
+
+    定义各数据库特有的SQL语法：
+    - 分页查询
+    - 主键自增
+    - 批量插入
+    - 特殊函数
+    """
+
+    @abstractmethod
+    def get_dialect_name(self) -> str:
+        """获取方言名称"""
+        pass
+
+    @abstractmethod
+    def get_pagination_sql(self, sql: str, offset: int, limit: int) -> str:
+        """
+        获取分页SQL
+
+        Args:
+            sql: 原始SQL
+            offset: 偏移量
+            limit: 每页条数
+
+        Returns:
+            分页SQL
+        """
+        pass
+
+    @abstractmethod
+    def get_insert_returning_sql(self, sql: str, key_column: str) -> str:
+        """
+        获取插入并返回主键的SQL
+
+        Args:
+            sql: 原始INSERT SQL
+            key_column: 主键列名
+
+        Returns:
+            返回主键的INSERT SQL
+        """
+        pass
+
+    @abstractmethod
+    def get_batch_insert_sql(self, table_name: str, columns: List[str], values: List[Tuple]) -> str:
+        """
+        获取批量插入SQL
+
+        Args:
+            table_name: 表名
+            columns: 列名列表
+            values: 值列表
+
+        Returns:
+            批量插入SQL
+        """
+        pass
+
+    @abstractmethod
+    def get_batch_update_sql(self, table_name: str, columns: List[str], values: List[Tuple], pk_column: str) -> str:
+        """
+        获取批量更新SQL
+
+        Args:
+            table_name: 表名
+            columns: 列名列表（不含主键）
+            values: 值列表（每条记录包含主键和更新值）
+            pk_column: 主键列名
+
+        Returns:
+            批量更新SQL
+        """
+        pass
+
+    @abstractmethod
+    def get_identity_query(self) -> str:
+        """获取获取自增主键的SQL"""
+        pass
+
+    @abstractmethod
+    def get_now_function(self) -> str:
+        """获取当前时间函数"""
+        pass
+
+    @abstractmethod
+    def get_concat_function(self, args: List[str]) -> str:
+        """获取字符串拼接函数"""
+        pass
+
+    @abstractmethod
+    def get_substring_function(self, column: str, start: int, length: Optional[int] = None) -> str:
+        """获取子字符串函数"""
+        pass
+
+    @abstractmethod
+    def get_length_function(self, column: str) -> str:
+        """获取长度函数"""
+        pass
+
+    @abstractmethod
+    def supports_limit_offset(self) -> bool:
+        """是否支持LIMIT OFFSET语法"""
+        pass
+
+    @abstractmethod
+    def supports_batch_insert(self) -> bool:
+        """是否支持批量插入"""
+        pass
+
+    @abstractmethod
+    def get_quote_char(self) -> str:
+        """获取标识符引用字符"""
+        pass
+
+    def quote_identifier(self, identifier: str) -> str:
+        """
+        引用标识符（表名、列名等）
+
+        Args:
+            identifier: 标识符
+
+        Returns:
+            带引号的标识符
+        """
+        quote = self.get_quote_char()
+        return f"{quote}{identifier}{quote}"
+
+
+class MySQLDialect(Dialect):
+    """MySQL数据库方言"""
+
+    def get_dialect_name(self) -> str:
+        return 'mysql'
+
+    def get_pagination_sql(self, sql: str, offset: int, limit: int) -> str:
+        return f"{sql} LIMIT {limit} OFFSET {offset}"
+
+    def get_insert_returning_sql(self, sql: str, key_column: str) -> str:
+        return sql
+
+    def get_batch_insert_sql(self, table_name: str, columns: List[str], values: List[Tuple]) -> str:
+        columns_str = ', '.join(self.quote_identifier(c) for c in columns)
+        values_str = ', '.join(
+            f"({', '.join('%s' for _ in row)})" for row in values
+        )
+        return f"INSERT INTO {self.quote_identifier(table_name)} ({columns_str}) VALUES {values_str}"
+
+    def get_batch_update_sql(self, table_name: str, columns: List[str], values: List[Tuple], pk_column: str) -> str:
+        # MySQL批量更新使用CASE WHEN
+        set_parts = []
+        for col in columns:
+            when_parts = []
+            for _ in values:
+                when_parts.append(f"WHEN {pk_column} = %s THEN %s")
+            set_parts.append(f"{self.quote_identifier(col)} = CASE {pk_column} {' '.join(when_parts)} END")
+
+        set_str = ', '.join(set_parts)
+        pk_values = [row[0] for row in values]
+        where_str = f"{pk_column} IN ({', '.join('%s' for _ in pk_values)})"
+
+        return f"UPDATE {self.quote_identifier(table_name)} SET {set_str} WHERE {where_str}"
+
+    def get_identity_query(self) -> str:
+        return "SELECT LAST_INSERT_ID()"
+
+    def get_now_function(self) -> str:
+        return "NOW()"
+
+    def get_concat_function(self, args: List[str]) -> str:
+        return ' CONCAT(' + ', '.join(args) + ')'
+
+    def get_substring_function(self, column: str, start: int, length: Optional[int] = None) -> str:
+        if length:
+            return f"SUBSTRING({column}, {start}, {length})"
+        return f"SUBSTRING({column}, {start})"
+
+    def get_length_function(self, column: str) -> str:
+        return f"LENGTH({column})"
+
+    def supports_limit_offset(self) -> bool:
+        return True
+
+    def supports_batch_insert(self) -> bool:
+        return True
+
+    def get_quote_char(self) -> str:
+        return '`'
+
+
+class PostgreSQLDialect(Dialect):
+    """PostgreSQL数据库方言"""
+
+    def get_dialect_name(self) -> str:
+        return 'postgresql'
+
+    def get_pagination_sql(self, sql: str, offset: int, limit: int) -> str:
+        return f"{sql} LIMIT {limit} OFFSET {offset}"
+
+    def get_insert_returning_sql(self, sql: str, key_column: str) -> str:
+        return f"{sql} RETURNING {self.quote_identifier(key_column)}"
+
+    def get_batch_insert_sql(self, table_name: str, columns: List[str], values: List[Tuple]) -> str:
+        columns_str = ', '.join(self.quote_identifier(c) for c in columns)
+        values_str = ', '.join(
+            f"({', '.join('%s' for _ in row)})" for row in values
+        )
+        return f"INSERT INTO {self.quote_identifier(table_name)} ({columns_str}) VALUES {values_str}"
+
+    def get_batch_update_sql(self, table_name: str, columns: List[str], values: List[Tuple], pk_column: str) -> str:
+        # PostgreSQL批量更新使用FROM子句
+        set_parts = []
+        for col in columns:
+            set_parts.append(f"{self.quote_identifier(col)} = updates.{self.quote_identifier(col)}")
+
+        set_str = ', '.join(set_parts)
+
+        # 构建VALUES子句作为临时表
+        columns_with_pk = [pk_column] + columns
+        values_str = ', '.join(
+            f"({', '.join('%s' for _ in row)})" for row in values
+        )
+
+        return f"""
+            UPDATE {self.quote_identifier(table_name)}
+            SET {set_str}
+            FROM (VALUES {values_str}) AS updates({', '.join(self.quote_identifier(c) for c in columns_with_pk)})
+            WHERE {self.quote_identifier(table_name)}.{self.quote_identifier(pk_column)} = updates.{self.quote_identifier(pk_column)}
+        """
+
+    def get_identity_query(self) -> str:
+        return "SELECT LASTVAL()"
+
+    def get_now_function(self) -> str:
+        return "NOW()"
+
+    def get_concat_function(self, args: List[str]) -> str:
+        return ' || '.join(args)
+
+    def get_substring_function(self, column: str, start: int, length: Optional[int] = None) -> str:
+        if length:
+            return f"SUBSTRING({column} FROM {start} FOR {length})"
+        return f"SUBSTRING({column} FROM {start})"
+
+    def get_length_function(self, column: str) -> str:
+        return f"LENGTH({column})"
+
+    def supports_limit_offset(self) -> bool:
+        return True
+
+    def supports_batch_insert(self) -> bool:
+        return True
+
+    def get_quote_char(self) -> str:
+        return '"'
+
+
+class SQLiteDialect(Dialect):
+    """SQLite数据库方言"""
+
+    def get_dialect_name(self) -> str:
+        return 'sqlite'
+
+    def get_pagination_sql(self, sql: str, offset: int, limit: int) -> str:
+        return f"{sql} LIMIT {limit} OFFSET {offset}"
+
+    def get_insert_returning_sql(self, sql: str, key_column: str) -> str:
+        return sql
+
+    def get_batch_insert_sql(self, table_name: str, columns: List[str], values: List[Tuple]) -> str:
+        columns_str = ', '.join(self.quote_identifier(c) for c in columns)
+        values_str = ', '.join(
+            f"({', '.join('?' for _ in row)})" for row in values
+        )
+        return f"INSERT INTO {self.quote_identifier(table_name)} ({columns_str}) VALUES {values_str}"
+
+    def get_batch_update_sql(self, table_name: str, columns: List[str], values: List[Tuple], pk_column: str) -> str:
+        # SQLite批量更新使用CASE WHEN
+        set_parts = []
+        for col in columns:
+            when_parts = []
+            for i, row in enumerate(values):
+                when_parts.append(f"WHEN {pk_column} = ? THEN ?")
+            set_parts.append(f"{self.quote_identifier(col)} = CASE {pk_column} {' '.join(when_parts)} END")
+
+        set_str = ', '.join(set_parts)
+        pk_values = [row[0] for row in values]
+        where_str = f"{pk_column} IN ({', '.join('?' for _ in pk_values)})"
+
+        return f"UPDATE {self.quote_identifier(table_name)} SET {set_str} WHERE {where_str}"
+
+    def get_identity_query(self) -> str:
+        return "SELECT LAST_INSERT_ROWID()"
+
+    def get_now_function(self) -> str:
+        return "datetime('now')"
+
+    def get_concat_function(self, args: List[str]) -> str:
+        return ' || '.join(args)
+
+    def get_substring_function(self, column: str, start: int, length: Optional[int] = None) -> str:
+        if length:
+            return f"SUBSTR({column}, {start}, {length})"
+        return f"SUBSTR({column}, {start})"
+
+    def get_length_function(self, column: str) -> str:
+        return f"LENGTH({column})"
+
+    def supports_limit_offset(self) -> bool:
+        return True
+
+    def supports_batch_insert(self) -> bool:
+        return True
+
+    def get_quote_char(self) -> str:
+        return '"'
+
+
+class OracleDialect(Dialect):
+    """Oracle数据库方言"""
+
+    def get_dialect_name(self) -> str:
+        return 'oracle'
+
+    def get_pagination_sql(self, sql: str, offset: int, limit: int) -> str:
+        # Oracle使用ROWNUM进行分页
+        offset_val = offset + 1
+        return f"""
+            SELECT * FROM (
+                SELECT t.*, ROWNUM rn FROM (
+                    {sql}
+                ) t WHERE ROWNUM <= {offset + limit}
+            ) WHERE rn >= {offset_val}
+        """
+
+    def get_insert_returning_sql(self, sql: str, key_column: str) -> str:
+        return f"{sql} RETURNING {self.quote_identifier(key_column)} INTO :id"
+
+    def get_batch_insert_sql(self, table_name: str, columns: List[str], values: List[Tuple]) -> str:
+        # Oracle批量插入使用UNION ALL
+        columns_str = ', '.join(self.quote_identifier(c) for c in columns)
+        values_parts = []
+        for i, row in enumerate(values):
+            row_values = []
+            for j, _ in enumerate(row):
+                row_values.append(f":{i * len(row) + j + 1}")
+            values_parts.append(f"SELECT {', '.join(row_values)} FROM DUAL")
+
+        values_str = ' UNION ALL '.join(values_parts)
+        return f"INSERT INTO {self.quote_identifier(table_name)} ({columns_str}) {values_str}"
+
+    def get_batch_update_sql(self, table_name: str, columns: List[str], values: List[Tuple], pk_column: str) -> str:
+        # Oracle批量更新使用MERGE语句
+        columns_with_pk = [pk_column] + columns
+
+        # 构建VALUES子句
+        values_parts = []
+        param_index = 1
+        for row in values:
+            row_values = []
+            for _ in row:
+                row_values.append(f":{param_index}")
+                param_index += 1
+            values_parts.append(f"({', '.join(row_values)})")
+
+        values_str = ' UNION ALL '.join(
+            f"SELECT {', '.join(values_parts[i])} FROM DUAL" for i in range(len(values_parts))
+        )
+
+        # 构建SET子句
+        set_parts = []
+        for col in columns:
+            set_parts.append(f"{self.quote_identifier(col)} = source.{self.quote_identifier(col)}")
+        set_str = ', '.join(set_parts)
+
+        return f"""
+            MERGE INTO {self.quote_identifier(table_name)} target
+            USING (SELECT {', '.join(self.quote_identifier(c) for c in columns_with_pk)} FROM ({values_str})) source
+            ON (target.{self.quote_identifier(pk_column)} = source.{self.quote_identifier(pk_column)})
+            WHEN MATCHED THEN UPDATE SET {set_str}
+        """
+
+    def get_identity_query(self) -> str:
+        return "SELECT SEQ_CURRVAL FROM DUAL"
+
+    def get_now_function(self) -> str:
+        return "SYSDATE"
+
+    def get_concat_function(self, args: List[str]) -> str:
+        return ' || '.join(args)
+
+    def get_substring_function(self, column: str, start: int, length: Optional[int] = None) -> str:
+        if length:
+            return f"SUBSTR({column}, {start}, {length})"
+        return f"SUBSTR({column}, {start})"
+
+    def get_length_function(self, column: str) -> str:
+        return f"LENGTH({column})"
+
+    def supports_limit_offset(self) -> bool:
+        return False
+
+    def supports_batch_insert(self) -> bool:
+        return True
+
+    def get_quote_char(self) -> str:
+        return '"'
+
+
+def get_dialect(dialect_name: str) -> Dialect:
+    """
+    根据方言名称获取方言实例
+
+    Args:
+        dialect_name: 方言名称（mysql/postgresql/sqlite/oracle）
+
+    Returns:
+        方言实例
+
+    Raises:
+        ValueError: 不支持的方言
+    """
+    dialect_map = {
+        'mysql': MySQLDialect(),
+        'postgresql': PostgreSQLDialect(),
+        'sqlite': SQLiteDialect(),
+        'oracle': OracleDialect()
+    }
+
+    dialect = dialect_map.get(dialect_name.lower())
+    if not dialect:
+        raise ValueError(f"不支持的数据库方言: {dialect_name}")
+
+    return dialect

spring/orm/pymybatis/dynamic_sql/__init__.py

@@ -0,0 +1,9 @@
+"""
+PyMyBatis动态SQL模块
+
+处理if、where、foreach等动态SQL标签
+"""
+
+from .dynamic_sql import DynamicSQLProcessor, SecurityError
+
+__all__ = ['DynamicSQLProcessor', 'SecurityError']