openGauss数据库段页式与代码走读

2024年 3月 15日 31.6k 0

一些概念

段页式存储是一种在数据库系统中常见的存储管理方式,它将数据库中的存储空间按照一定的规则组织成不同的段(segments)来进行管理。所有的表都在一个文件中,解决文件句柄过多,磁盘存在上限等问题。

扩展区块(Extent)(物理概念)

一段连续的物理存储空间,用于存放存放部分数据的容器。一共有四种尺寸64K、1M、8M、64M。正好在段空间内的2 3 4 5文件内存放。里边存放的就是page。

段页式存储文件(段空间)(物理概念)

    [carrot@dev-openeuler-arm 15797]$ ll
    total 147M
    -rw------- 1 carrot carrot 128M Feb 23 11:02 1
    -rw------- 1 carrot carrot 128M Feb 23 11:02 2
    -rw------- 1 carrot carrot 128M Feb 23 11:02 2_fsm
    -rw------- 1 carrot carrot 128M Feb 23 11:02 3
    -rw------- 1 carrot carrot 128M Feb 23 11:02 3_fsm
    -rw------- 1 carrot carrot 128M Feb 23 11:02 4
    -rw------- 1 carrot carrot 128M Feb 23 11:02 4_fsm
    -rw------- 1 carrot carrot 128M Feb 23 11:02 5
    -rw------- 1 carrot carrot 128M Feb 23 11:02 5_fsm
    -rw------- 1 carrot carrot 4.0K Feb 23 10:59 pg_filenode.map
    -rw------- 1 carrot carrot 4.0K Feb 23 10:59 pg_filenode.map.backup
    -rw------- 1 carrot carrot    4 Feb 23 10:59 PG_VERSION

    • 其中的 1 ~ 5 就是段页式文件,是物理的文件。

    • 1号文件存放的是segmentHeader,不存放数据。

    • 2 ~ 5 几个物理文件之中存放的是一个个的extent(扩展块),不同文件存放不同尺寸的扩展块(Extent),同一个文件之中的扩展块可能来自于不同的表。

    • 文件空间不够的话,每次会扩展128M。

    段(Segment)(逻辑概念)

    段页式中,一个段就是一个表。

    一个表由多个扩展区块组成,扩展逻辑如下:

       尺寸     数量    容量   | 单extent页面容量  页面容量    累计容量   累计页面容量 
      [ 64K ] *  16个 = 1M     | 8                 128         1M         128          
      [ 1M  ] * 127个 = 127M   | 128               16256       128M       16384        
      [ 8M  ] * 112个 = 896M   | 1024              114688      1GB        131072      
      [ 64M ] *  ∞ 个 =        | 8192                                                

      • 当向表中插入数据但空间不足时,每次会扩展一个Extent,先扩展的extent大小为64K,16个之后为1M,最大是64M…先小后大。

      • 因此我们知道一个page的页号,就可以很轻易地算出来属于那个extent,且这个extent的尺寸是多大。

      • 注意:每个表最大支持是32TB,因此64M extent并不是无穷的。

      SegmentHeader 与 BMT(Block Map Tree)

      一个表由多个extent组成,这些extent之间物理上是不连续的,因此我们需要有一个结构来记录表上都有哪些extent,这个结构便是BMT。

      一个表会有一个BMT,用于存放自己的extent列表。

      从上边的扩展逻辑可以看出,实际上只需要一个int数组即可。已知一个表最大是32TB,可以算出一共需要大概513K个extent,每个extent只需要一个uint来作为ID即可。

      513K个uint一共占用2M+空间。但是数据库页面只有8K,因此这里并不能是一个连续的物理地址。

        typedef blockNumber extentPos;               页面号也可以直接作为extent的位置,也可以认为就是extetId。(代码中没有这个typedef,都用的blockNumber,但这么理解好理解)




        // SegmentHeader,表的元数据,占用一个页面刚好
        struct SegmentHeader {


            extentPos level0_slot[1255];             能直接存在当前页面的extentid最多只有
          blockNumber level1_slots[256];           剩下的存不下的,存在其他的页面内,这里存放页面的id。
           
           blockNumber fork_head[];                 其他fork的SegmentHeader所在的页面
        };




        // 能存放2000的extentid,大小刚好8000B,占用一个页面刚好。
        struct BMTLevel0Page {
           uint64 magic
            extentPos slots[2000];
        }

        可以看到这里几个结构体的主要思想之一就是,每个结构体刚好一个页面。所以无论是extent、SegmentHeader、BMTLevel0Page,其位置都可以通过页面号来确定,也就是blockNumber。

        BMT就是level0、level1组成的东西,与其叫树,不如叫一个二维数组,或者叫做组列表,level1就是组。

        如何根据BlockNumber找到页面具体位置

        假如我们现在需要找BlockNumber为185172567的页面。

        1、pg_class内获取SegmentHeader所在的页面id,读取文件1获得SegmentHeader

        2、计算185172567页面所在的extent是哪一个

          pageid = 185172567


          已知16个64Kextent共可存储128个页面,累计到127个1Mextent可存储16384个页面, 累积到112个8Mextent共可存储131072页面。


          pageid > 131072, 因此可知这个页面是在64M的extent之中,也就是在段页式文件5之中。


          (pageid - 131072) 8192 = 22588 ... 599 可以知道他在第22588个64Mextent中的599个页面


          16 + 127 + 112 + 22588 = 22843,第22588个64Mextent中也就是第22843个extent


          SegmentHeader中直接存储的只有前1255个extentPos,因此我们需要通过level1去寻找。


          (22843 - 1255 = 21588) 2000 = 10 ... 1588;每个BMTLevel0Page存储2000个extentPos,因此他在level1_slot[10]所标识的组里,是第1588个




          根据SegmentHeader.level1_slots[10]找到对应的页面,类型转换为BMTLevel0Page




          extentPos extentpos = BMTLevel0Page.slots[1588]

          综上可知,BlockNumber为185172567的页面所在的位置为:段页式文件5,偏移量为extentpos的extent,里边的第599个页面。在代码里,这个位置使用结构体SegPageLocation来表示,里边的三个变量就是上面三个变量。

          这里随手写了个段页式计算器,一个html,计算是js完成的,代码保存到本地然后浏览器打开即可。

          一个随手写的计算器




             
             
             段页式计算器
             
               /* CSS样式 */
               body {
                 font-family: Arial, sans-serif;
                 background-color: #f4f4f4;
                 padding: 20px;
               }
               .container {
                 max-width: 1200px; * 设置最大宽度 */
                 margin: 0 auto; * 水平居中 */
                 background-color: #fff; * 设置背景颜色 */
                 padding: 20px;
                 border-radius: 8px; * 设置圆角边框 */
                 box-shadow: 0 0 10px rgba(0, 0, 0, 0.1); * 设置阴影效果 */
               }
               .result_container {
                 max-width: 1150px; * 设置最大宽度 */
                 background-color: #fff; * 设置背景颜色 */
                 margin: 10px 0;
                 padding: 10px;
                 border-radius: 8px; /* 设置圆角边框 */
                 box-shadow: 0 0 10px rgba(0, 0, 0, 0.1); /* 设置阴影效果 */
               }
               h2 {
                 text-align: center;
                 margin-bottom: 20px;
               }
               input[type="text"] {
                 width: 1080px;
                 padding: 10px;
                 margin: 10px 0;
                 border-radius: 5px;
                 border: 1px solid #ccc;
               }
               button {
                 padding: 10px 20px;
                 background-color: #4caf50;
                 color: white;
                 border: none;
                 border-radius: 5px;
                 cursor: pointer;
               }
               button:hover {
                 background-color: #45a049;
               }
               .input-and-button {
                 display: flex;
                 align-items: center;
               }
               .input-container {
                 flex: 1;
                 margin-right: 5px;
               }
               #result_title {
                 margin-top: 10px;
                 font-weight: bold;
               }
             


             
               返回首页

               

            段页式计算器


               
               
                 
                   
                 
                 计算
               
               

            计算结果:


               
                   逻辑页号:
                   

                   

                   Extent 类型:
                   

                   Extent ID:
                   

                   Extent offset:
                   

                   Block offset:
                   

                   

                   BMT位置:


               
             
             
               function convertNumber() {
                   let inputNumber = document.getElementById('inputNumber').value;
                   if (!/^[0-9]+$/.test(inputNumber)) {
                       document.getElementById('blockid').innerText = `输入错误,请输入数字`;
                       return;
                   }
                   
                   // 逻辑页号
                   let blockid = parseInt(inputNumber, 10);
                   if (blockid 2000000000) {
                      document.getElementById('blockid').innerText = `暂不支持的blockid范围。[0, 2000000000]`;
                       return;
                   }
                   document.getElementById('blockid').innerText = blockid;






                    // extent信息:
                    // extent类型:64k1M8M64M
                    // extentid:第几个extent
                    // 第几个type extent
                   const EXT_SIZE_8_BOUNDARY = 16;
                   const EXT_SIZE_8_TOTAL_PAGES = 128;
                   const EXT_SIZE_8 = 8;
                   
                   const EXT_SIZE_128_BOUNDARY = 143;
                   const EXT_SIZE_128_TOTAL_PAGES = 16384;
                   const EXT_SIZE_128 = 128;
                   
                   const EXT_SIZE_1024_BOUNDARY = 255;
                   const EXT_SIZE_1024_TOTAL_PAGES = 131072;
                   const EXT_SIZE_1024 = 1024;
                   
                   const EXT_SIZE_8192 = 8192;
                   
                   
                   let logic_id = blockid;
                   let extent_type = '';
                   let extent_id = 0;
                   let extent_offset = 0;
                   let block_offset = 0;


                   if (logic_id < EXT_SIZE_8_TOTAL_PAGES) {
                        extent_type = 'Extent size 64KB, Capacity 8 pages, File name 2';
                       extent_id = Math.floor(logic_id / EXT_SIZE_8);
                       extent_offset = extent_id;
                       block_offset = logic_id % EXT_SIZE_8;
                   } else if (logic_id < EXT_SIZE_128_TOTAL_PAGES) {
                        extent_type = 'Extent size 1MB, Capacity 128 pages, File name 3';
                       logic_id -= EXT_SIZE_8_TOTAL_PAGES;
                       extent_offset = Math.floor(logic_id / EXT_SIZE_128);
                       extent_id = EXT_SIZE_8_BOUNDARY + extent_offset;
                       block_offset = logic_id % EXT_SIZE_128;
                   } else if (logic_id < EXT_SIZE_1024_TOTAL_PAGES) {
                        extent_type = 'Extent size 8MB, Capacity 1024 pages, File name 4';
                       logic_id -= EXT_SIZE_128_TOTAL_PAGES;
                       extent_offset = Math.floor(logic_id / EXT_SIZE_1024);
                       extent_id = EXT_SIZE_128_BOUNDARY + extent_offset;
                       block_offset = logic_id % EXT_SIZE_1024;
                   } else {
                        extent_type = 'Extent size 64MB, Capacity 8192 pages, File name 5';
                       logic_id -= EXT_SIZE_1024_TOTAL_PAGES;
                       extent_offset = Math.floor(logic_id / EXT_SIZE_8192);
                       extent_id = EXT_SIZE_1024_BOUNDARY + extent_offset;
                       block_offset = logic_id % EXT_SIZE_8192;
                   }


                   document.getElementById('extent_type').innerText = extent_type;
                   document.getElementById('extent_id').innerText = extent_id;
                   document.getElementById('extent_offset').innerText = extent_offset;
                   document.getElementById('block_offset').innerText = block_offset;
                   
                   
                   // BMT位置信息:
                   // level0[]
                   // level1[]->[]
                   const level0_capacity = 1255;
                   const level1_length = 256;
                   const level1_capacity = 2000;
                   if (extent_id < level0_capacity) {
                       document.getElementById('bmt_pos').innerText = `SegmentHead.level0[${extent_id}].block_offset[${block_offset}]`;
                   } else {
                        let left_extents = extent_id - level0_capacity;
                       
                        let level1_id = Math.floor(left_extents / level1_capacity);
                        let level1_0_id = left_extents % level1_capacity;
                       document.getElementById('bmt_pos').innerText = `SegmentHead.level1[${level1_id}].level0[${level1_0_id}].block_offset[${block_offset}]`;
                   }
               }


             



            相关文章

            Oracle如何使用授予和撤销权限的语法和示例
            Awesome Project: 探索 MatrixOrigin 云原生分布式数据库
            下载丨66页PDF,云和恩墨技术通讯(2024年7月刊)
            社区版oceanbase安装
            Oracle 导出CSV工具-sqluldr2
            ETL数据集成丨快速将MySQL数据迁移至Doris数据库

            发布评论