oGRAC兼容性框架

1. 总体架构设计

1.1 设计目标

兼容性框架的核心目标是实现多兼容性数据库的独立开发和解耦，同时确保高性能和低开销。具体目标包括：

• 语法兼容：支持不同的SQL语法（如A、B、C等多种方言）。
• 函数与操作符兼容：各兼容性模式拥有独立的函数和操作符体系。
• 类型系统兼容：类型表示和转换规则可按模式定制。
• 系统元数据兼容：系统表、视图等元数据按兼容性模式隔离。
• 性能零开销：在非跨兼容性操作中不引入额外开销。

1.2 架构模式

框架采用了一种“方言插件”架构，将每种兼容性模式视为一个插件（模块），数据库内核通过统一的接口与这些插件交互。这种架构的关键在于：

• 抽象接口层：定义了一系列接口（如语法解析、函数查找、类型转换等），每个兼容性模块实现这些接口。
• 核心路由层：根据当前数据库的兼容性模式，将请求路由到对应的模块实现。
• 模块注册机制：允许动态注册新的兼容性模块，支持扩展。

1.3 组件划分

框架主要由以下组件构成：

• 初始化组件：负责在数据库启动时根据配置加载对应的兼容性模块。
• 语法解析组件：包括词法分析和语法分析，支持多方言。
• 函数管理组件：管理各兼容性模式的函数注册、查找和调用。
• 类型系统组件：处理类型注册、类型转换和兼容性判断。
• 元数据管理组件：负责系统表、视图等元数据的按模式隔离。
• 优化器与执行器组件：在查询优化和执行阶段考虑兼容性特性。

2. 初始化与配置

2.1 配置读取

数据库兼容性模式可通过多种方式设置：

• 安装配置文件：在集群初始化配置文件（如install_config.json）中指定dbcompatibility参数。
• 数据库创建参数：使用CREATE DATABASE ... WITH dbcompatibility = 'A'语法。
• 运行时参数：支持会话级设置（如SET dbcompatibility TO 'B'），但注意某些设置可能仅允许在数据库创建时指定。

2.2 模块加载

初始化过程中，框架根据配置的兼容性模式加载对应的模块：

| | | | --- | --- | | 1 | // 伪代码：模块加载 | | 2 | CompatibilityModule* module = NULL; | | 3 | switch (compatibility_mode) { | | 4 | case MODE_A: | | 5 | module = load_module("dialect_a_module"); | | 6 | break; | | 7 | case MODE_B: | | 8 | module = load_module("dialect_b_module"); | | 9 | break; | | 10 | case MODE_C: | | 11 | module = load_module("dialect_c_module"); | | 12 | break; | | 13 | default: | | 14 | : | | 15 | // 处理错误 | | 16 | } | | 17 | // 注册模块接口 | | 18 | register_parser(module->parser); | | 19 | register_function_manager(module->func_manager); | | 20 | // ... 其他接口 |

2.3 资源隔离

为确保各模式互不干扰，框架为每个模块分配独立的资源：

• 内存上下文：各模块在自己的内存上下文中分配资源，便于管理和释放。
• 系统表空间：模式特定的系统表存储在独立的表空间中。
• 全局状态：各模块维护自己的全局状态，避免冲突。

3. 语法解析实现

3.1 词法分析（Lexer）

词法分析器通过条件编译和运行时状态支持多方言：

• 公共词法规则：定义在公共文件中（如scan.l），包含所有共享的关键词和规则。
• 方言特定规则：各模块提供自己的补充规则（如scan-dialect-rule.l），通过宏展开和条件编译嵌入到最终词法分析器中。
• 运行时切换：词法分析器根据当前会话的兼容性模式动态选择词法规则。

3.2 语法分析（Parser）

语法分析器采用类似技术：

• 基础语法规则：定义在gram.y中，包含共享的语法产生式。
• 方言特定产生式：各模块通过gram-dialect-rule.y提供额外的产生式。
• 冲突解决：通过优先级和结合性设置解决方言之间的冲突，确保语法解析无二义性。

3.3 抽象语法树（AST）转换

解析生成的AST可能需要根据兼容性模式进行转换：

• 统一AST表示：框架定义统一的AST节点结构，但某些节点可能包含兼容性特定信息。
• 方言特定转换：** 各模块可以实现AST转换函数，将方言特定的AST节点转换为公共表示，或反之。

4. 函数与操作符管理

4.1 函数注册

每个兼容性模块在初始化时注册自己的函数：

| | | | --- | --- | | 1 | // 伪代码：函数注册 | | 2 | void register_functions(CompatibilityModule* module) { | | 3 | for (int i = 0; i < module->num_functions; i++) { | | 4 | SysFuncDesc* func = &module->functions[i]; | | 5 | // 为函数分配OID，确保各模块的OID不冲突 | | 6 | func->oid = allocate_oid_for_module(module, func->name); | | 7 | // 注册到函数管理器中 | | 8 | register_function(func); | | 9 | } | | 10 | } |

4.2 函数查找

函数查找考虑兼容性模式：

• 优先查找方言特定函数：在当前兼容性模式的函数表中查找。
• 回退到公共函数：如果当前模式没有找到，则在公共函数表中查找。
• 重载解析：函数重载解析时，考虑参数类型和兼容性模式。

4.3 操作符处理

操作符本质上是函数的语法糖，处理方式类似：

• 操作符注册：各模块注册自己的操作符，包括优先级和结合性。
• 操作符转换：某些操作符可能需要转换成函数调用（如<=>操作符在B兼容模式中可能转换为特定函数）。

5. 类型系统

5.1 类型注册

各兼容性模块注册自己的类型：

• 类型OID分配：为确保唯一性，为每个模块分配一个OID范围。
• 类型元数据：包括类型名称、长度、对齐方式、输入/输出函数等。

5.2 类型转换

类型转换规则按兼容性模式定制：

• 转换规则注册：各模块注册自己的转换规则（如哪些类型之间可以隐式转换，哪些需要显式转换）。
• 转换路径查找：当需要类型转换时，框架在当前模式的转换规则中查找转换路径。
• 转换函数执行：找到转换路径后，调用对应的转换函数进行值转换。

6. 元数据管理

6.1 系统表

各兼容性模式可能有不同的系统表：

• 公共系统表：所有模式共享的系统表，如用户和权限管理。
• 模式特定系统表：如数据字典表，各模式有不同的结构。

6.2 系统视图

系统视图根据兼容性模式动态定义：

• 视图定义脚本：各模块提供自己的视图定义脚本。
• 视图创建：数据库初始化时，根据当前模式运行对应的脚本创建视图。

7. 查询处理与优化

7.1 查询解析

查询解析阶段使用当前兼容性模式的解析器，生成AST。

7.2 查询重写

查询重写阶段可能应用模式特定的重写规则。

7.3 优化与执行

优化器和执行器需要考虑兼容性模式：

• 成本模型：不同模式可能有不同的成本模型（如连接顺序选择）。
• 执行算子：某些模式可能支持特殊的执行算子。

8. 扩展性设计

8.1 模块注册

框架允许动态注册新的兼容性模块：

• 模块发现：通过配置文件或标准目录发现可用模块。
• 接口版本控制：确保模块与内核接口的兼容性。

8.2 热加载

支持在不重启数据库的情况下加载新的兼容性模块（但可能需要创建新的数据库才能使用）。

9. 性能优化

9.1 快速路径

对于性能关键路径（如函数调用），框架提供快速路径：

• 内联函数：对常用函数使用内联减少调用开销。
• 缓存：缓存查找结果（如函数查找、类型转换路径）。

9.2 懒加载

模块的某些部分可以按需加载，减少初始化时间和内存开销。

10. 总结

oGRAC兼容性框架通过插件化架构和精细的模块化设计，实现了多兼容性数据库的高效支持。其核心在于通过接口抽象和路由机制将兼容性模式与核心代码解耦，同时通过资源隔离和优化策略确保性能和稳定性。框架的扩展性设计为未来支持更多兼容性模式奠定了基础。

oGRAC 兼容性框架：架构设计与实现深度解析

一、框架架构设计理念

1.1 设计指导原则

oGRAC兼容性框架采用了一系列先进的设计原则来确保系统的灵活性、可扩展性和高性能：

• 最小化侵入性原则：框架设计确保对数据库核心代码的影响降到最低，核心代码无需感知兼容性框架的存在
• 性能零开销原则：兼容性判断和路由选择在编译期和运行时都尽可能高效，非跨兼容性操作不引入额外开销
• 扩展性原则：支持未来无缝添加新的兼容性模式而不影响现有功能，遵循开闭原则

1.2 核心架构模式

框架采用"方言即插件"(Dialect-as-Plugins)的架构理念，将每种兼容性模式视为可插拔组件：

| | | | --- | --- | | 1 | // 兼容性模块接口定义 | | 2 | typedef struct CompatibilityModule { | | 3 | const char* module_name; | | 4 | CompatibilityMode mode; | | 5 | InitFunction init_func; | | 6 | ParserInterface* parser_interface; | | 7 | FunctionManagerInterface* function_interface; | | 8 | TypeSystemInterface* type_interface; | | 9 | // ... 其他接口 | | 10 | } CompatibilityModule; |

这种设计使得系统核心保持稳定，而兼容性特定的实现则可以独立演化和扩展。内核通过定义良好的接口与各兼容性模块交互，实现了关注点的清晰分离。

1.3 层次化架构设计

框架采用四层架构设计，每层都有明确的职责边界：

1.3.1 接口层(Interface Layer)

定义统一的兼容性接口规范，包括：

| | | | --- | --- | | 1 | // 语法解析接口 | | 2 | typedef struct { | | 3 | ParseResult (*parse_query)(const char* query, CompatibilityMode mode); | | 4 | Node* (*transform_node)(Node* node, CompatibilityMode mode); | | 5 | bool (*is_reserved_keyword)(const char* word, CompatibilityMode mode); | | 6 | } ParserInterface; | | 7 | | | 8 | // 函数管理接口 | | 9 | typedef struct { | | 10 | FuncDesc* (*lookup_function)(const char* func_name, Oid* arg_types, int nargs); | | 11 | Oid (*get_func_oid)(const char* func_name, Oid* arg_types, int nargs); | | 12 | void (*register_function)(FuncDesc* func_desc); | | 13 | } FunctionManagerInterface; | | 14 | | | 15 | // 类型系统接口 | | 16 | typedef struct { | | 17 | Oid (*get_type_oid)(const char* type_name); | | 18 | bool (*can_cast)(Oid source_type, Oid target_type); | | 19 | Datum (*cast_value)(Datum value, Oid source_type, Oid target_type); | | 20 | } TypeSystemInterface; |

1.3.2 核心调度层(Core Dispatcher)

负责根据dbcompatibility参数路由请求到具体的方言实现，采用基于跳转表的高效路由机制：

| | | | --- | --- | | 1 | typedef struct CompatibilityDispatcher { | | 2 | JumpTable* mode_jump_tables[MAX_COMPATIBILITY_MODES]; | | 3 | CacheManager* cache_manager; | | 4 | // ... 其他调度组件 | | 5 | } CompatibilityDispatcher; |

1.3.3 方言实现层(Dialect Implementation)

包含各兼容性模式的具体实现，每个方言是一个相对独立的模块：

src/backend/dialect/ ├── dialect_a/ ├── dialect_b/ ├── dialect_c/ └── common/ # 公共基础组件

1.3.4 公共基础层(Common Base)

提供跨方言的公共功能和工具类，避免代码重复：

| | | | --- | --- | | 1 | // 公共类型定义 | | 2 | typedef struct CompatibilityContext { | | 3 | MemoryContext memory_context; | | 4 | CompatibilityMode current_mode; | | 5 | // ... 其他上下文信息 | | 6 | } CompatibilityContext; |

1.4 依赖管理设计

框架通过依赖倒置原则实现方言实现与核心代码的解耦：

| | | | --- | --- | | 1 | // 核心模块定义抽象接口 | | 2 | typedef struct CoreService { | | 3 | ParserService* (*get_parser)(CompatibilityMode mode); | | 4 | FunctionService* (*get_function_service)(CompatibilityMode mode); | | 5 | TypeService* (*get_type_service)(CompatibilityMode mode); | | 6 | } CoreService; | | 7 | | | 8 | // 方言模块提供具体实现 | | 9 | void register_dialect_implementation(CompatibilityMode mode, | | 10 | DialectImplementation* impl) { | | 11 | // 注册实现到核心服务 | | 12 | } |

二、初始化与配置管理系统

2.1 多级配置体系

框架实现了三级配置机制，支持从不同层级指定兼容性模式：

| | | | --- | --- | | 1 | // 配置优先级：会话级 > 数据库级 > 集群级 | | 2 | CompatibilityMode resolve_compatibility_mode() { | | 3 | // 检查会话级配置 | | 4 | if (session_has_compatibility_setting()) { | | 5 | return get_session_compatibility(); | | 6 | } | | 7 | | | 8 | // 检查数据库级配置 | | 9 | if (database_has_compatibility_setting()) { | | 10 | return get_database_compatibility(); | | 11 | } | | 12 | | | 13 | // 返回集群级默认配置 | | 14 | return get_cluster_default_compatibility(); | | 15 | } |

2.2 初始化脚本管理

采用分目录存储策略，每个兼容性模式拥有独立的初始化脚本目录：

scripts/ ├── common/ # 公共初始化脚本 ├── dialect_a/ # A兼容性模式脚本 ├── dialect_b/ # B兼容性模式脚本 └── dialect_c/ # C兼容性模式脚本

初始化过程中，框架根据配置的兼容性模式加载对应目录下的SQL脚本：

| | | | --- | --- | | 1 | void load_initialization_scripts(CompatibilityMode mode) { | | 2 | // 加载公共脚本 | | 3 | load_scripts("scripts/common"); | | 4 | | | 5 | // 加载模式特定脚本 | | 6 | char dialect_path[MAX_PATH]; | | 7 | snprintf(dialect_path, MAX_PATH, "scripts/dialect_%c", mode_to_char(mode)); | | 8 | load_scripts(dialect_path); | | 9 | } |

2.3 动态加载机制

框架采用懒加载策略减少内存开销：

| | | | --- | --- | | 1 | typedef struct DialectModule { | | 2 | CompatibilityMode mode; | | 3 | bool is_loaded; | | 4 | void* handle; // 动态库句柄 | | 5 | // ... 其他模块信息 | | 6 | } DialectModule; | | 7 | | | 8 | DialectModule* load_dialect_module(CompatibilityMode mode) { | | 9 | DialectModule* module = find_module(mode); | | 10 | if (!module->is_loaded) { | | 11 | // 动态加载模块 | | 12 | char lib_name[MAX_PATH]; | | 13 | snprintf(lib_name, MAX_PATH, "libdialect_%c.so", mode_to_char(mode)); | | 14 | module->handle = dlopen(lib_name, RTLD_LAZY); | | 15 | module->is_loaded = true; | | 16 | } | | 17 | return module; | | 18 | } |

三、语法解析子系统实现

3.1 多分支词法分析器

词法分析器采用基于条件编译和运行时判断的混合模式：

| | | | --- | --- | | 1 | %option noyywrap | | 2 | | | 3 | %{ | | 4 | #include "compatibility.h" | | 5 | %} | | 6 | | | 7 | %x DIALECT_A_KEYWORDS | | 8 | %x DIALECT_B_KEYWORDS | | 9 | %x DIALECT_C_KEYWORDS | | 10 | | | 11 | %% | | 12 | | | 13 | /* 公共关键词 */ | | 14 | SELECT|select { return SELECT; } | | 15 | | | 16 | /* 模式特定关键词处理 */ | | 17 | <DIALECT_A_KEYWORDS>{ | | 18 | LIMIT { return LIMIT; } | | 19 | } | | 20 | | | 21 | <DIALECT_B_KEYWORDS>{ | | 22 | TOP { return TOP; } | | 23 | } | | 24 | | | 25 | <INITIAL>{ | | 26 | /* 根据模式切换状态 */ | | 27 | { | | 28 | switch(current_compatibility_mode) { | | 29 | case MODE_A: BEGIN(DIALECT_A_KEYWORDS); break; | | 30 | case MODE_B: BEGIN(DIALECT_B_KEYWORDS); break; | | 31 | case MODE_C: BEGIN(DIALECT_C_KEYWORDS); break; | | 32 | } | | 33 | } | | 34 | } |

3.2 语法规则的多版本管理

Bison语法规则文件采用模板生成技术：

| | | | --- | --- | | 1 | /* gram-template.y */ | | 2 | %token SELECT FROM WHERE | | 3 | | | 4 | %% | | 5 | | | 6 | query: /* 公共规则 */ | | 7 | | dialect_specific_rule | | 8 | ; | | 9 | | | 10 | /* 插入点用于方言特定规则 */ | | 11 | %DIALECT_RULES_INSERTION_POINT% |

构建系统会根据配置动态生成最终的语法文件：

| | | | --- | --- | | 1 | # Makefile规则用于生成语法文件 | | 2 | gram.y: gram-template.y dialect-rules/* | | 3 | cat gram-template.y > gram.y | | 4 | # 插入当前模式的方言规则 | | 5 | echo "%DIALECT_RULES_INSERTION_POINT%" >> gram.y | | 6 | cat dialect-rules/dialect_$(MODE).rules >> gram.y | | 7 | |

3.3 抽象语法树的兼容性转换

框架实现了AST的重写机制，将方言特定的语法结构转换为统一的中间表示：

| | | | --- | --- | | 1 | typedef struct AstTransformer { | | 2 | Node* (*transform_select_stmt)(SelectStmt* stmt, CompatibilityMode mode); | | 3 | Node* (*transform_function_call)(FuncCall* func, CompatibilityMode mode); | | 4 | // ... 其他转换函数 | | 5 | } AstTransformer; | | 6 | | | 7 | Node* transform_ast(Node* ast, CompatibilityMode source_mode, | | 8 | CompatibilityMode target_mode) { | | 9 | AstTransformer* transformer = get_transformer(source_mode, target_mode); | | 10 | return apply_transformer(ast, transformer); | | 11 | } |

四、函数与操作符管理系统

4.1 函数注册表的多层结构

函数管理系统采用三级查找结构：

| | | | --- | --- | | 1 | typedef struct FunctionNamespace { | | 2 | char* namespace_name; | | 3 | HTAB* function_hash; // 函数名 -> FunctionEntry[] | | 4 | } FunctionNamespace; | | 5 | | | 6 | typedef struct FunctionRegistry { | | 7 | FunctionNamespace* common_namespace; // 公共函数 | | 8 | FunctionNamespace* dialect_namespaces[MAX_COMPATIBILITY_MODES]; // 方言函数 | | 9 | FunctionNamespace* temp_namespace; // 临时函数 | | 10 | } FunctionRegistry; |

查找算法优先搜索方言特定函数，然后搜索公共函数：

| | | | --- | --- | | 1 | FuncDesc* resolve_function(const char* func_name, Oid* arg_types, | | 2 | int nargs, CompatibilityMode mode) { | | 3 | // 第一步：在当前兼容性模式中查找精确匹配 | | 4 | FuncDesc* candidate = find_in_dialect_namespace(func_name, arg_types, nargs, mode); | | 5 | | | 6 | // 第二步：查找兼容性模式中的类型转换匹配 | | 7 | if (candidate == NULL) { | | 8 | candidate = find_with_coercion(func_name, arg_types, nargs, mode); | | 9 | } | | 10 | | | 11 | // 第三步：在公共命名空间中查找 | | 12 | if (candidate == NULL) { | | 13 | candidate = find_in_common_namespace(func_name, arg_types, nargs); | | 14 | } | | 15 | | | 16 | return candidate; | | 17 | } |

4.2 函数调用优化

框架实现了基于兼容性模式的函数调用优化：

| | | | --- | --- | | 1 | typedef struct { | | 2 | CompatibilityMode mode; | | 3 | Oid func_oid; | | 4 | FmgrInfo* flinfo_cache; // 快速调用缓存 | | 5 | FunctionOptimizer optimizer; // 模式特定优化器 | | 6 | } CachedFunctionCall; | | 7 | | | 8 | Datum optimized_function_call(CachedFunctionCall* cache, FunctionCallInfo fcinfo) { | | 9 | // 应用模式特定的优化策略 | | 10 | if (cache->optimizer != NULL) { | | 11 | return cache->optimizer(fcinfo); | | 12 | } | | 13 | | | 14 | // 标准调用路径 | | 15 | return FunctionCallInvoke(fcinfo); | | 16 | } |

五、类型系统实现

5.1 类型注册与发现

类型系统维护多个类型命名空间：

| | | | --- | --- | | 1 | typedef struct TypeEntry { | | 2 | Oid oid; | | 3 | char* type_name; | | 4 | CompatibilityMode defining_mode; | | 5 | TypeCategory category; | | 6 | // 类型元数据... | | 7 | } TypeEntry; | | 8 | | | 9 | typedef struct TypeRegistry { | | 10 | Oid next_oid_per_mode[MAX_COMPATIBILITY_MODES]; | | 11 | HTAB* type_by_oid; // OID -> TypeEntry | | 12 | HTAB* type_by_name_mode; // (name, mode) -> TypeEntry | | 13 | HTAB* type_aliases; // 类型别名映射 | | 14 | } TypeRegistry; |

5.2 类型转换子系统

类型转换系统实现了复杂的转换路径查找算法：

| | | | --- | --- | | 1 | typedef struct TypeCastPath { | | 2 | Oid source_type; | | 3 | Oid target_type; | | 4 | Oid intermediate_types[MAX_CAST_STEPS]; | | 5 | int num_steps; | | 6 | CastFunction cast_functions[MAX_CASTSTEPS]; | | 7 | Cost cost; // 转换成本估计 | | 8 | } TypeCastPath; | | 9 | | | 10 | TypeCastPath* find_cast_path(Oid source, Oid target, CompatibilityMode mode) { | | 11 | // 首先查找直接转换 | | 12 | TypeCastPath* path = find_direct_cast(source, target, mode); | | 13 | if (path != NULL) return path; | | 14 | | | 15 | // 查找基于类型继承关系的转换 | | 16 | path = find_inheritance_cast(source, target, mode); | | 17 | if (path != NULL) return path; | | 18 | | | 19 | // 使用通用转换规则 | | 20 | path = find_generic_cast(source, target, mode); | | 21 | | | 22 | return path; | | 23 | } |

5.3 类型兼容性矩阵

框架为每个兼容性模式维护类型兼容性矩阵：

| | | | --- | --- | | 1 | typedef struct { | | 2 | Oid source_type; | | 3 | Oid target_type; | | 4 | CompatibilityLevel level; // 完全兼容、部分兼容、需要显式转换等 | | 5 | CastContext context; // 赋值上下文、隐式转换上下文等 | | 6 | } TypeCompatibility; | | 7 | | | 8 | bool types_are_compatible(Oid source, Oid target, CastContext context, | | 9 | CompatibilityMode mode) { | | 10 | TypeCompatibility* compat = | | 11 | find_compatibility_entry(source, target, mode); | | 12 | | | 13 | if (compat == NULL) return false; | | 14 | | | 15 | return compat->level >= get_required_level(context); | | 16 | } |

六、系统目录与元数据管理

6.1 扩展系统目录架构

系统目录表采用可扩展设计：

| | | | --- | --- | | 1 | -- 公共目录表结构 | | 2 | CREATE TABLE pg_catalog.pg_class ( | | 3 | oid OID, | | 4 | relname NAME, | | 5 | relnamespace OID, | | 6 | relkind CHAR, | | 7 | -- 公共字段... | | 8 | dialect_specific_attributes JSONB -- 存储模式特定属性 | | 9 | ); | | 10 | | | 11 | -- 模式特定目录表 | | 12 | CREATE TABLE pg_catalog.pg_dialect_a_specific ( | | 13 | oid OID REFERENCES pg_class(oid), | | 14 | a_specific_attr1 INT, | | 15 | a_specific_attr2 TEXT | | 16 | ); |

6.2 动态元数据视图

系统视图采用模板化生成：

| | | | --- | --- | | 1 | typedef struct ViewTemplate { | | 2 | char* view_name; | | 3 | char* base_query_template; | | 4 | DialectClause dialect_clauses[MAX_COMPATIBILITY_MODES]; | | 5 | ColumnMapping column_mappings[MAX_COLUMNS]; | | 6 | } ViewTemplate; | | 7 | | | 8 | void create_dialect_views(CompatibilityMode mode) { | | 9 | for (int i = 0; i < num_view_templates; i++) { | | 10 | ViewTemplate* template = &view_templates[i]; | | 11 | char* query = build_view_query(template, mode); | | 12 | execute_sql_query(query); | | 13 | } | | 14 | } |

七、性能优化策略

7.1 基于模式的查询优化

查询优化器考虑兼容性模式的影响：

| | | | --- | --- | | 1 | typedef struct CompatibilityAwarePlanner { | | 2 | CompatibilityMode mode; | | 3 | CostModel cost_models[MAX_COMPATIBILITY_MODES]; | | 4 | JoinMethod supported_join_methods[MAX_COMPATIBILITY_MODES]; | | 5 | IndexStrategy index_strategies[MAX_COMPATIBILITY_MODES]; | | 6 | } CompatibilityAwarePlanner; | | 7 | | | 8 | Plan* plan_query(Query* query, CompatibilityMode mode) { | | 9 | CompatibilityAwarePlanner* planner = get_planner_for_mode(mode); | | 10 | | | 11 | // 应用模式特定的优化规则 | | 12 | apply_dialect_rewrite_rules(query, mode); | | 13 | | | 14 | // 使用模式特定的成本模型进行 planning | | 15 | return standard_planner(query, planner->cost_model); | | 16 | } |

7.2 高效缓存子系统

框架实现了多级缓存体系：

| | | | --- | --- | | 1 | typedef struct CompatibilityCache { | | 2 | // 解析结果缓存，按模式和查询文本哈希 | | 3 | HTAB* parsed_query_cache; | | 4 | | | 5 | // 函数缓存，按(模式,函数名,参数类型)缓存 | | 6 | HTAB* function_cache; | | 7 | | | 8 | // 类型转换路径缓存 | | 9 | HTAB* cast_path_cache; | | 10 | | | 11 | // 统计信息缓存，按模式分隔 | | 12 | HTAB* stats_cache[MAX_COMPATIBILITY_MODES]; | | 13 | } CompatibilityCache; |

缓存失效机制确保模式切换时的数据一致性：

| | | | --- | --- | | 1 | void on_compatibility_mode_change(CompatibilityMode old_mode, | | 2 | CompatibilityMode new_mode) { | | 3 | // 失效受影响模式的缓存项 | | 4 | invalidate_cache_entries_for_mode(old_mode); | | 5 | | | 6 | // 预加载新模式的缓存热数据 | | 7 | warmup_cache_for_mode(new_mode); | | 8 | } |