mongo-2-sql 0.1.4__tar.gz → 0.1.5__tar.gz

{mongo_2_sql-0.1.4 → mongo_2_sql-0.1.5}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Bao Bingbo
+Copyright (c) 2026 baobingbo
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

{mongo_2_sql-0.1.4/src/mongo_2_sql.egg-info → mongo_2_sql-0.1.5}/PKG-INFO

@@ -1,9 +1,13 @@
 Metadata-Version: 2.4
 Name: mongo-2-sql
-Version: 0.1.4
+Version: 0.1.5
 Summary: A library to convert MongoDB aggregation pipelines to SQL parser
 Author-email: Bao Bingbo <baob2@outlook.com>
 License: MIT License
+Project-URL: Homepage, https://github.com/baobingbo/mongo-2-sql
+Project-URL: Documentation, https://github.com/baobingbo/mongo-2-sql#readme
+Project-URL: Repository, https://github.com/baobingbo/mongo-2-sql.git
+Project-URL: Issues, https://github.com/baobingbo/mongo-2-sql/issues
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -24,42 +28,21 @@ Dynamic: license-file
 
 Mongo to SQL 是一个将 MongoDB 聚合管道转换为 SQL 查询语句的工具。
 
-## 版本更新 v0.1.4
+## 项目仓库
 
-### 新增功能
-
-#### 1. CTE（公用表表达式）统一处理
-- **$addFields、$project、$group 阶段现在使用 CTE 方式处理**
-- 将复杂的聚合管道拆分为多个SQL片段，使用 WITH 子句拼接
-- 自动管理 CTE 命名和依赖关系
-- 适用于多次投影、多层分组等复杂场景
-
-#### 2. 表达式解析器统一架构
-- **ExpressionResolver**: 统一的表达式解析器入口，避免 stage 之间相互 import
-- **BaseExpressionParser**: 基础表达式解析器基类，减少代码重复
-- 提供通用操作符集合、字段引用解析、值转换等基础功能
-
-#### 3. SQL 格式化输出
-- 使用 sqlparse 库自动格式化 SQL
-- SELECT、FROM、WHERE、GROUP BY 等关键字独占一行
-- 字段列表缩进对齐，提高可读性
-- WHERE 子句添加注释提示可扩展性
-
-#### 4. Project 阶段增强
-- 支持字段重命名语法: `{"new_name": "$old_name"}`
-- 聚合后字段引用自动处理（无需添加表前缀）
-- 支持包含模式和排除模式
+- **GitHub**: [baobingbo/mongo-2-sql](https://github.com/baobingbo/mongo-2-sql)
 
-#### 5. Stage 解耦架构
-- 各 stage 表达式解析器通过统一的 ExpressionResolver 进行交互
-- 避免模块之间的循环依赖
-- 更易于扩展和维护
+## 版本更新 v0.1.5
 
-### 问题修复
+### 新增功能
 
-- **修复 `_id` 字段双引号问题**: 不再使用 `"_id"`，改为 `_id`
-- **修复聚合后字段引用**: 聚合后的字段不再错误添加表前缀
-- **修复模块导入路径**: 统一使用相对导入，避免 "attempted relative import beyond top-level package" 错误
+#### 1. $addFields 阶段表达式与字面量语义
+- `$addFields` 使用独立的 `AddFieldsExpressionParser`，不再复用 `$project` 的解析逻辑，避免跨阶段耦合
+- `$addFields` 支持三类值：
+  - **字面量值**: 如 `{"score": 1}`, `{ "flag": true }`, `{ "text": "hello" }`，会直接转换为 `1 AS score`、`TRUE AS flag`、`'hello' AS text`
+  - **字段引用**: 如 `{ "cat": "$category" }`，会转换为 `t.category AS cat`
+  - **表达式**: 如 `{ "total": { "$add": [1, "$price"] } }` 或 `{ "isBig": { "$gt": ["$amount", 100] } }`
+- **仅 `$project` 阶段中**，`{"field": 1}` / `{"field": 0}` 仍然表示“包含/排除字段”；其他阶段（包括 `$addFields`）中，`1` 始终被视为字面量数值 1
 
 ## 功能特性
 
@@ -583,6 +566,13 @@ MIT License - 详见 [LICENSE](LICENSE) 文件
 
 ## 变更日志
 
+### v0.1.5 (2025-02-23)
+
+**新增功能:**
+- addFields阶段独立解析器（AddFieldsExpressionParser），与 project 解耦
+- 支持字面量值、字段引用、表达式三类语义
+- 统一数值 1 为字面量（仅 $project 阶段保留包含/排除语义）
+
 ### v0.1.4 (2025-02-13)
 
 **新增功能:**

{mongo_2_sql-0.1.4 → mongo_2_sql-0.1.5}/README.md

@@ -2,42 +2,21 @@
 
 Mongo to SQL 是一个将 MongoDB 聚合管道转换为 SQL 查询语句的工具。
 
-## 版本更新 v0.1.4
+## 项目仓库
 
-### 新增功能
-
-#### 1. CTE（公用表表达式）统一处理
-- **$addFields、$project、$group 阶段现在使用 CTE 方式处理**
-- 将复杂的聚合管道拆分为多个SQL片段，使用 WITH 子句拼接
-- 自动管理 CTE 命名和依赖关系
-- 适用于多次投影、多层分组等复杂场景
-
-#### 2. 表达式解析器统一架构
-- **ExpressionResolver**: 统一的表达式解析器入口，避免 stage 之间相互 import
-- **BaseExpressionParser**: 基础表达式解析器基类，减少代码重复
-- 提供通用操作符集合、字段引用解析、值转换等基础功能
-
-#### 3. SQL 格式化输出
-- 使用 sqlparse 库自动格式化 SQL
-- SELECT、FROM、WHERE、GROUP BY 等关键字独占一行
-- 字段列表缩进对齐，提高可读性
-- WHERE 子句添加注释提示可扩展性
-
-#### 4. Project 阶段增强
-- 支持字段重命名语法: `{"new_name": "$old_name"}`
-- 聚合后字段引用自动处理（无需添加表前缀）
-- 支持包含模式和排除模式
+- **GitHub**: [baobingbo/mongo-2-sql](https://github.com/baobingbo/mongo-2-sql)
 
-#### 5. Stage 解耦架构
-- 各 stage 表达式解析器通过统一的 ExpressionResolver 进行交互
-- 避免模块之间的循环依赖
-- 更易于扩展和维护
+## 版本更新 v0.1.5
 
-### 问题修复
+### 新增功能
 
-- **修复 `_id` 字段双引号问题**: 不再使用 `"_id"`，改为 `_id`
-- **修复聚合后字段引用**: 聚合后的字段不再错误添加表前缀
-- **修复模块导入路径**: 统一使用相对导入，避免 "attempted relative import beyond top-level package" 错误
+#### 1. $addFields 阶段表达式与字面量语义
+- `$addFields` 使用独立的 `AddFieldsExpressionParser`，不再复用 `$project` 的解析逻辑，避免跨阶段耦合
+- `$addFields` 支持三类值：
+  - **字面量值**: 如 `{"score": 1}`, `{ "flag": true }`, `{ "text": "hello" }`，会直接转换为 `1 AS score`、`TRUE AS flag`、`'hello' AS text`
+  - **字段引用**: 如 `{ "cat": "$category" }`，会转换为 `t.category AS cat`
+  - **表达式**: 如 `{ "total": { "$add": [1, "$price"] } }` 或 `{ "isBig": { "$gt": ["$amount", 100] } }`
+- **仅 `$project` 阶段中**，`{"field": 1}` / `{"field": 0}` 仍然表示“包含/排除字段”；其他阶段（包括 `$addFields`）中，`1` 始终被视为字面量数值 1
 
 ## 功能特性
 
@@ -561,6 +540,13 @@ MIT License - 详见 [LICENSE](LICENSE) 文件
 
 ## 变更日志
 
+### v0.1.5 (2025-02-23)
+
+**新增功能:**
+- addFields阶段独立解析器（AddFieldsExpressionParser），与 project 解耦
+- 支持字面量值、字段引用、表达式三类语义
+- 统一数值 1 为字面量（仅 $project 阶段保留包含/排除语义）
+
 ### v0.1.4 (2025-02-13)
 
 **新增功能:**

{mongo_2_sql-0.1.4 → mongo_2_sql-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mongo-2-sql"
-version = "0.1.4"
+version = "0.1.5"
 description = "A library to convert MongoDB aggregation pipelines to SQL parser"
 readme = "README.md"
 license = {text = "MIT License"}
@@ -28,6 +28,12 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Python Modules",
 ]
 
+[project.urls]
+Homepage = "https://github.com/baobingbo/mongo-2-sql"
+Documentation = "https://github.com/baobingbo/mongo-2-sql#readme"
+Repository = "https://github.com/baobingbo/mongo-2-sql.git"
+Issues = "https://github.com/baobingbo/mongo-2-sql/issues"
+
 # 配置 setuptools 特定的行为
 [tool.setuptools]
 package-dir = {"" = "src"} 

{mongo_2_sql-0.1.4 → mongo_2_sql-0.1.5}/src/mongo_2_sql/core/expr_parser_base.py

@@ -50,6 +50,11 @@ class BaseExpressionParser:
         '$concat', '$substr', '$toLower', '$toUpper', '$trim'
     }
     
+    # 日期操作符
+    DATE_OPERATORS: Set[str] = {
+        '$year', '$month', '$dayOfMonth', '$hour', '$minute', '$second', '$dateToString'
+    }
+    
     # 条件操作符
     CONDITIONAL_OPERATORS: Set[str] = {
         '$cond', '$ifNull', '$switch'

{mongo_2_sql-0.1.4 → mongo_2_sql-0.1.5}/src/mongo_2_sql/core/stage_base.py

@@ -197,7 +197,6 @@ class RenderContext:
         
         # CTE - 使用新的 CTE 管理器
         with_clause = self.cte_manager.build_with_clause()
-        print(with_clause)
         if with_clause:
             parts.append(with_clause)
         

{mongo_2_sql-0.1.4 → mongo_2_sql-0.1.5}/src/mongo_2_sql/main.py

@@ -261,7 +261,7 @@ def main() -> int:
     try:
         # 加载管道
         pipeline = load_pipeline(args)
-        
+        print(pipeline)
         # 转换
         sql, metadata = convert_mongo_pipeline_to_sql(
             pipeline=pipeline,

mongo_2_sql-0.1.5/src/mongo_2_sql/stages/add_fields/expr.py

@@ -0,0 +1,220 @@
+"""
+Add Fields Expression Parser Module
+
+解析 MongoDB $addFields 阶段的表达式。
+"""
+
+from typing import Any, Dict, List, Optional
+
+from ...core.expr_parser_base import BaseExpressionParser
+from ...core.expr_base import (
+    BaseExpression,
+    BinaryOperation,
+    FieldReference,
+    FunctionCall,
+    LiteralValue,
+)
+from ...core.expr_registry import ExpressionRegistry
+from ...core.stage_base import RenderContext
+
+
+class AddFieldsExpressionParser(BaseExpressionParser):
+    """
+    Add Fields 表达式解析器。
+    
+    将 MongoDB $addFields 表达式解析为 SQL 计算字段。
+    专门用于处理 $addFields 阶段，不使用 $project 的包含/排除逻辑。
+    """
+    
+    @classmethod
+    def parse(cls, add_fields_spec: Dict[str, Any], context: RenderContext) -> List[str]:
+        """
+        解析 $addFields 规范并生成 SQL SELECT 列。
+        
+        Args:
+            add_fields_spec: MongoDB $addFields 规范
+            context: 渲染上下文
+            
+        Returns:
+            SQL SELECT 列列表
+        """
+        columns = []
+        
+        for field_name, field_value in add_fields_spec.items():
+            if isinstance(field_value, dict):
+                # 表达式：{"field": {"$add": ["$price", "$tax"]}}
+                column = cls._parse_expression_projection(field_name, field_value, context)
+                if column:
+                    columns.append(column)
+            elif isinstance(field_value, str) and field_value.startswith('$'):
+                # 字段引用：{"new_field": "$old_field"}
+                column = cls._parse_field_rename(field_name, field_value, context)
+                if column:
+                    columns.append(column)
+            else:
+                # 字面量值：{"field": 1} 或 {"field": "value"}
+                column = cls._parse_literal_value(field_name, field_value, context)
+                if column:
+                    columns.append(column)
+        
+        return columns
+    
+    @classmethod
+    def _parse_expression_projection(cls, alias: str, expr: Dict[str, Any], context: RenderContext) -> Optional[str]:
+        """
+        解析表达式投影。
+        
+        Args:
+            alias: 输出字段别名
+            expr: 表达式字典
+            context: 渲染上下文
+            
+        Returns:
+            SQL 列表达式，或 None
+        """
+        if not expr:
+            return None
+        
+        # 获取操作符
+        operators = list(expr.keys())
+        if len(operators) != 1:
+            return None
+        
+        op = operators[0]
+        value = expr[op]
+        
+        # 解析表达式
+        sql_expr = cls._parse_expression_value(op, value, context)
+        
+        if sql_expr:
+            return f"{sql_expr} AS {alias}"
+        
+        return None
+    
+    @classmethod
+    def _parse_field_rename(cls, alias: str, field_ref: str, context: RenderContext) -> Optional[str]:
+        """
+        解析字段重命名投影。
+        
+        Args:
+            alias: 新字段名
+            field_ref: 字段引用（如 "$old_name"）
+            context: 渲染上下文
+            
+        Returns:
+            SQL 列表达式，或 None
+        """
+        if not field_ref.startswith('$'):
+            return None
+            
+        # 提取字段名
+        field_name = field_ref[1:]  # 移除开头的 $
+        
+        # 添加表前缀
+        table_alias = context.from_alias or 't'
+        return f"{table_alias}.{field_name} AS {alias}"
+    
+    @classmethod
+    def _parse_literal_value(cls, alias: str, value: Any, context: RenderContext) -> Optional[str]:
+        """
+        解析字面量值投影。
+        
+        Args:
+            alias: 输出字段别名
+            value: 字面量值
+            context: 渲染上下文
+            
+        Returns:
+            SQL 列表达式，或 None
+        """
+        sql_literal = cls._value_to_sql(value)
+        return f"{sql_literal} AS {alias}"
+    
+    @classmethod
+    def _parse_arithmetic_operator(cls, operator: str, value: Any, context: RenderContext) -> Optional[str]:
+        """解析算术操作符，返回布尔表达式"""
+        op_map = {
+            '$add': '+',
+            '$subtract': '-',
+            '$multiply': '*',
+            '$divide': '/',
+            '$mod': '%',
+        }
+        
+        sql_op = op_map.get(operator)
+        if sql_op is None:
+            return None
+        
+        if not isinstance(value, list) or len(value) < 2:
+            return None
+        
+        operands = []
+        for item in value:
+            if isinstance(item, str) and item.startswith('$'):
+                field = item[1:]
+                table_alias = context.from_alias or 't'
+                operands.append(f'{table_alias}.{field}')
+            else:
+                operands.append(cls._value_to_sql(item))
+        
+        return f"({f' {sql_op} '.join(operands)})"
+    
+    @classmethod 
+    def _parse_comparison_operator(cls, operator: str, value: Any, context: RenderContext) -> Optional[str]:
+        """解析比较操作符，返回布尔表达式"""
+        if not isinstance(value, list) or len(value) != 2:
+            return None
+            
+        op_map = {
+            '$eq': '=',
+            '$ne': '!=',
+            '$gt': '>',
+            '$gte': '>=',
+            '$lt': '<',
+            '$lte': '<=',
+        }
+        
+        sql_op = op_map.get(operator)
+        if sql_op is None:
+            return None
+        
+        def parse_operand(operand):
+            if isinstance(operand, str) and operand.startswith('$'):
+                field = operand[1:]
+                table_alias = context.from_alias or 't'
+                return f'{table_alias}.{field}'
+            else:
+                return cls._value_to_sql(operand)
+        
+        left = parse_operand(value[0])
+        right = parse_operand(value[1])
+        
+        return f"({left} {sql_op} {right})"
+    
+    @classmethod
+    def _parse_expression_value(cls, operator: str, value: Any, context: RenderContext) -> Optional[str]:
+        """
+        解析表达式值。
+        
+        Args:
+            operator: 操作符
+            value: 操作数值
+            context: 渲染上下文
+            
+        Returns:
+            SQL 表达式，或 None
+        """
+        # 字面量
+        if operator == '$literal':
+            return cls._value_to_sql(value)
+        
+        # 算术操作符 - 使用专门的处理逻辑
+        if operator in cls.ARITHMETIC_OPERATORS:
+            return cls._parse_arithmetic_operator(operator, value, context)
+        
+        # 比较操作符 - 使用专门的处理逻辑  
+        if operator in cls.COMPARISON_OPERATORS:
+            return cls._parse_comparison_operator(operator, value, context)
+        
+        return None
+    

{mongo_2_sql-0.1.4 → mongo_2_sql-0.1.5}/src/mongo_2_sql/stages/add_fields/stage.py

@@ -76,10 +76,10 @@ class AddFieldsStage(CTEStageProcessor):
         Returns:
             CTE SQL 内容
         """
-        from ...stages.project.expr import ProjectExpressionParser
+        from ...stages.add_fields.expr import AddFieldsExpressionParser
         
         # 解析添加的字段表达式
-        columns = ProjectExpressionParser.parse(stage_value, context, is_post_aggregation=False)
+        columns = AddFieldsExpressionParser.parse(stage_value, context)
         
         # 构建 CTE 的 SELECT 子句
         select_parts = []

{mongo_2_sql-0.1.4 → mongo_2_sql-0.1.5}/src/mongo_2_sql/stages/group/expr.py

@@ -18,13 +18,6 @@ class GroupExpressionParser(BaseExpressionParser):
     将 MongoDB $group 表达式解析为 SQL GROUP BY 和聚合函数。
     """
     
-    # 累加器操作符
-    ACCUMULATORS = {
-        '$sum', '$avg', '$min', '$max', '$count',
-        '$first', '$last', '$push', '$addToSet',
-        '$stdDevPop', '$stdDevSamp'
-    }
-    
     @classmethod
     def parse(cls, group_spec: Dict[str, Any], context: RenderContext) -> Tuple[List[str], List[str], List[str]]:
         """

{mongo_2_sql-0.1.4 → mongo_2_sql-0.1.5}/src/mongo_2_sql/stages/project/expr.py

@@ -25,27 +25,6 @@ class ProjectExpressionParser(BaseExpressionParser):
     将 MongoDB 投影表达式解析为 SQL SELECT 列。
     """
     
-    # 算术操作符
-    ARITHMETIC_OPERATORS = {'$add', '$subtract', '$multiply', '$divide', '$mod'}
-    
-    # 字符串操作符
-    STRING_OPERATORS = {'$concat', '$substr', '$toLower', '$toUpper', '$trim'}
-    
-    # 日期操作符
-    DATE_OPERATORS = {'$year', '$month', '$dayOfMonth', '$hour', '$minute', '$second', '$dateToString'}
-    
-    # 条件操作符
-    CONDITIONAL_OPERATORS = {'$cond', '$ifNull', '$switch'}
-    
-    # 比较操作符
-    COMPARISON_OPERATORS = {'$eq', '$ne', '$gt', '$gte', '$lt', '$lte', '$in', '$nin'}
-    
-    # 数组操作符
-    ARRAY_OPERATORS = {'$size', '$slice', '$arrayElemAt'}
-    
-    # 字面量操作符
-    LITERAL_OPERATOR = '$literal'
-    
     @classmethod
     def parse(cls, projection: Dict[str, Any], context: RenderContext, is_post_aggregation: bool = False) -> List[str]:
         """
@@ -104,6 +83,11 @@ class ProjectExpressionParser(BaseExpressionParser):
                     column = cls._parse_field_rename(field, value, context, is_post_aggregation)
                     if column:
                         columns.append(column)
+                else:
+                    # 字面量值（用于 $addFields）：{"field": "literal_value"}
+                    column = cls._parse_literal_value(field, value, context, is_post_aggregation)
+                    if column:
+                        columns.append(column)
             else:
                 # 排除模式：value = 0 表示排除字段
                 # 表达式投影在两种模式下都应该工作
@@ -119,6 +103,11 @@ class ProjectExpressionParser(BaseExpressionParser):
                     column = cls._parse_field_rename(field, value, context, is_post_aggregation)
                     if column:
                         columns.append(column)
+                else:
+                    # 字面量值（用于 $addFields）：{"field": "literal_value"}
+                    column = cls._parse_literal_value(field, value, context, is_post_aggregation)
+                    if column:
+                        columns.append(column)
         
         return columns
     
@@ -241,6 +230,46 @@ class ProjectExpressionParser(BaseExpressionParser):
             table_alias = context.from_alias or 't'
             return f"{table_alias}.{field_name} AS {alias}"
     
+    @classmethod
+    def _parse_literal_value(cls, alias: str, value: Any, context: RenderContext, is_post_aggregation: bool = False) -> Optional[str]:
+        """
+        解析字面量值投影（主要用于 $addFields）。
+        
+        Args:
+            alias: 输出字段别名
+            value: 字面量值
+            context: 渲染上下文
+            is_post_aggregation: 是否在聚合之后进行投影
+            
+        Returns:
+            SQL 列表达式，或 None
+        """
+        if value is None:
+            sql_literal = 'NULL'
+        elif isinstance(value, bool):
+            sql_literal = 'TRUE' if value else 'FALSE'
+        elif isinstance(value, (int, float)):
+            sql_literal = str(value)
+        elif isinstance(value, str):
+            escaped = value.replace("'", "''")
+            sql_literal = f"'{escaped}'"
+        elif isinstance(value, list):
+            import json
+            # 将数组转换为 JSON 字符串
+            json_str = json.dumps(value)
+            escaped = json_str.replace("'", "''")
+            sql_literal = f"'{escaped}'"
+        elif isinstance(value, dict):
+            import json
+            # 将字典转换为 JSON 字符串
+            json_str = json.dumps(value)
+            escaped = json_str.replace("'", "''")
+            sql_literal = f"'{escaped}'"
+        else:
+            sql_literal = f"'{str(value)}'"
+        
+        return f"{sql_literal} AS {alias}"
+    
     @classmethod
     def _parse_expression_value(cls, operator: str, value: Any, context: RenderContext) -> Optional[str]:
         """
@@ -596,35 +625,6 @@ class ProjectExpressionParser(BaseExpressionParser):
         
         return cls._value_to_sql(value)
     
-    @classmethod
-    def _value_to_sql(cls, value: Any) -> str:
-        """
-        将值转换为 SQL 表示。
-        
-        Args:
-            value: 值
-            
-        Returns:
-            SQL 字面量
-        """
-        if value is None:
-            return 'NULL'
-        elif isinstance(value, bool):
-            return 'TRUE' if value else 'FALSE'
-        elif isinstance(value, (int, float)):
-            return str(value)
-        elif isinstance(value, str):
-            escaped = value.replace("'", "''")
-            return f"'{escaped}'"
-        elif isinstance(value, list):
-            items = [cls._value_to_sql(item) for item in value]
-            return f"({', '.join(items)})"
-        elif isinstance(value, dict):
-            import json
-            json_str = json.dumps(value)
-            escaped = json_str.replace("'", "''")
-            return f"'{escaped}'"
-        else:
-            return f"'{str(value)}'"
+
 
 

{mongo_2_sql-0.1.4 → mongo_2_sql-0.1.5}/src/mongo_2_sql/stages/project/stage.py

@@ -42,14 +42,9 @@ class ProjectStage(CTEStageProcessor):
         
         # 检查是否在聚合后进行投影
         is_post_aggregation = context.has_aggregation and len(context.group_by_columns) > 0
-        
-        # 对于会改变字段结构的 $project，使用 CTE
-        if self.should_use_cte(stage_value, context):
-            self.process_with_cte(stage_value, context, self.build_cte_sql)
-        else:
-            # 传统的处理方式
-            self._process_traditional(stage_value, context, is_post_aggregation)
-    
+
+        self.process_with_cte(stage_value, context, self.build_cte_sql)
+
     def should_use_cte(self, stage_value: Any, context: RenderContext) -> bool:
         """
         判断是否应该使用 CTE 来处理此 $project 阶段。