【OpenGauss源码学习 —— 执行器（execMain）】

执行器（execMain）

  • 概述
    • 文件内容
    • 作用
    • 执行的操作
    • 主要函数概述
  • 部分函数详细分析
    • ExecutorStart 函数
      • standard_ExecutorStart 函数
    • ExecutorRun 函数
      • standard_ExecutorRun 函数
    • ExecutorFinish 函数
      • standard_ExecutorFinish 函数
    • ExecutorEnd 函数
      • standard_ExecutorEnd 函数

声明：本文的部分内容参考了他人的文章。在编写过程中，我们尊重他人的知识产权和学术成果，力求遵循合理使用原则，并在适用的情况下注明引用来源。
本文主要参考了 OpenGauss1.1.0 的开源代码和《OpenGauss数据库源码解析》和《PostgresSQL数据库内核分析》一书

概述

  在 OpenGauss 数据库系统中，execMain.cpp 文件是执行器（Executor）模块的核心部分之一。这个文件主要负责实现查询的执行逻辑，是数据库查询处理的关键组成部分。其中，execMain.cpp 文件所对应的部分如下图中的红色框区域所示。其中，本文主要介绍蓝色框区域的内容。
在这里插入图片描述

  以下是对 execMain.cpp 文件内容、作用以及其执行的操作的详细概述：

文件内容

  execMain.cpp 包含了执行查询的核心函数和逻辑。这包括但不限于：

  1. 查询执行的初始化和结束： 实现了查询执行的初始化（ExecutorStart）和结束（ExecutorEnd）功能，为查询执行准备必要的状态、上下文和资源，并在执行完成后进行清理。
  2. 主执行循环： 定义了主执行循环（ExecutorRun），这是执行计划的中心部分，负责按顺序处理查询计划树的节点。
  3. 行处理逻辑： 包含了处理每一行数据的逻辑，包括从数据源获取数据、应用各种操作（如过滤、聚合）以及将结果传递到下一处理阶段。
  4. 支持函数： 定义了一系列支持函数，以协助完成特定的子任务，例如处理参数、处理触发器事件等。

作用

  execMain.cpp 文件在 OpenGauss 的查询执行过程中扮演着核心角色。其主要作用包括：

  1. 查询计划执行： 将优化器生成的查询计划转化为实际操作，负责按照计划执行数据库操作，如读取表数据、执行连接操作、进行过滤和聚合等。
  2. 结果生成： 处理和生成查询结果，确保返回给用户或调用者的数据是准确和符合预期的。
  3. 事务和并发控制： 确保查询执行遵守事务规则和并发控制，维护数据的一致性和隔离性。

执行的操作

  在查询执行过程中，execMain.cpp 执行了以下主要操作：

  1. 始化执行环境： 设置执行所需的内存上下文、状态变量和执行环境。
  2. 遍历执行计划： 按照查询计划的指示逐步执行，包括访问表、执行连接、过滤和聚合等。
  3. 数据处理： 对获取的数据进行处理，如应用谓词、计算表达式等。
  4. 触发器处理： 如果涉及，处理相关的数据库触发器。
  5. 生成结果： 最终产生查询结果，可能涉及格式化数据以满足客户端的要求。
  6. 资源清理： 执行结束后，清理占用的资源，如释放内存、关闭文件等。

  总的来说，execMain.cpp 在 OpenGauss 中是执行查询的关键组件，负责将查询计划转化为实际的数据库操作，并生成查询结果。

主要函数概述

  在 OpenGauss 的 execMain.cpp 文件中，以下列出的函数各自承担着查询执行流程的不同责任。这些函数共同协作，确保从查询计划的初始化到执行的每个步骤都能正确进行。下面依次列出了这些函数并随后进行了具体描述：

void InitPlan(QueryDesc *queryDesc, int eflags);
static void CheckValidRowMarkRel(Relation rel, RowMarkType markType);
static void ExecPostprocessPlan(EState *estate);
static void ExecEndPlan(PlanState *planstate, EState *estate);
static void ExecCollectMaterialForSubplan(EState *estate);
#ifdef ENABLE_MOT
static void ExecutePlan(EState *estate, PlanState *planstate, CmdType operation, bool sendTuples, long numberTuples,ScanDirection direction, DestReceiver *dest, JitExec::JitContext* mot_jit_context);
#else
static void ExecutePlan(EState *estate, PlanState *planstate, CmdType operation, bool sendTuples, long numberTuples,ScanDirection direction, DestReceiver *dest);
#endif
static void ExecuteVectorizedPlan(EState *estate, PlanState *planstate, CmdType operation, bool sendTuples,long numberTuples, ScanDirection direction, DestReceiver *dest);
static bool ExecCheckRTEPerms(RangeTblEntry *rte);
static bool ExecCheckRTEPermsModified(Oid relOid, Oid userid, Bitmapset *modifiedCols, AclMode requiredPerms);
void ExecCheckXactReadOnly(PlannedStmt *plannedstmt);
static void EvalPlanQualStart(EPQState *epqstate, EState *parentestate, Plan *planTree);extern char* ExecBuildSlotValueDescription(Oid reloid, TupleTableSlot *slot, TupleDesc tupdesc, Bitmapset *modifiedCols, int maxfieldlen);extern void BuildStreamFlow(PlannedStmt *plan);
extern void StartUpStreamInParallel(PlannedStmt* pstmt, EState* estate);extern void CodeGenThreadRuntimeSetup();
extern bool CodeGenThreadObjectReady();
extern void CodeGenThreadRuntimeCodeGenerate();
extern void CodeGenThreadTearDown();
extern bool anls_opt_is_on(AnalysisOpt dfx_opt);
函数功能
InitPlan初始化查询计划。这个函数负责准备执行环境，包括分配和设置执行状态（EState）以及其他查询执行所需的资源。
CheckValidRowMarkRel检查行标记关系的有效性。这个函数用于确保行标记操作（如 SELECT FOR UPDATE）应用于适当的关系类型。
ExecPostprocessPlan执行计划的后处理。在查询计划执行完毕后，这个函数执行必要的清理和后处理操作。
ExecEndPlan结束查询计划的执行。释放计划状态树（PlanState）中占用的资源，并进行必要的清理工作。
ExecCollectMaterialForSubplan为子计划收集材料。这通常涉及缓存子计划的结果以供后续操作使用。
ExecutePlan执行查询计划。这个函数是查询执行的核心，它遍历并执行计划状态树，处理数据并生成结果。
ExecuteVectorizedPlan执行向量化查询计划。这是对 ExecutePlan 的变种，专门用于处理向量化查询，可以提高某些查询类型的性能。
ExecCheckRTEPerms检查关系表条目（Range Table Entry）的权限。确保对表的访问符合权限要求。
ExecCheckRTEPermsModified检查修改后的关系表条目的权限。特别是在涉及列级权限时使用。
ExecCheckXactReadOnly检查事务是否为只读。这对于预防在只读事务中执行写操作尤为重要。
EvalPlanQualStart开始评估计划质量。用于启动执行计划的一部分，以评估特定的行或条件。
ExecBuildSlotValueDescription构建插槽值描述。用于生成关于元组插槽的详细描述，这在调试和日志记录中很有用。
BuildStreamFlow构建流处理流程。这与处理流数据相关，涉及设置流处理的路径和方式。
StartUpStreamInParallel并行启动流处理。在并行环境中初始化流处理。
CodeGenThreadRuntimeSetup设置代码生成线程的运行时环境。用于即时编译（JIT）优化。
CodeGenThreadObjectReady, CodeGenThreadRuntimeCodeGenerate, CodeGenThreadTearDown与代码生成线程的生命周期管理有关的一系列函数，从确认就绪状态到生成代码再到拆卸环境。
anls_opt_is_on检查分析优化选项是否开启。这与查询优化和性能分析相关。

部分函数详细分析

  这里不一一的对以上所有的函数进行分析，我们重点挑选执行器的外部接口函数来进行详细的学习，其余的函数有感兴趣的小伙伴可以根据自身的需求去阅读源码。
  其中，四个核心执行器接口函数：ExecutorStart(), ExecutorRun(), ExecutorFinish(), 和 ExecutorEnd()。以下是对这段文字的中文总结及对这四个函数的说明：

  1. ExecutorStart()：
      在执行任何查询计划的开始时必须调用。它负责初始化执行环境，准备所需的资源和状态。
  2. ExecutorRun()：
      用于执行查询计划。接受方向和数量参数，指定执行的方向（向前或向后）和处理的元组数量。这个函数可能被多次调用，以处理计划的所有元组，特别是在查询计划涉及多个阶段或者需要分步处理时。对于 SELECT 查询，也可以提前停止执行。
  3. ExecutorFinish()：
      在最后一次调用 ExecutorRun() 之后、在调用 ExecutorEnd() 之前必须调用。这一步是执行过程的收尾阶段，但在只执行 EXPLAIN 时可以省略这一步。
  4. ExecutorEnd()：
      在查询计划执行的最后必须调用。它用于清理执行过程中分配的资源，无论执行是否因为错误而中断，都必须调用此函数。

  这四个函数共同构成了查询执行的生命周期：

  • ExecutorStart()：初始化阶段，准备执行环境。
  • ExecutorRun()：执行阶段，可以多次调用，负责实际的查询处理。
  • ExecutorFinish()：结束阶段的一部分，处理执行后的收尾工作。
  • ExecutorEnd()：清理阶段，释放资源，结束查询执行。

  下面，我们依次来学习一下这几个函数的具体执行流程。

ExecutorStart 函数

  ExecutorStart 函数是查询执行流程的起始点。它的主要作用是初始化查询执行环境，包括设置内部状态（如 estate 和 planstate）和返回元组的描述（tupDesc）。这个函数处理 QueryDesc 结构，这是一个包含了查询描述信息的关键数据结构。此外，函数支持通过钩子（hook）机制允许插件介入查询执行的初始化过程，提供了扩展和自定义的可能性。在函数开始和结束时，通过 gstrace 进行跟踪，以便监控函数的执行情况。如果没有设置特定的钩子，函数会调用 standard_ExecutorStart 来进行标准的初始化流程。这个函数对于确保查询计划能够正确执行是至关重要的，因为它准备了执行查询所需的所有必要的上下文和状态。函数源码如下所示：（路径：src\gausskernel\runtime\executor\execMain.cpp）

/* ----------------------------------------------------------------* 		ExecutorStart** 		这个程序必须在任何查询计划执行的开始时调用。** 接收由 CreateQueryDesc 创建的 QueryDesc（分开是因为某些地方使用 QueryDesc 执行实用程序命令）。* QueryDesc 的 tupDesc 字段填充了描述将返回的元组的信息，内部字段（estate 和 planstate）也被设置好。** eflags 包含 executor.h 中描述的标志位。** 注意：调用此函数时的 CurrentMemoryContext 将成为此 Executor 调用的每个查询上下文的父级。** 我们提供了一个函数钩子变量，允许可加载的插件在调用 ExecutorStart 时获得控制权。* 这样的插件通常会调用 standard_ExecutorStart()。* ----------------------------------------------------------------*/
void ExecutorStart(QueryDesc* queryDesc, int eflags)
{gstrace_entry(GS_TRC_ID_ExecutorStart);  // 进入函数的跟踪点/* 在处理插件钩子时要小心，因为动态库可能已被释放 */if (ExecutorStart_hook && !(g_instance.status > NoShutdown))(*ExecutorStart_hook)(queryDesc, eflags);  // 如果设置了 ExecutorStart 钩子，则调用它else/* ----------------------------------------------------------------* 		ExecutorStart** 		这个程序必须在任何查询计划执行的开始时调用。** 接收由 CreateQueryDesc 创建的 QueryDesc（分开是因为某些地方使用 QueryDesc 执行实用程序命令）。* QueryDesc 的 tupDesc 字段填充了描述将返回的元组的信息，内部字段（estate 和 planstate）也被设置好。** eflags 包含 executor.h 中描述的标志位。** 注意：调用此函数时的 CurrentMemoryContext 将成为此 Executor 调用的每个查询上下文的父级。** 我们提供了一个函数钩子变量，允许可加载的插件在调用 ExecutorStart 时获得控制权。* 这样的插件通常会调用 standard_ExecutorStart()。* ----------------------------------------------------------------*/
void ExecutorStart(QueryDesc* queryDesc, int eflags)
{gstrace_entry(GS_TRC_ID_ExecutorStart);  // 进入函数的跟踪点/* 在处理插件钩子时要小心，因为动态库可能已被释放 */if (ExecutorStart_hook && !(g_instance.status > NoShutdown))(*ExecutorStart_hook)(queryDesc, eflags);  // 如果设置了 ExecutorStart 钩子，则调用它elsestandard_ExecutorStart(queryDesc, eflags);  // 否则，调用标准的 ExecutorStart 实现gstrace_exit(GS_TRC_ID_ExecutorStart);  // 退出函数的跟踪点
}
(queryDesc, eflags);  // 否则，调用标准的 ExecutorStart 实现gstrace_exit(GS_TRC_ID_ExecutorStart);  // 退出函数的跟踪点
}

standard_ExecutorStart 函数

  standard_ExecutorStart 函数是数据库查询执行器的一部分，主要负责初始化查询的执行环境和状态。这个函数为数据库查询执行提供了全面的准备，包括内存管理、状态设置、性能监控和触发器处理等。代码中使用了宏定义和条件编译，这表明其具有处理不同编译设置和运行时情况的灵活性。函数源码如下所示：（路径：src\gausskernel\runtime\executor\execMain.cpp）

void standard_ExecutorStart(QueryDesc *queryDesc, int eflags)
{/* 定义执行状态、内存上下文和性能测量相关的变量 */EState *estate = NULL;MemoryContext old_context;instr_time starttime;double totaltime = 0;/* 确保查询描述符有效且尚未开始执行 */Assert(queryDesc != NULL);Assert(queryDesc->estate == NULL);#ifdef MEMORY_CONTEXT_CHECKING/* 执行器开始时检查所有内存上下文 */MemoryContextCheck(t_thrd.top_mem_cxt, false);
#endif/* 如果事务是只读的，检查是否有计划写入非临时表 */if (u_sess->attr.attr_common.XactReadOnly && !(eflags & EXEC_FLAG_EXPLAIN_ONLY)) {ExecCheckXactReadOnly(queryDesc->plannedstmt);}/* 重置内存上下文的连续编号 */t_thrd.utils_cxt.mctx_sequent_count = 0;/* 初始化内存跟踪信息 */MemoryTrackingInit();/* 创建执行状态（EState），并切换到查询特定的内存上下文 */estate = CreateExecutorState();queryDesc->estate = estate;/* 根据编译选项记录执行器的内存追踪信息 */
#ifndef ENABLE_MEMORY_CHECKt_thrd.utils_cxt.ExecutorMemoryTrack = ((AllocSet)(estate->es_query_cxt))->track;
#elset_thrd.utils_cxt.ExecutorMemoryTrack = ((AsanSet)(estate->es_query_cxt))->track;
#endif/* 初始化流式处理和性能监控（如果适用） */// 这部分代码涉及特定于流处理的性能监控初始化/* 切换到查询执行的内存上下文 */old_context = MemoryContextSwitchTo(estate->es_query_cxt);/* 初始化代码生成对象（如果使用代码生成） */CodeGenThreadRuntimeSetup();/* 从查询描述符中填充外部参数，并为内部参数分配空间 */estate->es_param_list_info = queryDesc->params;if (queryDesc->plannedstmt->nParamExec > 0) {estate->es_param_exec_vals =(ParamExecData *)palloc0(queryDesc->plannedstmt->nParamExec * sizeof(ParamExecData));}/** 如果查询不是只读的，设置命令ID以标记输出元组*/switch (queryDesc->operation) {case CMD_SELECT:/** 对于包含SELECT FOR UPDATE/SHARE和修改CTE的查询，需要标记元组*/if (queryDesc->plannedstmt->rowMarks != NIL || queryDesc->plannedstmt->hasModifyingCTE) {estate->es_output_cid = GetCurrentCommandId(true);}/** 如果查询中不包含修改CTE，就不可能触发触发器，所以强制跳过触发器模式。* 这只是一种边缘效率的优化，因为AfterTriggerBeginQuery/AfterTriggerEndQuery的成本不高，* 但我们还是这样做吧。*/if (!queryDesc->plannedstmt->hasModifyingCTE) {eflags |= EXEC_FLAG_SKIP_TRIGGERS;}break;case CMD_INSERT:case CMD_DELETE:case CMD_UPDATE:case CMD_MERGE:estate->es_output_cid = GetCurrentCommandId(true);break;default:ereport(ERROR, (errcode(ERRCODE_UNRECOGNIZED_NODE_TYPE),errmsg("不识别的操作代码：%d", (int)queryDesc->operation)));break;}/** 复制其他重要信息到 EState*/// 这部分代码复制了快照信息、执行标志、性能监控选项等到执行状态estate->es_snapshot = RegisterSnapshot(queryDesc->snapshot); // 注册快照信息到执行状态estate->es_crosscheck_snapshot = RegisterSnapshot(queryDesc->crosscheck_snapshot); // 注册交叉检查快照到执行状态estate->es_top_eflags = eflags; // 将执行标志复制到执行状态的顶层标志estate->es_instrument = queryDesc->instrument_options; // 复制仪表选项到执行状态/* 应用 BloomFilter 数组空间。 */// 这部分代码涉及到为查询计划中可能使用的布隆过滤器分配空间if (queryDesc->plannedstmt->MaxBloomFilterNum > 0) {int bloom_size = queryDesc->plannedstmt->MaxBloomFilterNum;estate->es_bloom_filter.array_size = bloom_size; // 设置 BloomFilter 数组的大小estate->es_bloom_filter.bfarray = (filter::BloomFilter **)palloc0(bloom_size * sizeof(filter::BloomFilter *)); // 分配 BloomFilter 数组的内存}/* 语句总是从协调节点 (CN) 开始 */// 这部分代码处理时间戳设置，以确保语句执行时间的准确性if (IS_PGXC_COORDINATOR || IS_SINGLE_NODE) {SetCurrentStmtTimestamp(); // 设置当前语句的时间戳} /* 否则从协调节点同步 stmtSystemTimestamp 时间戳 *//** 初始化计划状态树*/// 这部分代码负责初始化整个查询计划的执行状态树(void)INSTR_TIME_SET_CURRENT(starttime); // 记录当前时间IPC_PERFORMANCE_LOG_OUTPUT("standard_ExecutorStart InitPlan start."); // 记录性能日志，表示计划初始化开始InitPlan(queryDesc, eflags); // 初始化查询计划IPC_PERFORMANCE_LOG_OUTPUT("standard_ExecutorStart InitPlan end."); // 记录性能日志，表示计划初始化结束totaltime += elapsed_time(&starttime); // 计算计划初始化时间/** 如果当前计划用于表达式计算，不需要收集仪表信息。*/// 这部分代码处理性能数据的收集if (estate->es_instrument != INSTRUMENT_NONE && StreamTopConsumerAmI() && u_sess->instr_cxt.global_instr &&u_sess->instr_cxt.thread_instr) {int node_id = queryDesc->plannedstmt->planTree->plan_node_id - 1;int *m_instrArrayMap = u_sess->instr_cxt.thread_instr->m_instrArrayMap;// 更新仪表数据的初始化时间u_sess->instr_cxt.thread_instr->m_instrArray[m_instrArrayMap[node_id]].instr.instruPlanData.init_time =totaltime;}/** 设置 AFTER 触发器语句上下文，除非明确不需要，或者是 EXPLAIN-only 模式（不会调用 ExecutorFinish）。*/// 这部分代码负责初始化与触发器相关的上下文if (!(eflags & (EXEC_FLAG_SKIP_TRIGGERS | EXEC_FLAG_EXPLAIN_ONLY))) {AfterTriggerBeginQuery(); // 设置 AFTER 触发器的语句上下文}(void)MemoryContextSwitchTo(old_context); // 切换回原来的内存上下文}

  其中，switch 中代码主要功能是根据查询的操作类型（queryDesc->operation）来设置命令 ID（es_output_cid），以便标记输出元组，同时根据查询类型决定是否跳过触发器。

  • 对于 SELECT 查询，如果查询中包含了 FOR UPDATE 或 FOR SHARE 锁定语句，或者查询计划中包含了修改通用表表达式（CTE），则会设置命令 ID 为当前事务的命令 ID，用于标记输出元组。如果查询不包含修改 CTE，则会强制设置执行标志 eflags 中的 EXEC_FLAG_SKIP_TRIGGERS，以跳过触发器的执行。
  • 对于 INSERT、DELETE、UPDATE 和 MERGE 操作，无论是否包含修改CTE，都会设置命令 ID 为当前事务的命令 ID，用于标记输出元组。
  • 如果查询的操作类型不是上述任何一种，会触发一个错误报告，指示出现了不识别的操作代码。

  下面以举一个具体的案例来说明，假设我们有一个包含以下 SQL 查询的数据库：

-- 查询1：一个只读查询
SELECT name, age FROM employees WHERE department = 'HR';-- 查询2：一个更新查询
UPDATE employees SET salary = salary + 500 WHERE department = 'Engineering';-- 查询3：一个插入查询
INSERT INTO employees (name, age, department) VALUES ('Alice', 28, 'Marketing');-- 查询4：一个删除查询
DELETE FROM employees WHERE name = 'Bob';-- 查询5：一个选择性更新查询
MERGE INTO employees AS tgt
USING updated_salaries AS src
ON tgt.id = src.id
WHEN MATCHED THEN UPDATE SET tgt.salary = src.new_salary;
  1. 对于查询1，这是一个只读查询（CMD_SELECT），不包含任何修改操作。因此，不需要标记输出元组的命令 ID，而且触发器也不会被触发。这是通过将 eflags 中的 EXEC_FLAG_SKIP_TRIGGERS 设置为 true 来实现的。
  2. 对于查询2、3、4 和 5，它们都是更新查询，包括插入、更新和删除操作（CMD_INSERT、CMD_DELETE、CMD_UPDATE 和 CMD_MERGE）。对于这些查询，需要标记输出元组的命令ID，以便将来跟踪它们的修改。因此，estate->es_output_cid 被设置为当前事务的命令 ID（使用 GetCurrentCommandId(true)）。
  3. 如果查询的操作类型不是上述任何一种，将触发错误报告，指示出现了不识别的操作代码。这可以帮助开发人员及时发现并修复代码中的问题。

  综上所述，这段代码的作用是根据查询的操作类型来确定是否需要标记输出元组的命令ID，并且在必要时设置执行标志 eflags 以跳过触发器的执行。这有助于确保在数据库操作中的元组修改能够正确地跟踪和标记。

ExecutorRun 函数

  ExecutorRun 函数主要功能是接受查询描述符并执行查询计划。它首先进行准备工作，包括解释查询计划和进行性能分析。然后，根据配置决定是否进行资源跟踪和操作符历史统计，并调用相应的函数执行查询。在查询执行完成后，它还负责记录执行时间、报告查询计划以及记录操作符历史统计信息，以便后续性能分析和查询优化。函数源码如下所示：（路径：src\gausskernel\runtime\executor\execMain.cpp）

/** ExecutorRun** 这是执行器模块的主要例程。它接受来自交通警察的查询描述符，并执行查询计划。** ExecutorStart 必须已经被调用。** 如果 direction 是 NoMovementScanDirection，那么除了启动/关闭目标外，什么都不会执行。* 否则，我们按指定方向检索最多 'count' 个元组。** 注意：count = 0 被解释为没有门户限制，即运行到完成为止。还要注意，计数限制仅适用于检索的元组，* 而不适用于由 ModifyTable 计划节点插入/更新/删除的元组。** 没有返回值，但输出元组（如果有的话）将发送到 QueryDesc 中指定的目标接收器；并且顶层处理的元组数量* 可以在 estate->es_processed 中找到。** 我们提供了一个函数钩子变量，允许可加载插件在调用 ExecutorRun 时获取控制权。这样的插件通常会调用 standard_ExecutorRun()。*/
void ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, long count)
{// 以下部分代码主要用于执行器运行前的准备工作和性能分析// 检查是否需要进行操作符历史统计以及记录执行计划int instrument_option = 0;bool has_track_operator = false;char* old_stmt_name = u_sess->pcache_cxt.cur_stmt_name;// 如果 SPI 连接打开，则设置当前语句名为空if (u_sess->SPI_cxt._connected >= 0) {u_sess->pcache_cxt.cur_stmt_name = NULL;}// 执行计划解释和分析exec_explain_plan(queryDesc);// 根据配置决定是否进行资源跟踪和操作符历史统计if (u_sess->attr.attr_resource.use_workload_manager &&u_sess->attr.attr_resource.resource_track_level == RESOURCE_TRACK_OPERATOR && queryDesc != NULL && queryDesc->plannedstmt != NULL &&queryDesc->plannedstmt->is_stream_plan && u_sess->exec_cxt.need_track_resource) {#ifdef STREAMPLANif (queryDesc->instrument_options) {instrument_option = queryDesc->instrument_options;}if (IS_PGXC_COORDINATOR && instrument_option != 0 && u_sess->instr_cxt.global_instr == NULL &&queryDesc->plannedstmt->num_nodes != 0) {has_track_operator = true;queryDesc->plannedstmt->instrument_option = instrument_option;// 初始化操作符历史统计相关数据结构AutoContextSwitch streamCxtGuard(t_thrd.mem_cxt.msg_mem_cxt);int dop = queryDesc->plannedstmt->query_dop;u_sess->instr_cxt.global_instr = StreamInstrumentation::InitOnCn(queryDesc, dop);MemoryContext old_context = u_sess->instr_cxt.global_instr->getInstrDataContext();u_sess->instr_cxt.thread_instr = u_sess->instr_cxt.global_instr->allocThreadInstrumentation(queryDesc->plannedstmt->planTree->plan_node_id);(void)MemoryContextSwitchTo(old_context);}
#endif}// 根据条件决定是否可以进行操作符历史统计bool can_operator_history_statistics = false;if (u_sess->exec_cxt.need_track_resource && queryDesc &&(has_track_operator || (IS_PGXC_DATANODE && queryDesc->instrument_options))) {can_operator_history_statistics = true;}// 如果允许操作符历史统计，执行 ExplainNodeFinishif (can_operator_history_statistics) {ExplainNodeFinish(queryDesc->planstate, NULL, (TimestampTz)0.0, true);}// 如果存在执行器运行的钩子函数，调用它if (ExecutorRun_hook) {(*ExecutorRun_hook)(queryDesc, direction, count);} else {standard_ExecutorRun(queryDesc, direction, count);}// 在协调节点或单节点上，报告插入、删除、更新等操作的时间if (IS_PGXC_COORDINATOR || IS_SINGLE_NODE) {if (queryDesc->operation == CMD_INSERT || queryDesc->operation == CMD_DELETE ||queryDesc->operation == CMD_UPDATE || queryDesc->operation == CMD_MERGE) {report_iud_time(queryDesc);}}// SQL Self-Tuning：在查询执行完成后基于运行时信息分析查询计划问题if (u_sess->exec_cxt.need_track_resource && queryDesc != NULL && has_track_operator &&(IS_PGXC_COORDINATOR || IS_SINGLE_NODE)) {List *issue_results = PlanAnalyzerOperator(queryDesc, queryDesc->planstate);// 如果找到计划问题，将其记录到 sysview gs_wlm_session_historyif (issue_results != NIL) {RecordQueryPlanIssues(issue_results);}}// 打印查询执行时间print_duration(queryDesc);// 仪表统计信息报告查询计划instr_stmt_report_query_plan(queryDesc);// 如果允许操作符历史统计，最终记录统计信息if (can_operator_history_statistics) {u_sess->instr_cxt.can_record_to_table = true;ExplainNodeFinish(queryDesc->planstate, queryDesc->plannedstmt, GetCurrentTimestamp(), false);#ifdef ENABLE_MULTIPLE_NODESif ((IS_PGXC_COORDINATOR) && u_sess->instr_cxt.global_instr != NULL) {
#elseif (StreamTopConsumerAmI() && u_sess->instr_cxt.global_instr != NULL) {
#endifdelete u_sess->instr_cxt.global_instr;u_sess->instr_cxt.thread_instr = NULL;u_sess->instr_cxt.global_instr = NULL;}}// 恢复原来的语句名u_sess->pcache_cxt.cur_stmt_name = old_stmt_name;
}

standard_ExecutorRun 函数

  standard_ExecutorRun 函数的主要功能是执行给定的查询计划，包括生成机器代码、记录执行时间、处理元组的接收和发送、进行仪表统计以及维护内存上下文等。它会根据查询的操作类型和目标接收器的要求来发送查询结果，同时还会记录查询执行的总时间，用于性能分析和监控。此外，代码还处理了一些特殊情况，如矢量化查询计划和分桶查询。具体功能如下：

  1. 初始化一些变量，包括执行状态 (estate)、操作类型 (operation)、目标接收器 (dest) 等，以及记录时间变量。
  2. 进行一些健全性检查，确保查询描述符和执行状态存在，且不处于仅解释执行的模式。
  3. 切换到查询内存上下文 (es_query_cxt)，以便在执行期间进行内存分配。
  4. 生成查询的机器代码，用于执行查询计划。如果启用 LLVM 编译优化并且需要仪表统计信息，则记录 LLVM 编译时间。
  5. 允许仪表统计整个执行器的运行时间，如果查询描述符中指定了时间节点。
  6. 提取查询描述符中的操作类型和目标接收器。
  7. 启动元组接收器，如果查询将输出元组，并初始化元组接收相关状态。
  8. 设置全局桶映射 (u_sess->exec_cxt.global_bucket_map)，如果查询涉及到分布式表分桶。
  9. 记录执行计划的开始时间，并执行查询计划。
  10. 在执行计划后，更新执行状态，记录已处理的元组数量，并记录执行时间。
  11. 标记查询描述符为已执行。
  12. 如果当前查询计划用于表达式计算且需要仪表统计信息，则记录执行时间到仪表统计信息中。
  13. 关闭元组接收器，如果启动了接收器。
  14. 如果查询描述符中指定了时间节点，则停止仪表统计信息节点，记录已处理的元组数量。
  15. 恢复到先前的内存上下文。

  函数源码如下所示：（路径：src\gausskernel\runtime\executor\execMain.cpp）

void standard_ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, long count)
{EState *estate = NULL; // 初始化执行状态指针CmdType operation; // 初始化操作类型DestReceiver *dest = NULL; // 初始化目标接收器bool send_tuples = false; // 初始化是否发送元组的标志MemoryContext old_context; // 保存旧的内存上下文instr_time starttime; // 记录执行时间double totaltime = 0; // 记录总执行时间/* 健全性检查 */Assert(queryDesc != NULL); // 断言查询描述符不为空estate = queryDesc->estate; // 获取查询描述符中的执行状态Assert(estate != NULL); // 断言执行状态不为空Assert(!(estate->es_top_eflags & EXEC_FLAG_EXPLAIN_ONLY)); // 断言不处于仅解释执行的模式/** 切换到查询内存上下文*/old_context = MemoryContextSwitchTo(estate->es_query_cxt);/** 为此查询生成机器代码*/if (CodeGenThreadObjectReady()) {if (anls_opt_is_on(ANLS_LLVM_COMPILE) && estate->es_instrument > 0) {TRACK_START(queryDesc->planstate->plan->plan_node_id, LLVM_COMPILE_TIME); // 记录 LLVM 编译开始时间CodeGenThreadRuntimeCodeGenerate(); // 生成机器代码TRACK_END(queryDesc->planstate->plan->plan_node_id, LLVM_COMPILE_TIME); // 记录 LLVM 编译结束时间} else {CodeGenThreadRuntimeCodeGenerate(); // 生成机器代码}}/* 允许仪表统计整个执行器的运行时间 */if (queryDesc->totaltime) {queryDesc->totaltime->memoryinfo.nodeContext = estate->es_query_cxt; // 设置仪表统计信息的内存上下文InstrStartNode(queryDesc->totaltime); // 开始记录仪表统计信息节点}/** 从查询描述符和查询特性中提取信息*/operation = queryDesc->operation; // 获取操作类型dest = queryDesc->dest; // 获取目标接收器/** 如果将发出元组，则启动元组接收器*/estate->es_processed = 0; // 初始化已处理的元组数量estate->es_last_processed = 0; // 初始化上一次已处理的元组数量estate->es_lastoid = InvalidOid; // 初始化上一次的对象标识符send_tuples = (operation == CMD_SELECT || queryDesc->plannedstmt->hasReturning); // 根据操作类型判断是否需要发出元组/** 为了确保消息(T-C-Z)的完整性，无论 u_sess->exec_cxt.executor_stop_flag 的值如何，* 都应该发送消息'T'。*/if (send_tuples)(*dest->rStartup)(dest, operation, queryDesc->tupDesc); // 启动元组接收器if (queryDesc->plannedstmt->bucketMap != NULL) {u_sess->exec_cxt.global_bucket_map = queryDesc->plannedstmt->bucketMap[0]; // 设置全局桶映射} else {u_sess->exec_cxt.global_bucket_map = NULL; // 如果没有桶映射，则设置为空}(void)INSTR_TIME_SET_CURRENT(starttime); // 记录当前时间/** 执行查询计划*/if (!ScanDirectionIsNoMovement(direction)) {if (queryDesc->planstate->vectorized) {ExecuteVectorizedPlan(estate, queryDesc->planstate, operation, send_tuples, count, direction, dest); // 执行矢量化查询计划} else {
#ifdef ENABLE_MOTExecutePlan(estate, queryDesc->planstate, operation, send_tuples,count, direction, dest, queryDesc->mot_jit_context); // 执行查询计划
#elseExecutePlan(estate, queryDesc->planstate, operation, send_tuples, count, direction, dest); // 执行查询计划
#endif}}totaltime += elapsed_time(&starttime); // 计算总执行时间queryDesc->executed = true; // 标记查询描述符为已执行/** 如果当前查询计划用于表达式计算且需要仪表统计信息，则记录执行时间到仪表统计信息中*/if (estate->es_instrument != INSTRUMENT_NONE && StreamTopConsumerAmI() && u_sess->instr_cxt.global_instr &&u_sess->instr_cxt.thread_instr) {int node_id = queryDesc->plannedstmt->planTree->plan_node_id - 1; // 获取计划节点的IDint* m_instrArrayMap = u_sess->instr_cxt.thread_instr->m_instrArrayMap; // 获取仪表统计信息映射数组u_sess->instr_cxt.thread_instr->m_instrArray[m_instrArrayMap[node_id]].instr.instruPlanData.run_time =totaltime; // 记录执行时间到仪表统计信息中}/** 关闭元组接收器，如果启动了的话*/if (send_tuples) {(*dest->rShutdown)(dest); // 关闭元组接收器}if (queryDesc->totaltime) {InstrStopNode(queryDesc->totaltime, estate->es_processed); // 停止记录仪表统计信息节点，记录已处理的元组数量}(void)MemoryContextSwitchTo(old_context); // 恢复到先前的内存上下文
}

ExecutorFinish 函数

  ExecutorFinish 函数的主要作用是在最后一次执行器运行调用之后执行清理操作，例如触发 AFTER 触发器等。它是 ExecutorEnd 的独立函数，因为在执行 EXPLAIN ANALYZE 时需要将这些操作包括在总运行时间中。如果有加载的插件需要在 ExecutorFinish 被调用时执行额外操作，可以通过函数钩子 ExecutorFinish_hook 来实现，通常会调用 standard_ExecutorFinish 来完成标准的清理工作。函数源码如下所示：（路径：src\gausskernel\runtime\executor\execMain.cpp）

/* ----------------------------------------------------------------*      ExecutorFinish**      此例程必须在最后一次 ExecutorRun 调用之后被调用。*      它执行清理操作，例如触发 AFTER 触发器等。*      之所以与 ExecutorEnd 分开，是因为 EXPLAIN ANALYZE 需要将这些操作的耗时计入总运行时间。**      我们提供了一个函数钩子变量，允许可加载插件在调用 ExecutorFinish 时获得控制权。*      这样的插件通常会调用 standard_ExecutorFinish 来执行标准的清理工作。** ----------------------------------------------------------------*/
void ExecutorFinish(QueryDesc *queryDesc)
{// 如果有 ExecutorFinish_hook 函数钩子，就调用它if (ExecutorFinish_hook) {(*ExecutorFinish_hook)(queryDesc);} // 否则，调用标准的 ExecutorFinish 函数完成清理操作else {standard_ExecutorFinish(queryDesc);}
}

怎么理解下面这句话呢：
  “之所以与 ExecutorEnd 分开，是因为 EXPLAIN ANALYZE 需要将这些操作的耗时计入总运行时间。”

  这句话的意思是，将 ExecutorFinish 和 ExecutorEnd 分开的原因是因为在性能分析工具（如 EXPLAIN ANALYZE ）中，我们希望能够准确地统计每个查询执行的时间，包括清理操作所花费的时间。
  举个例子来说明：假设我们有一个包含多个查询的 SQL 脚本，我们想要使用 EXPLAIN ANALYZE 来分析每个查询的性能。如果将 ExecutorFinish 的清理操作合并到 ExecutorEnd 中，那么在执行完最后一个查询后，所有的清理操作会一起计入总运行时间。这将导致我们无法区分每个查询的实际执行时间，因为清理操作的时间会被分摊到所有查询上。
  通过将 ExecutorFinish 与 ExecutorEnd 分开，我们可以确保每个查询的执行时间只包括查询本身的时间，清理操作的时间会被单独计算并添加到总运行时间中。这使得我们能够更精确地分析每个查询的性能，并识别性能瓶颈或优化机会。这对于数据库性能调优和查询分析非常有用。

standard_ExecutorFinish 函数

  standard_ExecutorFinish 函数的作用是在执行器完成所有查询执行后进行清理工作，包括运行 ModifyTable 节点以确保所有修改操作已完成，并执行等待触发的 AFTER 触发器。这些清理操作需要确保在性能分析工具（如 EXPLAIN ANALYZE）中能够准确地计入总运行时间。函数源码如下所示：（路径：src\gausskernel\runtime\executor\execMain.cpp）

void standard_ExecutorFinish(QueryDesc *queryDesc)
{EState *estate = NULL;MemoryContext old_context;/* sanity checks */Assert(queryDesc != NULL); // 断言确保传入的queryDesc参数不为空estate = queryDesc->estate; // 获取查询状态信息Assert(estate != NULL); // 断言确保查询状态信息不为空Assert(!(estate->es_top_eflags & EXEC_FLAG_EXPLAIN_ONLY)); // 断言确保不是处于解释执行模式下/* This should be run once and only once per Executor instance */Assert(!estate->es_finished); // 断言确保此方法只会在Executor实例中运行一次/* Switch into per-query memory context */old_context = MemoryContextSwitchTo(estate->es_query_cxt); // 切换到查询内存上下文/* Allow instrumentation of Executor overall runtime */if (queryDesc->totaltime)InstrStartNode(queryDesc->totaltime); // 启动执行器总运行时间的性能计数/* Run ModifyTable nodes to completion */ExecPostprocessPlan(estate); // 执行ModifyTable节点的后处理，确保所有修改操作完成/* Execute queued AFTER triggers, unless told not to */if (!(estate->es_top_eflags & EXEC_FLAG_SKIP_TRIGGERS)) {AfterTriggerEndQuery(estate); // 执行等待触发的AFTER触发器，除非明确禁止}if (queryDesc->totaltime) {InstrStopNode(queryDesc->totaltime, 0); // 停止执行器总运行时间的性能计数}(void)MemoryContextSwitchTo(old_context); // 切换回之前的内存上下文estate->es_finished = true; // 设置Executor实例为已完成状态
}

ExecutorEnd 函数

  ExecutorEnd 函数的作用是在任何查询计划执行结束后调用，它可以通过钩子函数的方式来扩展功能，允许外部插件介入执行器的结束阶段。如果没有钩子函数，它将调用标准的 ExecutorEnd 函数来完成必要的清理和资源释放工作。函数源码如下所示：（路径：src\gausskernel\runtime\executor\execMain.cpp）

/* ----------------------------------------------------------------* 		ExecutorEnd** 		This routine must be called at the end of execution of any* 		query plan** 		We provide a function hook variable that lets loadable plugins* 		get control when ExecutorEnd is called.  Such a plugin would* 	 	normally call standard_ExecutorEnd().** ----------------------------------------------------------------*/
void ExecutorEnd(QueryDesc *queryDesc)
{if (ExecutorEnd_hook) {(*ExecutorEnd_hook)(queryDesc); // 如果有ExecutorEnd的挂钩函数，则调用挂钩函数，否则调用标准的ExecutorEnd函数} else {standard_ExecutorEnd(queryDesc); // 调用标准的ExecutorEnd函数}
}

standard_ExecutorEnd 函数

  standard_ExecutorEnd 函数的作用是在查询计划执行结束后进行必要的清理工作。它首先执行一些断言和内存检查，以确保执行器状态正常，然后切换到每个查询的内存上下文，并调用 ExecEndPlan 来结束查询计划的执行，释放与执行相关的资源。接着，它注销已注册的快照信息，关闭代码生成线程（如果存在），并输出内存跟踪信息到文件。最后，它计算查询执行的总时间，并记录到工具信息中，用于性能分析。函数源码如下所示：（路径：src\gausskernel\runtime\executor\execMain.cpp）

void standard_ExecutorEnd(QueryDesc *queryDesc)
{EState *estate = NULL;MemoryContext old_context;instr_time starttime;double totaltime = 0;(void)INSTR_TIME_SET_CURRENT(starttime); // 设置开始时间/* sanity checks */Assert(queryDesc != NULL); // 断言确保查询描述不为空estate = queryDesc->estate; // 获取查询状态信息Assert(estate != NULL); // 断言确保查询状态不为空#ifdef MEMORY_CONTEXT_CHECKING/* 检查内存上下文，用于内存泄漏检测 */MemoryContextCheck(t_thrd.top_mem_cxt, false);
#endif/** 检查是否调用了ExecutorFinish，除非是在仅解释模式下，这是必要的，因为ExecutorFinish是从9.1版本开始的新功能，调用者可能会忘记调用它。*/Assert(estate->es_finished || (estate->es_top_eflags & EXEC_FLAG_EXPLAIN_ONLY));/** 切换到每个查询的内存上下文以运行ExecEndPlan*/old_context = MemoryContextSwitchTo(estate->es_query_cxt);/* 执行计划结束，释放与执行相关的资源 */ExecEndPlan(queryDesc->planstate, estate);/* 释放快照信息 */UnregisterSnapshot(estate->es_snapshot);UnregisterSnapshot(estate->es_crosscheck_snapshot);if (!t_thrd.codegen_cxt.g_runningInFmgr) {CodeGenThreadTearDown();}/** 在销毁之前必须切换出上下文*/(void)MemoryContextSwitchTo(old_context);#ifdef MEMORY_CONTEXT_CHECKING/* 检查每个查询的内存上下文，用于内存泄漏检测 */MemoryContextCheck(estate->es_query_cxt, (estate->es_query_cxt->session_id > 0));
#endif/** 释放EState和每个查询的内存上下文，这应该释放执行器分配的所有资源。*/FreeExecutorState(estate);/* 重置不再指向任何内容的查询描述字段 */queryDesc->tupDesc = NULL;queryDesc->estate = NULL;queryDesc->planstate = NULL;queryDesc->totaltime = NULL;/* 输出内存跟踪信息到文件 */MemoryTrackingOutputFile();totaltime += elapsed_time(&starttime); // 计算执行结束的总时间/** 如果当前计划用于表达式计算，则无需收集工具信息。*/if (queryDesc->instrument_options != 0 && StreamTopConsumerAmI() && u_sess->instr_cxt.global_instr &&u_sess->instr_cxt.thread_instr) {int node_id = queryDesc->plannedstmt->planTree->plan_node_id - 1;int *m_instrArrayMap = u_sess->instr_cxt.thread_instr->m_instrArrayMap;u_sess->instr_cxt.thread_instr->m_instrArray[m_instrArrayMap[node_id]].instr.instruPlanData.end_time =totaltime;}/* 重置永久空间的全局值 */perm_space_value_reset();
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/620251.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

京东宣布启动鸿蒙原生应用开发，全力支持鸿蒙生态 | 百能云芯

京东宣布启动鸿蒙原生应用开发，全力支持鸿蒙生态 | 百能云芯

华为常务董事、终端BG CEO、智能汽车解决方案BU董事长余承东于1月10日在微博上发布了一条令人振奋的消息：京东即将启动鸿蒙原生应用的开发。这一消息在科技圈掀起了不小的波澜，也为鸿蒙系统的发展注入了新的动力。 京东集团首席执行官兼执行董事许冉和余…
阅读更多...
SpringBoot读取配置文件中的内容

SpringBoot读取配置文件中的内容

文章目录 1. 读取配置文件application.yml中内容的方法1.1 Environment1.2 Value注解1.3 ConfigurationProperties 注解1.4 PropertySources 注解，获取自定义配置文件中的内容，yml文件需要自行实现适配器1.5 YamlPropertiesFactoryBean 加载 YAML 文件1.…
阅读更多...
SpringBoot知识03

SpringBoot知识03

1、多模块项目无法启动，报错Failed to execute goal on project*: Could not resolve dependencies for project
阅读更多...
强化学习应用（七）：基于Q-learning的无人机物流路径规划研究（提供Python代码）

强化学习应用（七）：基于Q-learning的无人机物流路径规划研究（提供Python代码）

一、Q-learning简介 Q-learning是一种强化学习算法，用于解决基于马尔可夫决策过程（MDP）的问题。它通过学习一个价值函数来指导智能体在环境中做出决策，以最大化累积奖励。 Q-learning算法的核心思想是通过不断更新一个称为Q值的…
阅读更多...
Python如何免费调用微软Bing翻译API

Python如何免费调用微软Bing翻译API

一、引言 现在免费的机器翻译越来越少了，随着有道翻译开始收费，百度降低用户的免费机器翻译额度(目前只有实名认证过的高级用户才能获得100万字符的免费翻译额度)，而亚马逊、腾讯等机器翻译调用相对比较麻烦，需要下载各种插件包&…
阅读更多...
【IDEA】瑞_IDEA模版注释设置_IDEA自动生成注释模版（详细图文步骤）

【IDEA】瑞_IDEA模版注释设置_IDEA自动生成注释模版（详细图文步骤）

文章目录 1 概要2 类的自定义模版注释3 自定义模版注释3.1 方法的自定义模版注释3.2 属性的自定义模版注释 🙊 前言：在Java开发中，注释具有不可或缺的重要性，注释负责解释代码，能帮助开发人员深入理解代码的逻辑和功能…
阅读更多...
关联规则分析（Apriori算法2

关联规则分析（Apriori算法2

目录 1.核心术语：2.强关联规则：小结： 1.核心术语： 支持度（Support）：指项集出现的频繁程度（相当于项集出现的概率） 最小支持度有绝对值和占比两种表示方式 置信度&#…
阅读更多...
Xtuner大模型微调

Xtuner大模型微调

Xtuner大模型微调 一、课程笔记 文档链接：https://github.com/InternLM/tutorial/blob/main/xtuner/README.md 视频链接： https://www.bilibili.com/video/BV1yK4y1B75J/ 大模型微调 大模型的训练利用了各类数据，可以说是一个通才&#xff…
阅读更多...
数据仓库（2）-认识数仓

数据仓库（2）-认识数仓

1、数据仓库是什么 数据仓库 ，由数据仓库之父比尔恩门（Bill Inmon）于1990年提出，主要功能仍是将组织透过资讯系统之联机事务处理(OLTP)经年累月所累积的大量资料，透过数据仓库理论所特有的资料储存架构，做…
阅读更多...
高级路由技术案例

高级路由技术案例

文章目录 案例项目一：1、静态ECMP和浮动静态路由配置实验2、浮动静态路由配置 案例项目二：使用filter-policy过滤路由案例项目三：IS-IS基本配置案例项目四：OSPF基本配置案例任务一：OSPF单区域配置案例任务二&#xff1…
阅读更多...
开源 UI 组件库和开发工具库概览 | 开源专题 No.59

开源 UI 组件库和开发工具库概览 | 开源专题 No.59

ant-design/ant-design Stars: 87.9k License: MIT Ant Design 是一个企业级 UI 设计语言和 React UI 库。 为 Web 应用程序设计的企业级 UI。提供一套高质量的开箱即用的 React 组件。使用可预测静态类型编写 TypeScript 代码。包含完整的设计资源和开发工具包。支持数十种语…
阅读更多...
小程序基础学习（组件传参）

小程序基础学习（组件传参）

原理&#xff1a;通知在组件标签中传递参数已达到传参的目的 在组件的js的 properties中接受传递来的参数 然后在页面是展示这些数据 源码&#xff1a; <!--components/my-info/my-info.wxml--> <view class"title"> <text class"texts"&g…
阅读更多...
Java--RSA非对称加密的实现（使用java.security.KeyPair）

Java--RSA非对称加密的实现（使用java.security.KeyPair）

文章目录 前言实现步骤测试结果 前言 非对称加密是指使用不同的两个密钥进行加密和解密的一种加密算法&#xff0c;调用方用使用服务方提供的公钥进行加密&#xff0c;服务方使用自己的私钥进行解密。RSA算法是目前使用最广泛的公钥密码算法。Java提供了KeyPairGenerator类要生…
阅读更多...
BikeDNA（七）外在分析：OSM 与参考数据的比较1

BikeDNA（七）外在分析：OSM 与参考数据的比较1

BikeDNA&#xff08;七&#xff09;外在分析&#xff1a;OSM 与参考数据的比较1 该笔记本将提供的参考自行车基础设施数据集与同一区域的 OSM 数据进行所谓的外部质量评估进行比较。 为了运行这部分分析&#xff0c;必须有一个参考数据集可用于比较。 该分析基于将参考数据集…
阅读更多...
01.neuvector防护平台功能实现设计

01.neuvector防护平台功能实现设计

本篇文章主要讲neuvector大概的设计与实现&#xff0c;功能实现细节可查看后续文章&#xff0c;原文链接,欢迎大家关注我的github账号 一、整体架构 相关主要业务容器运行结构如下&#xff1a; 主要容器为以下几个&#xff1a; Controller容器负责规则的收集与下发&#xff0…
阅读更多...
Open3D AABB包围盒计算与使用（19）

Open3D AABB包围盒计算与使用（19）

Open3D AABB包围盒计算与使用（19） 一、算法速览二、算法实现1.代码2.结果少年听雨歌楼上。红烛昏罗帐。壮年听雨客舟中。江阔云低、断雁叫西风。 而今听雨僧庐下。鬓已星星也。悲欢离合总无情。一任阶前、点滴到天明。 一、算法速览 AABB包围盒就是将点云用一个各条边沿着坐…
阅读更多...
OceanBase架构概览

OceanBase架构概览

了解一个系统或软件&#xff0c;比较好的一种方式是了解其架构&#xff0c;下图是官网上的架构图&#xff0c;基于V 4.2.1版本 OceanBase 使用通用服务器硬件&#xff0c;依赖本地存储&#xff0c;分布式部署在多个服务器上&#xff0c;每个服务器都是对等的&#xff0c;数据库…
阅读更多...
翻译: Streamlit从入门到精通 基础控件 一

翻译: Streamlit从入门到精通 基础控件 一

这个关于Streamlit的教程旨在帮助数据科学家或机器学习工程师&#xff0c;他们不是网络开发者&#xff0c;也不想花费数周时间学习使用这些框架来构建网络应用程序。 1. 什么是Streamlit&#xff1f; Streamlit是一个免费且开源的框架&#xff0c;用于快速构建和共享美观的机器…
阅读更多...
[小程序]定位功能实现

[小程序]定位功能实现

第一步:首先要认识三个小程序的 api wx.chooseLocation 和 wx.getLocation 和 wx.openLocation (1).wx.chooseLocation 用于在小程序中选择地理位置。当用户点击选择位置按钮时&#xff0c;小程序会调起地图选择界面&#xff0c;用户可以在地图上选择一个位置&#xff0c;并可以…
阅读更多...
ubuntu连接xshell怎么连接

ubuntu连接xshell怎么连接

在网上找了好多办法都不行 例如 太久没打开Ubuntu可能输入命令查不到IP地址&#xff0c;解决办法也比较简单&#xff0c;首先第一步 确定自己能不能进入管理员root权限&#xff08;输入命令su&#xff09;&#xff0c;如果没有的话得重新配置&#xff0c;如下图 这是因为当前Ub…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023