行存、列存，堆表、AO表性能对比 - 阿里云HDB for PostgreSQL最佳实践

最新推荐文章于 2022-07-29 16:15:27 发布
最新推荐文章于 2022-07-29 16:15:27 发布
阅读量623 收藏 2
点赞数
文章标签： 数据库 runtime 嵌入式
原文链接：https://yq.aliyun.com/articles/179210
版权

标签

PostgreSQL , GIS , PostGIS , Greenplum , 空间检索 , GiST , B-Tree , geohash

背景

《Greenplum 行存、列存，堆表、AO表的原理和选择》

以上文档详细的介绍了行存、列存，堆表、AO表的原理以及选择的依据。

《一个简单算法可以帮助物联网,金融 用户 节约98%的数据存储成本 (PostgreSQL,Greenplum帮你做到)》

以上文档介绍了提升基于列存的全局数据压缩比的方法。

《解密上帝之手 - 阿里云HDB for PostgreSQL数据库metascan特性(存储级、块级、batch级过滤与数据编排)》

以上文档介绍了局部编排，以及阿里云HDB for PostgreSQL数据库的metascan特性，（在不需要索引的情况下，如何提升任意列的选择性）。

压缩实际上是计算(CPU)换空间(磁盘)的做法，该不该做，我们还是先看看压缩比、性能损耗吧。

堆表

postgres=# create table t_heap(id int, c1 text, c2 int);  
CREATE TABLE  
  
postgres=# insert into t_heap select id, repeat(md5(random()::text), 128), random()*10000 from generate_series(1,10000000) t(id);  
INSERT 0 10000000  
Time: 120526.098 ms

某个维度count查询。

postgres=# explain analyze select c2,count(*) from t_heap group by c2;  
                                                                          QUERY PLAN                                                                             
---------------------------------------------------------------------------------------------------------------------------------------------------------------  
 Gather Motion 48:1  (slice2; segments: 48)  (cost=1578949.03..1579074.98 rows=10076 width=12)  
   Rows out:  10001 rows at destination with 1354 ms to end, start offset by 519 ms.  
   ->  HashAggregate  (cost=1578949.03..1579074.98 rows=210 width=12)  
         Group By: t_heap.c2  
         Rows out:  Avg 208.4 rows x 48 workers.  Max 223 rows (seg17) with 0.001 ms to first row, 692 ms to end, start offset by 581 ms.  
         ->  Redistribute Motion 48:48  (slice1; segments: 48)  (cost=1578596.37..1578797.89 rows=210 width=12)  
               Hash Key: t_heap.c2  
               Rows out:  Avg 10001.0 rows x 48 workers at destination.  Max 10704 rows (seg17) with 596 ms to end, start offset by 581 ms.  
               ->  HashAggregate  (cost=1578596.37..1578596.37 rows=210 width=12)  
                     Group By: t_heap.c2  
                     Rows out:  Avg 10001.0 rows x 48 workers.  Max 10001 rows (seg0) with 0.006 ms to first row, 131 ms to end, start offset by 566 ms.  
                     ->  Seq Scan on t_heap  (cost=0.00..1528595.58 rows=208337 width=4)  
                           Rows out:  Avg 208333.3 rows x 48 workers.  Max 208401 rows (seg18) with 26 ms to first row, 901 ms to end, start offset by 573 ms.  
 Slice statistics:  
   (slice0)    Executor memory: 359K bytes.  
   (slice1)    Executor memory: 724K bytes avg x 48 workers, 724K bytes max (seg0).  
   (slice2)    Executor memory: 388K bytes avg x 48 workers, 388K bytes max (seg0).  
 Statement statistics:  
   Memory used: 128000K bytes  
 Settings:  optimizer=off  
 Optimizer status: legacy query optimizer  
 Total runtime: 1874.143 ms  
(22 rows)  
  
Time: 1879.480 ms

无索引，某个单值查询

postgres=# explain analyze select * from t_heap where c2=1;  
                                                             QUERY PLAN                                                               
------------------------------------------------------------------------------------------------------------------------------------  
 Gather Motion 48:1  (slice1; segments: 48)  (cost=0.00..1553595.98 rows=980 width=40)  
   Rows out:  1001 rows at destination with 1489 ms to end, start offset by 1.419 ms.  
   ->  Seq Scan on t_heap  (cost=0.00..1553595.98 rows=21 width=40)  
         Filter: c2 = 1  
         Rows out:  Avg 20.9 rows x 48 workers.  Max 35 rows (seg6) with 21 ms to first row, 613 ms to end, start offset by 853 ms.  
 Slice statistics:  
   (slice0)    Executor memory: 295K bytes.  
   (slice1)    Executor memory: 230K bytes avg x 48 workers, 230K bytes max (seg0).  
 Statement statistics:  
   Memory used: 128000K bytes  
 Settings:  optimizer=off  
 Optimizer status: legacy query optimizer  
 Total runtime: 1490.889 ms  
(13 rows)  
  
Time: 1492.516 ms

有索引（IO放大），某个单值查询

create index idx_t_heap on t_heap(c2);  
  
explain analyze select * from t_heap where c2=1;  
  
postgres=# explain analyze select * from t_heap where c2=1;  
                                                               QUERY PLAN                                                                 
----------------------------------------------------------------------------------------------------------------------------------------  
 Gather Motion 48:1  (slice1; segments: 48)  (cost=107.99..95579.14 rows=980 width=40)  
   Rows out:  1001 rows at destination with 34 ms to end, start offset by 1.331 ms.  
   ->  Bitmap Heap Scan on t_heap  (cost=107.99..95579.14 rows=21 width=40)  
         Recheck Cond: c2 = 1  
         Rows out:  Avg 20.9 rows x 48 workers.  Max 35 rows (seg6) with 0.236 ms to first row, 0.959 ms to end, start offset by 19 ms.  
         ->  Bitmap Index Scan on idx_t_heap  (cost=0.00..107.74 rows=21 width=0)  
               Index Cond: c2 = 1  
               Bitmaps out:  Avg 1.0 x 48 workers.  Max 1 (seg0) with 0.169 ms to end, start offset by 19 ms.  
               Work_mem used:  168K bytes avg, 282K bytes max (seg6).  
 Slice statistics:  
   (slice0)    Executor memory: 303K bytes.  
   (slice1)    Executor memory: 901K bytes avg x 48 workers, 901K bytes max (seg0).  Work_mem: 282K bytes max.  
 Statement statistics:  
   Memory used: 128000K bytes  
 Settings:  optimizer=off  
 Optimizer status: legacy query optimizer  
 Total runtime: 35.093 ms  
(17 rows)  
  
Time: 37.198 ms

APPENDONLY 行存储、列存储

测试脚本如下

vi test.sql  
  
\timing  
  
-- 堆表  
create table t_heap(id int, c1 text, c2 int);  
  
insert into t_heap select id, repeat(md5(random()::text), 128), random()*10000 from generate_series(1,10000000) t(id);  
  
explain analyze select c2,count(*) from t_heap group by c2;  
  
explain analyze select * from t_heap where c2=1;  
  
create index idx_t_heap on t_heap(c2);  
  
explain analyze select * from t_heap where c2=1;  
  
-- AO 行存  
-- 不压缩, 8K  
  
create table t_ao_row_8k_0(id int, c1 text, c2 int) with (appendonly=true, blocksize=8192, ORIENTATION=row, COMPRESSTYPE=NONE, CHECKSUM=false);  
  
insert into t_ao_row_8k_0 select id, repeat(md5(random()::text), 128), random()*10000 from generate_series(1,10000000) t(id);  
  
explain analyze select c2,count(*) from t_ao_row_8k_0 group by c2;  
  
explain analyze select * from t_ao_row_8k_0 where c2=1;  
  
create index idx_t_ao_row_8k_0 on t_ao_row_8k_0(c2);  
  
explain analyze select * from t_ao_row_8k_0 where c2=1;  
  
-- 不压缩, 2M  
  
create table t_ao_row_2m_0(id int, c1 text, c2 int) with (appendonly=true, blocksize=2097152, ORIENTATION=row, COMPRESSTYPE=NONE, CHECKSUM=false);  
  
insert into t_ao_row_2m_0 select id, repeat(md5(random()::text), 128), random()*10000 from generate_series(1,10000000) t(id);  
  
explain analyze select c2,count(*) from t_ao_row_2m_0 group by c2;  
  
explain analyze select * from t_ao_row_2m_0 where c2=1;  
  
create index idx_t_ao_row_2m_0 on t_ao_row_2m_0(c2);  
  
explain analyze select * from t_ao_row_2m_0 where c2=1;  
  
-- 压缩比5, 8K  
  
create table t_ao_row_8k_5(id int, c1 text, c2 int) with (appendonly=true, blocksize=8192, ORIENTATION=row, COMPRESSTYPE=zlib, COMPRESSLEVEL=5, CHECKSUM=false);  
  
insert into t_ao_row_8k_5 select id, repeat(md5(random()::text), 128), random()*10000 from generate_series(1,10000000) t(id);  
  
explain analyze select c2,count(*) from t_ao_row_8k_5 group by c2;  
  
explain analyze select * from t_ao_row_8k_5 where c2=1;  
  
create index idx_t_ao_row_8k_5 on t_ao_row_8k_5(c2);  
  
explain analyze select * from t_ao_row_8k_5 where c2=1;  
  
-- 压缩比5, 2M  
  
create table t_ao_row_2m_5(id int, c1 text, c2 int) with (appendonly=true, blocksize=2097152, ORIENTATION=row, COMPRESSTYPE=zlib, COMPRESSLEVEL=5, CHECKSUM=false);  
  
insert into t_ao_row_2m_5 select id, repeat(md5(random()::text), 128), random()*10000 from generate_series(1,10000000) t(id);  
  
explain analyze select c2,count(*) from t_ao_row_2m_5 group by c2;  
  
explain analyze select * from t_ao_row_2m_5 where c2=1;  
  
create index idx_t_ao_row_2m_5 on t_ao_row_2m_5(c2);  
  
explain analyze select * from t_ao_row_2m_5 where c2=1;  
  
-- 压缩比9, 8K  
  
create table t_ao_row_8k_9(id int, c1 text, c2 int) with (appendonly=true, blocksize=8192, ORIENTATION=row, COMPRESSTYPE=zlib, COMPRESSLEVEL=9, CHECKSUM=false);  
  
insert into t_ao_row_8k_9 select id, repeat(md5(random()::text), 128), random()*10000 from generate_series(1,10000000) t(id);  
  
explain analyze select c2,count(*) from t_ao_row_8k_9 group by c2;  
  
explain analyze select * from t_ao_row_8k_9 where c2=1;  
  
create index idx_t_ao_row_8k_9 on t_ao_row_8k_9(c2);  
  
explain analyze select * from t_ao_row_8k_9 where c2=1;  
  
-- 压缩比9, 2M  
  
create table t_ao_row_2m_9(id int, c1 text, c2 int) with (appendonly=true, blocksize=2097152, ORIENTATION=row, COMPRESSTYPE=zlib, COMPRESSLEVEL=9, CHECKSUM=false);  
  
insert into t_ao_row_2m_9 select id, repeat(md5(random()::text), 128), random()*10000 from generate_series(1,10000000) t(id);  
  
explain analyze select c2,count(*) from t_ao_row_2m_9 group by c2;  
  
explain analyze select * from t_ao_row_2m_9 where c2=1;  
  
create index idx_t_ao_row_2m_9 on t_ao_row_2m_9(c2);  
  
explain analyze select * from t_ao_row_2m_9 where c2=1;  
  
-- AO 列存  
  
-- 不压缩, 8K  
  
create table t_ao_COLUMN_8k_0(id int, c1 text, c2 int) with (appendonly=true, blocksize=8192, ORIENTATION=COLUMN, COMPRESSTYPE=NONE, CHECKSUM=false);  
  
insert into t_ao_COLUMN_8k_0 select id, repeat(md5(random()::text), 128), random()*10000 from generate_series(1,10000000) t(id);  
  
explain analyze select c2,count(*) from t_ao_COLUMN_8k_0 group by c2;  
  
explain analyze select * from t_ao_COLUMN_8k_0 where c2=1;  
  
create index idx_t_ao_COLUMN_8k_0 on t_ao_COLUMN_8k_0(c2);  
  
explain analyze select * from t_ao_COLUMN_8k_0 where c2=1;  
  
-- 不压缩, 2M  
  
create table t_ao_COLUMN_2m_0(id int, c1 text, c2 int) with (appendonly=true, blocksize=2097152, ORIENTATION=COLUMN, COMPRESSTYPE=NONE, CHECKSUM=false);  
  
insert into t_ao_COLUMN_2m_0 select id, repeat(md5(random()::text), 128), random()*10000 from generate_series(1,10000000) t(id);  
  
explain analyze select c2,count(*) from t_ao_COLUMN_2m_0 group by c2;  
  
explain analyze select * from t_ao_COLUMN_2m_0 where c2=1;  
  
create index idx_t_ao_COLUMN_2m_0 on t_ao_COLUMN_2m_0(c2);  
  
explain analyze select * from t_ao_COLUMN_2m_0 where c2=1;  
  
-- 压缩比5, 8K  
  
create table t_ao_COLUMN_8k_5(id int, c1 text, c2 int) with (appendonly=true, blocksize=8192, ORIENTATION=COLUMN, COMPRESSTYPE=zlib, COMPRESSLEVEL=5, CHECKSUM=false);  
  
insert into t_ao_COLUMN_8k_5 select id, repeat(md5(random()::text), 128), random()*10000 from generate_series(1,10000000) t(id);  
  
explain analyze select c2,count(*) from t_ao_COLUMN_8k_5 group by c2;  
  
explain analyze select * from t_ao_COLUMN_8k_5 where c2=1;  
  
create index idx_t_ao_COLUMN_8k_5 on t_ao_COLUMN_8k_5(c2);  
  
explain analyze select * from t_ao_COLUMN_8k_5 where c2=1;  
  
-- 压缩比5, 2M  
  
create table t_ao_COLUMN_2m_5(id int, c1 text, c2 int) with (appendonly=true, blocksize=2097152, ORIENTATION=COLUMN, COMPRESSTYPE=zlib, COMPRESSLEVEL=5, CHECKSUM=false);  
  
insert into t_ao_COLUMN_2m_5 select id, repeat(md5(random()::text), 128), random()*10000 from generate_series(1,10000000) t(id);  
  
explain analyze select c2,count(*) from t_ao_COLUMN_2m_5 group by c2;  
  
explain analyze select * from t_ao_COLUMN_2m_5 where c2=1;  
  
create index idx_t_ao_COLUMN_2m_5 on t_ao_COLUMN_2m_5(c2);  
  
explain analyze select * from t_ao_COLUMN_2m_5 where c2=1;  
  
-- 压缩比9, 8K  
  
create table t_ao_COLUMN_8k_9(id int, c1 text, c2 int) with (appendonly=true, blocksize=8192, ORIENTATION=COLUMN, COMPRESSTYPE=zlib, COMPRESSLEVEL=9, CHECKSUM=false);  
  
insert into t_ao_COLUMN_8k_9 select id, repeat(md5(random()::text), 128), random()*10000 from generate_series(1,10000000) t(id);  
  
explain analyze select c2,count(*) from t_ao_COLUMN_8k_9 group by c2;  
  
explain analyze select * from t_ao_COLUMN_8k_9 where c2=1;  
  
create index idx_t_ao_COLUMN_8k_9 on t_ao_COLUMN_8k_9(c2);  
  
explain analyze select * from t_ao_COLUMN_8k_9 where c2=1;  
  
-- 压缩比9, 2M  
  
create table t_ao_COLUMN_2m_9(id int, c1 text, c2 int) with (appendonly=true, blocksize=2097152, ORIENTATION=COLUMN, COMPRESSTYPE=zlib, COMPRESSLEVEL=9, CHECKSUM=false);  
  
insert into t_ao_COLUMN_2m_9 select id, repeat(md5(random()::text), 128), random()*10000 from generate_series(1,10000000) t(id);  
  
explain analyze select c2,count(*) from t_ao_COLUMN_2m_9 group by c2;  
  
explain analyze select * from t_ao_COLUMN_2m_9 where c2=1;  
  
create index idx_t_ao_COLUMN_2m_9 on t_ao_COLUMN_2m_9(c2);  
  
explain analyze select * from t_ao_COLUMN_2m_9 where c2=1;  
  
select tablename, pg_size_pretty(pg_total_relation_size('postgres.'||tablename)) from pg_tables where schemaname='postgres';  

nohup psql -f ./test.sql > ./log 2>&1 &

结果对比

存储形态写入1000万耗时空间占用分组聚合单值多行查询(走全表)建索引耗时单值多行查询(走索引)
堆表120秒44GB1.8秒1.5秒13秒37毫秒
AO行存8K不压缩81秒1.3GB168毫秒96毫秒356毫秒32毫秒
AO行存2MB不压缩101秒39GB1.8秒1.7秒1.9秒158毫秒
AO行存8K压缩5级80秒557MB322毫秒269毫秒505毫秒54毫秒
AO行存2MB压缩5级104秒690MB1.6秒1.5秒1.7秒163毫秒
AO行存8K压缩9级80秒557MB331毫秒247毫秒500毫秒58毫秒
AO行存2MB压缩9级106秒690MB1.7秒1.38秒1.67秒162毫秒
AO列存8K不压缩92.6秒39GB362毫秒622毫秒877毫秒36毫秒
AO列存2MB不压缩98.8秒38GB140毫秒1.62秒1.8秒176毫秒
AO列存8K压缩5级83秒1.4GB125毫秒2.2秒2.5秒58毫秒
AO列存2MB压缩5级104秒593MB152毫秒1.37秒1.73秒189毫秒
AO列存8K压缩9级83秒1.4GB122毫秒2.3秒2.5秒62毫秒
AO列存2MB压缩9级106秒593MB136毫秒1.5秒1.77秒181毫秒

云端产品

阿里云 RDS PostgreSQL

阿里云 HybridDB for PostgreSQL

weixin_33923762
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
GreenPlum--表存储方式选择
唐僧洗头爱飘柔
05-06 1040
本文主要讨论的是GP中在创建表时可以选择的表的存储方式，有两类： 1、行存储，列存储 2、堆存储还是追加优化存储 首先我们来讨论一下行存和列存 行存储的具体形式： 行方向是传统的存储数据库元组的方式。 组成一行的列被连续地存储在磁盘上，因此整个行可以被以单次I/O从磁盘上读出。 行存储是行为单位存储数据，一行中越是靠后的列，那么查询需要的cost相对越大，这个以前oracle做过相应比较，都是一样...
PostgreSQL之堆表存储（Heap Table）
数据源的港湾
03-28 1987
SQL Server关于堆表的描述如下，没有聚集索引的表堆表在sys.partitions里有1条index_id = 0 的记录数据存储没有任何的顺序，插入数据也没顺序由于数据没有任何顺序，查询数据会非常慢数据页之间没有相互链接从数据页读取数据，需要从IAM（Index Allocation Map）页里找页号。
聊一聊数据库的行存与列存
hebiwen95的博客
07-29 1998
所以，列存储的解析过程更有利于分析大数据。同一列的数据，数据类型一致，列存的模式下就适合数据压缩，不同的列可以采用不同的压缩算法，压缩存储就会带来IO性能的提升。表的列数一般情况下，如果表的字段比较多即列数多（大宽表），查询中涉及到的列不多的情况下，适合列存储。1）行存储通常将一行数据完全取出，如果只需要其中几列数据的情况，就会存在冗余列，出于缩短处理时间的考量，消除冗余列的过程通常是在内存中进行的。而列存的时候，单个属性所有的值存储在临近的的空间，即一列的所有数据连续存储的，每个属性有不同的空间。...
《Postgresql学习笔记》——数据库集群、数据库和表
MasterLeon的博客
09-29 782
1.1 数据库集群的逻辑结构 1.2 物理结构
数仓知识10：数据库存储的两种方式-行存储和列存储
维克先生的博客
06-19 5111
目前大数据存储主要有两种方案可供选择：行存储（Row-Based）和列存储（Column-Based）。业界对两种方案有许多争持，争论的焦点是：谁能够更有效地处理海量数据，且兼顾安全、可靠、完整性。
藏经阁-阿里云数据库 PG、PPAS、HDB for PG 云生态、产品指南、企业全栈应用案例、开发管理实践.pdf
08-26
藏经阁-阿里云数据库 PG、PPAS、HDB for PG 云生态、产品指南、企业全栈应用案例、开发管理实践.pdf
德哥 _ 阿里云 - 阿里云数据库 PG、PPAS、HDB for PG 云生态、产品指南、企业全栈应用案例、开发管理实践
10-24
阿里云数据库 PostgreSQL、 PPAS、HDB for PG 云生态、产品指南、企业全栈应 用案例、开发管理实践
(完整word版)-matlab-HDB3编码译码数字通带调制解调.doc
11-24
(完整word版)-matlab-HDB3编码译码数字通带调制解调.doc
-matlab-HDB3编码译码数字通带调制解调.doc
最新发布
04-30
-matlab-HDB3编码译码数字通带调制解调.doc
Greenplum释放AO表SHELL脚本
10-17
Greenplum支持行储存(HEAP储存)与列(append-only)储存,对于AO存储，虽然是appendonly，但实际上GP是支持DELETE和UPDATE的，被删除或更新的行，通过BITMAP来标记删除与修改。AO存储是块级组织，当一个块内的数据大部分都被删除或更新掉时，扫描它浪费的成本实际上是很高的。而PostgreSQL是通过HOT技术以及autovacuum来避免或减少垃圾的。但是Greenplum没有自动回收的worker进程，所以需要人为的触发。接下来就分析AO表与HEAP表的问题以及如何解答，执行空间的释放有3中方法分别是: 1、执行VACUUM。（当膨胀率大于gp_appendonly_compaction_threshold参数时），为共享锁。 2、执行VACUUM FULL。（不管gp_appendonly_compaction_threshold参数的设置，都会回收垃圾空间。），为DDL锁，需要慎用这个命令，会把CPU与IO沾满。 3、执行重分布。（不管gp_appendonly_compaction_threshold参数，都会回收垃圾空间。），为DDL锁
代码干货 | 行存、列存_堆表、AO表性能对比-阿里云HDB for PostgreSQL最佳实践
CS13522431352的博客
08-28 1108
标签 PostgreSQL , GIS , PostGIS , Greenplum , 空间检索 , GiST , B-Tree , geohash 背景 《Greenplum 行存、列存，堆表、AO表的原理和选择》 以上文档详细的介绍了行存、列存，堆表、AO表的原理以及选择的依据。
Greenplum 行存、列存，堆表、AO表的原理和选择
MyySophia的博客
01-09 6196
原文地址：https://github.com/digoal/blog/blob/master/201708/20170818_02.md?spm=a2c4e.11153940.blogcont179210.17.6f682764HWr8pC&file=20170818_02.md 以下文字为德哥github原文，如有侵权，请及时联系，我会立即删除。 Greenplum支持行存和列存，...
堆表与索引组织表
weixin_30526593的博客
06-21 189
Ⅰ、堆表 数据存放在数据里面,索引存放在索引里 堆就是无序数据的集合,索引就是将数据变得有序,在索引中键值有序,数据还是无序的 堆表中,主键索引和普通索引一样的,叶子节点存放的是指向堆表中数据的指针（可以是一个页编号加偏移量）,指向物理地址,没有回表的说法 堆表中,主键和普通索引基本上没区别,和非空的唯一索引没区别 myisam就是用的这个堆表的存储方式,oracle支持堆表,pg只支持堆表...
postgres默认安装后有哪些表_Greenplum 行存、列存，堆表、AO表的原理和选择
weixin_39533432的博客
12-08 632
行存和列存的原理什么时候选择行存什么时候选择列存堆表和AO表的原理什么时候选择堆表什么时候选择AO表测试对比行存deform和列存的性能差别如何查看表的存储结构Greenplum支持行存和列存，支持堆表和AO表，那么他们有什么不同，如何选择呢？行存和列存的原理1、行存，以行为形式组织存储，一行是一个tuple，存在一起。当需要读取某列时，需要将这列前面的所有列都进行deform，所以访问第一列和访...
GaussDB数据库行列存表锁机制差异对于sql编写的影响
liyigan4852567的博客
09-07 2207
与行存表相比，列存表在数据量大、查询复杂的OLAP 场景下具有更加明显的优势。GaussDB数据库可以使用列存储模式对表进行存储，带来更加优异性能的同时也对sql编写者带来了新的要求。本文首先从行列存储原理入手对锁机制进行全面的分析，最后辅助以案例应对行列锁机制差异。
Greenplum ao表和heap表垃圾回收的细微差别
weixin_34228662的博客
09-17 342
标签 PostgreSQL , Greenplum , 垃圾回收 , vacuum 背景 在Greenplum中删除、更新数据记录时，会产生新的tuple版本，老的版本通过行头部标记：为已删除以及被哪个事务删除的。 因此频繁的更新后，或者批量的删除数据后，需要回收那些旧的版本。 通过vacuum、vacuum full、alter table red...
B+树
Trony的博客
01-02 335
一、B+树 1.1 多级索引 1.1.1 概念 当索引项比较多时，可以对索引再建立索引，以此类推，形成多级索引 1.2 B+树的基本概念 B+树索引：一种以树型数据结构来组织索引项的多级索引 一块中索引项的组织 索引字段值 指针，指向索引快或数据块中记录的指针 能够自动保持与主文件大小相适应的树的层次 每个索引块的指针利用率都在50%-100%之间 1.3 B+树的存储约定 1.3.1 一块中存放的索引项的数量 有n-1个索引项(<索引字段值，指针>)+1个指针
php 表单 email, URL 正则表达式
weixin_34185364的博客
10-30 154
转载于:https://www.cnblogs.com/wangshuazi/p/9877739.html
METHOD GLOBAL_END BY DATABASE PROCEDURE FOR HDB LANGUAGE SQLSCRIPT OPTIONS READ-ONLY USING
06-03
具体来说，该方法名为 `GLOBAL_END`，是一个存储过程方法（`METHOD`)，被定义在数据库层（`BY DATABASE PROCEDURE`），并使用 SQLScript 语言（`FOR HDB LANGUAGE SQLSCRIPT`）编写。该方法被定义为只读操作（`...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值