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 | } |