Postgres 的并行扫描源码分析

最新推荐文章于 2024-04-27 17:30:34 发布
最新推荐文章于 2024-04-27 17:30:34 发布
阅读量477 收藏 1
点赞数 1
文章标签： 队列 java python 数据库 编程语言
原文链接：https://mp.weixin.qq.com/s?__biz=MzI2NjYwOTAyMg==&mid=2247487831&idx=2&sn=83a4deebb5ce39fa236e3281d129831b&chksm=ea8ad946ddfd5050c4c2d934cd55cf66d3043722d8f04fd5433877f63dc08d143b576507fc8c&scene=126&&sessionid=0
版权

大家好，我是 「微扰理论」，目前在 Hashdata 担任数据库内核研发工程师。

前言

在计算机和半导体产业发展了许多年之后，摩尔定律已经越来越接近于理论上的物理极限；免费的午餐结束了。而为了继续提高计算机的性能，处理器厂商纷纷引入了多核架构。

为了更好地利用现代多核架构下的计算资源；PG 9.6 也终于正式引入并行查询的能力；其中并行顺序扫描 (parallel sequential scan) 则是 PG 引入的第一个并行化的算子。在 PG 9.6 之前，PG 开发者们也花了几年的时间去讨论和构建支持并行化的一些基础设施；包括动态共享内存、共享内存队列、后台工作进程等；我们在之前的文章中已经进行了相关内容的介绍。在最近发布的 PG 15 中，大部分只读的算子都已经部分或全部支持了并行化。6c2bcd1b28257598b54585c19c0e957a.png微扰酱最近的主要工作都集中在 PG 并行化算子实现的调研上，今天就来分享一下 PG 中最简单也是最早被支持的并行顺序扫描算子的实现细节。

一个简单的例子

首先我们来看一个简单的例子；这个例子也是微扰酱这几天调试代码反复使用的查询语句。

-- encourage use of parallel plans
postgres=# set parallel_setup_cost=0;
postgres=# set parallel_tuple_cost=0;
postgres=# set min_parallel_table_scan_size=0;
postgres=# set max_parallel_workers_per_gather=4;

-- prepare test table
postgres=# create table test(t int);
postgres=# insert into test select * from generate_series(1, 1000);

-- explain the query
postgres=# explain select * from test;
                             QUERY PLAN
---------------------------------------------------------------------
 Gather  (cost=0.00..9.17 rows=1000 width=4)
   Workers Planned: 2
   ->  Parallel Seq Scan on test  (cost=0.00..9.17 rows=417 width=4)
(3 rows)

正常来说，在比较小的表中，PG 是不会生成并行的查询计划的；所以为了使得 PG 生成并行查询计划，我们设置了几个相关的 GUC 值；包括：

  • parallel_setup_cost 是初始化并行环境的成本；在 PG 中默认设置为1000，是一个很大的值。

  • parallel_tuple_cost 是并行扫描每个元组的成本。

  • min_parallel_table_scan_size 是表扫描启用并行化的最低阈值；默认为 8 MB。

  • max_parallel_workers_per_gather 是 gather 操作的最大并行度。

这样，在生成的查询计划中，我们就可以看到 Workers Planned: 2 了；这意味着整个查询计划有两个 worker 参与扫描。由于查询计划最上层是 Gather 算子，根据火山模型，整个查询便由 Gather 驱动。Gather 算子于 leader 进程上执行，从共享内存中的队列获取由另外两个工作进程放入的消息并从中解析出元组信息，通过 shm_mq_receive 实现；两个工作进程则依次启动并对数据表竞争读，将元组打包成消息放入队列中，通过 shm_mq_send 实现 。

下面，我们读具体过程进行详述。先贴上在 leader 进程、 worker 进程和 master 进程中执行的一些关键函数和调用关系并提供了详细的注释；供大家对照后文阅读。

执行器调用过程

  • leader

ExecGather()
 // 这里生成工作进程的计划；在本例中 worker 进程最顶层的算子为 SeqScan
 ExecInitParallelPlan()
  ExecParallelInitializeDSM()
   ExecSeqScanInitializeDSM()
 LaunchParallelWorkers() // 这一步将创建工作进程
  foreach work loop:
   RegisterDynamicBackgroundWorker()
    SendPostmasterSignal // 通知 postmaster；由 postmaster 创建工作进程
 // setup tuple queue readers to read results
 ExecParallelCreateReaders()
 // 获取下一条数据
 gather_getnext()
  while (gatherstate->nreaders > 0 || gatherstate->need_to_scan_locally)
   gather_readnext() // 从某个 reader 读取一个元组
    for(;;)
     // 轮询 reader，读完一个再读下一个； 如果某个 reader 未能成功初始化，则不返回任何元组
     reader = gatherstate->reader[gatherstate->nextreader] 
     TupleQueueReaderNext() // 从 queue reader 里获取元组
      shm_mq_receive() // 从 queue 中获取一条消息
       // try read
       while (!mqh->mqh_length_word_complete)
        res = shm_mq_receive_bytes()
     // 如果当前 reader 被 detach 了，移除当前reader；如果所有全部完成，需要关闭 workers
     if (readerdone) 
      if (gatherstate->nreaders == 0)
       ExecShutdownGatherWorkers()
        ExecParallelFinish()
         // 需要等待工作进程结束；似乎是通过工作进程调用 pq_putmessage('X', NULL, 0) 完成的
         WaitForParallelWorkersToFinish()
     if (tup) return tup
     // tuple 为空不阻塞；尝试读下一个 reader
     gatherstate->nextreader++ 
 // 返回投影
 return ExecProject()

  • worker

ParallelWorkerMain()
 dsm_attach() // 绑定到 dsm segment
  dsm_create_descriptor()
 shm_toc_attach()
 // set parallel state
 shm_toc_lookup(toc, PARALLEL_KEY_FIXED, false)
 before_shmem_exit(ParallelWorkerShutdown, PointerGetDatum(seg)) // 注册退出回调函数
 // attach error queue
 shm_mq_set_sender()
 shm_mq_attach(mq, seg, NULL)
 // send BackendKeyData message
 pq_beginmessage(&msgbuf, 'K');

 // restore database connection
 BackgroundWorkerInitializeConnectionByOid()
 // restore state; protected by transaction
 RestoreLibraryState()
 RestoreGUCState()
 RestoreComboCIDState()

 // attach per-session segment
 AttachSession()
 RestoreTransactionSnapshot()
 
 ...

 EnterParallelMode()

 entrypt(seg, toc); // actuall is ParallelQueryMain
  // setup DestReceiver, SharedExecutorInstrumentation and QueryDesc
  ExecParallelGetReceiver() // 这一步很重要，后面 tqueueReceiveSlot 要用
  shm_toc_lookup(toc, PARALLEL_KEY_INSTRUMENTATION, true)
  ExecParallelGetQueryDesc()

  // 执行器初始化
  ExecParallelInitializeWorker()
    ExecSeqScanInitializeWorker()
     table_beginscan_parallel()
      RestoreSnapshot() // 从序列化的快照中恢复快照
      relation->rd_tableam->scan_begin()
  // prepare to track buffer/WAL usage
  InstrStartParallelQuery()
  // 正式执行
  ExecutorRun()
   standard_ExecutorRun()
    ExecutePlan()
     for(;;)
      ExecProcNode() // obtain a tuple
       ExecProcNodeFirst()
        ExecSeqScan()
         ExecScan()
          ExecScanFetch()
           SeqNext()
            table_scan_getnextslot()
             heap_getnextslot()
              heapgettup_pagemode()
               page = table_block_parallelscan_nextpage()
                // 当前 page 没有被读完
                if (pbscanwork->phsw_chunk_remaining > 0)
                 nallocated = ++pbscanwork->phsw_nallocated;
                // 当前 page 被读完
                else
                 nallocated = pg_atomic_fetch_add_u64(&pbscan->phs_nallocated, pbscanwork->phsw_chunk_size)
               heapgetpage()
              pgstat_count_heap_getnext()
      if (!dest->receiveSlot(slot, dest)) // actually tqueueReceiveSlot
       shm_mq_send()
    dest->rShutdown(dest)
  // 关闭执行器
  ExecutorFinish()
  // 获取 instrumentation 后必须执行
  ExecutorEnd()
  // clean
  dsa_detach()
  
 ExitParallelMode()
 DetachSession()
 // report success
 pq_putmessage()

  • postmaster

// 循环等待事件即可；在合适的时机 fork 出 worker 进程。
PostmasterMain()
 ServerLoop()
  sigusr1_handler()
   maybe_start_bgworkers()
    do_start_bgworker()
     fork_process()

Leader 进程和 Worker 进程

对于例子中简单的查询语句，整个查询树只有两层结构，在整个查询的执行过程中我们一共需要关注3个进程；分别是 master 进程、 leader 进程和 worker 进程。在执行过程中执行 ps 命令即可查询到这三种进程，我们分别用红色、蓝色和绿色标出。8a02f63d27f8d517cfc5b309edf67d8d.png其中，leader 进程和非并行化的算子一样，本质上是用户连接 PG 后 fork 出来用于处理查询的进程；只不过在并行化算子中，为了和 worker 进程区分，我们这里就称为 leader 进程。Worker 进程的发起，也是由 leader 进程控制的。

但是 leader 进程本身并不能直接 fork 出 worker 进程，而是需要通过给 master 进程发信号再由 master 进程 fork 的方式进行。

在 master 进程中，由 ServerLoop() 负责等待信号，如果发现是要求 fork worker 进程的信号，就会进行相应的后台工作进程的启动工作；再 fork_process 调用之后，worker 进程就产生并立刻进入初始化和后续的扫描工作。

而他们之间的通信主要通过动态共享内存和在此之上建立的消息队列实现；错误上报、扫描元组的传递都是通过该机制实现的；底层是一个无锁环形队列，实现非常巧妙，我们之后有机会展开讨论。

Worker 进程创建过程

那 worker 进程具体是如何被创建的呢？我们先来看看 PG 执行器收到的查询计划的结构。

Gather [startup_cost=0 total_cost=9.1666666666666679 plan_rows=1000 plan_width=4 parallel_aware=false parallel_safe=false async_capable=false plan_node_id=0]
       [num_workers=2 rescan_param=0 single_copy=false invisible=false initParam=0x0]
 [targetlist]
  TargetEntry [resno=1 resname="t" resorigtbl=24576 resorigcol=1]
   Var [varno=-2 varattno=1 vartype=23 varnosyn=1 varattnosyn=1]
 [lefttree]
  -> SeqScan [startup_cost=0 total_cost=9.1666666666666679 plan_rows=417 plan_width=4 parallel_aware=true parallel_safe=true async_capable=false plan_node_id=1
              extParam=0x00000001 allParam=0x00000001]
             [scanrelid=1]
             []
   [targetlist]
    TargetEntry [resno=1]
     Var [varno=1 varattno=1 vartype=23 varnosyn=1 varattnosyn=1]

计划的最上层是 Gather ；所以在执行器开始执行的时候，leader 进程首先就会从 ExecGather 开始进行执行操作，而这个时候，worker 进程其实还没有被创建。848b25402fda946716303343750e62b7.png真正地创建是在执行 ExecGather 的过程中发生的；如果 leader 进程执行过程中发现并行上下文尚未完成初始化，且计划器计划的并行工作进程数量大于0；则需要进行相应的并行进程初始化工作。

在 ExecInitParallelPlan() 调用的过程中，我们也会初始化 worker 进程所需要的查询计划，放入 node->pei 中，并通过共享内存同步给 worker 进程。随后，通过调用 LaunchParallelWorkers()  准备 worker 进程启动所需要的一些信息并发送信号给 master 要求 fork worker 进程。

在这个过程里， leader 也会负责将队列信息和 worker 进程的信息绑定在一起。

for (i = 0; i < pcxt->nworkers_to_launch; ++i)
 {
  memcpy(worker.bgw_extra, &i, sizeof(int));
  if (!any_registrations_failed &&
   RegisterDynamicBackgroundWorker(&worker,
           &pcxt->worker[i].bgwhandle))
  {
   shm_mq_set_handle(pcxt->worker[i].error_mqh,
         pcxt->worker[i].bgwhandle);
   pcxt->nworkers_launched++;
  }
}

而 worker 进程启动的时候就可以从共享内存中获取 bgw_extra。

void
ParallelWorkerMain(Datum main_arg)
{
 memcpy(&ParallelWorkerNumber, MyBgworkerEntry->bgw_extra, sizeof(int));
}

从而获取当前的消息队列应该是哪一个；通过调用 ExecParallelGetReceiver 可关联 shm_mq。

static DestReceiver *
ExecParallelGetReceiver(dsm_segment *seg, shm_toc *toc)
{
 char    *mqspace;
 shm_mq    *mq;

 mqspace = shm_toc_lookup(toc, PARALLEL_KEY_TUPLE_QUEUE, false);
 mqspace += ParallelWorkerNumber * PARALLEL_TUPLE_QUEUE_SIZE;
 mq = (shm_mq *) mqspace;
 shm_mq_set_sender(mq, MyProc);
 return CreateTupleQueueDestReceiver(shm_mq_attach(mq, seg, NULL));
}

最后，整个唤起进程的过程中可能会失败，所以实际唤起的工作进程数量可能是少于预期的；不过这并不会构成问题。

多个进程是如何协同扫描的？

现在我们来介绍多个进程是如何一起扫描的。在微扰酱一开始的猜测里，扫描可能是由 Planner 事先分配好每个进程的扫描的范围；然后并发协同扫描的。而这样，显然会导致多个进程扫描时产生一定的乱序，从而导致读性能下降，看起来不太可取。

那 PG 具体是如何做的呢？

事实上，PG 的做法是让多个进程竞争地顺序读数据表。其实现则依赖于在共享内存中存储的变量 ParallelBlockTableScanDesc 。它是被多个 worker 进程共享并用于控制目前扫描进行到哪一页的描述符。

多个进程扫描获取下一个元组的时候首先会去获取一批页，通过原子操作更新共享内存中的描述符实现互斥；如果进程获取的页没读完，则会先将获取的页中的元组全部读出，后再次申请新的页；核心代码如下。

BlockNumber
table_block_parallelscan_nextpage(Relation rel,
          ParallelBlockTableScanWorker pbscanwork,
          ParallelBlockTableScanDesc pbscan)
{
   nallocated = pbscanwork->phsw_nallocated =
   pg_atomic_fetch_add_u64(&pbscan->phs_nallocated,
         pbscanwork->phsw_chunk_size);
}

因此，并发扫描的粒度是以页为单位的。在一部分进程因为一些原因被阻塞的情况下，其他进程，则可以继续后续页中的数据。所有 worker 进程读出的数据都会通过共享内存队列发送给 leader 进程。Leader 进程也会循环读取每个队列中的数据，如果其中有队列中没有新的数据并不会阻塞，而是直接跳过当前进程继续读后续队列的数据。

这样，在并发读的过程中，由于有文件系统基于窗口的预读机制，在大部分情况下和严格顺序读的磁盘性能差距并不明显。

并发顺序扫描的意义？

写到这里，不知道读者会不会产生一个疑问；既然并发顺序读本身并不能提高 IO 本身的效率，甚至引入了一些额外的初始化和竞争的开销；那并发顺序扫描的算子到底有什么意义呢？

我们知道，并发主要释放的还是 CPU 的计算能力，尤其是在多核的场景下；而顺序扫描本身其实是一个纯 IO 的场景，在例子中非常简单的查询语句下其实确实是不能发挥什么优势的。但是如果你的查询语句比较复杂，涉及过滤、聚合等运算，那每个进程在获取数据之后就要进行许多诸如哈希计算这样耗费 CPU 计算资源的操作；并发的意义就得以体现了。看网上流传的一些评测数据中，在启用并发度为4的连接查询时，通常也能达到接近于4倍的效率提升。15797e4e9e6e067143e6fde8b06f2a5a.png而并发顺序扫描的意义就是为后续的其他并行算子提供基础。正如微扰酱的这篇文章也是后续研究其他算子的基础；大家的点赞、关注、转发也能让微扰酱有更可持续的写作基础一样。

参考链接

[1]. PostgreSQL 并行表扫描分析 Gather Parallel Seq Scan https://www.mytecdb.com/blogDetail.php?id=22

[2]. Parallel Hash for PostgreSQL https://www.enterprisedb.com/blog/parallel-hash-postgresql

[3]. Parallelism in PostgreSQL 11 https://2019.pgdu.org/static/presentations/Thomas-parallelism-postgresql-11.pdf

[4]. Using gdb to trace into a parallel worker spawned by postmaster during a large query https://www.highgo.ca/2021/07/09/using-gdb-to-trace-into-a-parallel-worker-spawned-by-postmaster-during-a-large-query/

结语

计算机是一门需要动手实践才能掌握的学科，想了解数据库最好的方式莫过于加入一家不错的公司啦；欢迎大家找我内推 hashdata；入职即享20天年假，优秀更可远程办公，快私信微扰酱一键内推吧～

guangcheng0312q
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
postgres内核源码分析实验环境配置导读.pptx
09-22
postgres内核源码分析实验环境配置导读.pptx
PostgreSQL · 实现分析 · PostgreSQL 10.0 并行查询和外部表的结合
weixin_34152820的博客
05-21 279
前言 大家都知道，PostgreSQL 近几大版本中加入了很多 OLAP 相关特性。9.6 的并行扫描应该算最大的相关特性。在今年发布的 10.0 中，并行扫描也在不断加强，新增了并行的索引扫描。 我们知道并行扫描是支持外部数据源的。在云上，有很多存储存储产品可以以外部数据源的形式做数据库的外部存储。例如，阿里云的 OSS 和 AWS 的 S3 都是...
PostgreSQL9.6：Parallel sequential scans 初体验
weixin_33682719的博客
11-05 193
Oracle 支持强大的并行功能，创建索引，表分析，数据加载时可以开启并行，这项功能让很多数据库产品垂涎， 作为开源数据库 PostgreSQL 在并行方面也在努力尝试，很早之前 PostgreSQL 几乎不支持任何并行的作业，到了 9.5 版本 PostgreSQL 支持并行的 vacuum，到了 9.6 后， PostgreSQL 支...
并发标记扫描（CMS）收集器（待完成）
weixin_34198583的博客
09-01 166
并发标记扫描（CMS）收集器专为需要较短垃圾收集暂停时间且能够在应用程序运行时与垃圾收集器共享处理器资源的应用程序而设计。 对于任何暂停时间要求较低的应用程序，应考虑使用此收集器。 使用命令行选项启用CMS收集器-XX:+UseConcMarkSweepGC。 与其他可用的收集器类似，CMS收集器是分代的;;因此，小型和主要收集都会发生 CMS收集器尝试通过使用单独的垃圾收集器线程...
2. postgresql并行扫描（1）——pg强制走并行扫描建表及参数配置
Orange_Wu的博客
09-03 938
pg强制执行的配置，以及pg索引扫描的核心
索引并行扫描
ciliting2867的博客
11-18 116
After the optimizer determines the execution plan of a statement, the parallelexecution coordinator determines the...
Postgres-XL源码安装包
08-01
Postgres-XL源码安装包 用法详见博客文章： https://blog.csdn.net/fm0517/article/details/81329309
postgres数据库数据探查
07-20
本资源使用python进行编写，解压后在pycharm中进行使用，该探查数据库适用于postgres数据库，运行结束后以.xlsx格式进行保存，探查的内容有：数据库名称、数据表名称、数据表注释、排序、字段名称、字段注释、字段...
Postgres节点并行测试方案示例
02-14
Postgres节点并行测试方案示例
在 docker-compose 上使用 Postgres 的 SonarQube
03-01
在 docker-compose 上使用 Postgres 的 SonarQube
并行化处理扫描
qq_44099721的博客
12-15 265
#include "cuda_runtime.h" #include "device_launch_parameters.h" #include "device_functions.h" #include<stdio.h> #define ARRAY_SIZE 8 //一个block开8个线程 __global__ void global_scan(float*d_out, floa...
CUDA学习（二）：并行扫描Scan
qq_44161734的博客
11-29 712
扫描（Scan）通常也称之为前缀和，并行扫描算法在很多算法中都有起到非常重要的基础模块作用。并且扫描也包括了闭扫描和开扫描两种方式，其中闭扫描和开扫描的形式分别如下图所示：这种扫描、规约类的算法在计算过程中往往非常依赖其他元素，因此在并行的过程中往往存在着较大的困难。本文主要介绍的是基于Hillis Steele算法以及Blelloch算法的并行扫描算法，并且在这些算法的基础上解决任意长度的并行扫描问题。
ThreatScan-端口并发扫描的实现
DYBOY-程序开发&网络安全
08-25 1214
在不断完善ThreatScan这个项目时，遇到了不少的坑，当然也学习到不少，为此根据ThreatScan的实现，做一些关键功能实现的分享 [外链图片转存失败(img-mAdVzIov-1566712902419)(https://image.3001.net/images/20190409/15547995385184.png “图源freebuf”)] ThreatScan是一款扫描器，主要...
goroutine并发扫描MySQL表_Golang并发编程-Go程(Goroutine)实战篇
weixin_29266679的博客
02-15 238
Golang并发编程-Go程(Goroutine)实战篇作者：尹正杰版权声明：原创作品，谢绝转载！否则将追究法律责任。一.并行和并发概述1>.什么是并行(parallel)并行(parallel)：如下图所示,指在同一时刻，有多条指令在多个处理器上同时执行。2>.什么是并发(concurrency)并发(concurrency)：如下图所示,指在同一时刻只能有一条指令执行，但多个进程指...
linux并发端口扫描以及fork()函数的用法；
u011760453的专栏
03-26 614
#include #include #include #include #include #include #include #include #define maxda 200 using namespace std; string ip="210.45.240.71"; int pin=maxda/5; void start(int arg) { int arga= ar
通过多线程方式实现并发扫描存活主机
彭淦淦的博客
05-30 507
3.1 问题 创建mtping.py脚本，实现以下功能： 通过ping测试主机是否可达 如果ping不通，不管什么原因都认为主机不可用 通过多线程方式实现并发扫描 3.2 方案 subprocess.call ()方法可以调用系统命令，其返回值是系统命令退出码，也就是如果系统命令成功执行，返回0，如果没有成功执行，返回非零值。 调用Ping对象，可以调用系统的ping命令，通过退出码来判断是否ping通了该主机。如果顺序执行，每个ping操作需要消耗数秒钟，全部的254个地址需要10分钟以上。而采用多线程，
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 940
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
最新发布
m0_46053885的博客
04-27 884
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
Lambda表达式特点
weixin_57763462的博客
04-24 805
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
postgres 查询引擎源码分析
07-08
PostgreSQL 是一个开源的关系型数据库系统，其查询引擎的源码位于 `src/backend/executor` 目录下。分析 PostgreSQL 的查询引擎源码需要对数据库内部的架构和相关算法有一定的了解。 以下是一个简要的概述，供你开始分析 PostgreSQL 查询引擎源码时的参考： 1. 查询解析和转换：`parse_analyze.c` 文件中包含了将 SQL 查询语句解析为内部数据结构（Parse Tree）的代码。在这个阶段，PostgreSQL 还会进行一些语法和语义检查，处理子查询、联接、投影等操作。 2. 查询优化：查询优化器位于 `optimizer/` 目录下，其中最重要的文件是 `optimize.c`。该阶段的目标是根据查询的成本模型、统计信息和索引等，生成最佳的执行计划候选项。优化器会考虑不同的连接方式、索引选择、谓词下推等操作。 3. 执行计划生成：执行计划生成器位于 `executor/` 目录下，重要的文件包括 `execMain.c` 和 `execProcnode.c`。在这个阶段，PostgreSQL 根据最佳执行计划生成相应的执行代码，包括表的访问方式、连接方式、排序方式等信息。 4. 执行计划执行：执行计划执行器也位于 `executor/` 目录下，其中的 `execMain.c` 是入口文件。在这个阶段，PostgreSQL 执行生成的执行计划，并返回结果给用户。 对于更详细的源码分析，你可以深入研究相关文件和函数，并参考 PostgreSQL 的官方文档、邮件列表和社区讨论。此外，还有一些在线资源和书籍提供了关于 PostgreSQL 内部架构和查询引擎的深入解析，可以帮助你更好地理解和分析源码。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值