postgresql表继承和表分区

最新推荐文章于 2024-04-18 16:10:34 发布
最新推荐文章于 2024-04-18 16:10:34 发布
阅读量3.7k 收藏 6
点赞数
分类专栏： postgresql基础 文章标签： postgresql分区表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/su377486/article/details/82731657
版权

一.表继承

表继承是pg中特有的东西.继承表拥有父表的所有字段,下面有一个a1表如下:
 

 

test=# create table a1(id int,name varchar(20));
CREATE TABLE

创建一个a2表继承a1表,使用inherits关键字.表继承可以继承多个表,那么子表将拥有父表的所有字段,是所有父表的融合.继承会继承父表的约束,并且如果某个父表的字段存在非空约束,那么融合后的字段也要是非空.但是不会融合索引

 

test=# create table a2(age int) inherits(a1);
CREATE TABLE
test=# \d a2
                         Table "test.a2"
 Column |         Type          | Collation | Nullable | Default 
--------+-----------------------+-----------+----------+---------
 id     | integer               |           |          | 
 name   | character varying(20) |           |          | 
 age    | integer               |           |          | 
Inherits: a1
 
test=# \d t1
                            Table "test.t1"
 Column |            Type             | Collation | Nullable | Default 
--------+-----------------------------+-----------+----------+---------
 id     | integer                     |           |          | 
 name   | character varying(10)       |           |          | 
 ostime | timestamp without time zone |           |          | 
 
 
test=# \d t3
                 Table "test.t3"
 Column | Type  | Collation | Nullable | Default 
--------+-------+-----------+----------+---------
 image  | bytea |           |          | 
 
test=# create table t5(flag int) inherits(t1,t3);
CREATE TABLE
test=# \d t5
                            Table "test.t5"
 Column |            Type             | Collation | Nullable | Default 
--------+-----------------------------+-----------+----------+---------
 id     | integer                     |           |          | 
 name   | character varying(10)       |           |          | 
 ostime | timestamp without time zone |           |          | 
 image  | bytea                       |           |          | 
 flag   | integer                     |           |          | 
Inherits: t1,
          t3
 

下面是表继承特性测试:

1.如果在父表中插入修改数据,那么这些数据只有父表可以查询到,子表无法查询

 

test=# insert into a1 values(1,'brent');
INSERT 0 1
test=# select * from a1;
 id | name  
----+-------
  1 | brent
(1 row)
 
test=# select * from a2;
 id | name | age 
----+------+-----
(0 rows)

2.如果在子表中插入修改数据,那么这些数据在父表和子表都能查询到

 

test=# insert into a2 values(2,'bob',19);
INSERT 0 1
test=# select * from a1;
 id | name  
----+-------
  1 | brent
  2 | bob
(2 rows)
 
test=# select * from a2;
 id | name | age 
----+------+-----
  2 | bob  |  19
(1 row)

3.如果在父表中只想查询父表的数据,需要添加only关键字

 

test=# select * from only a1;
 id | name  
----+-------
  1 | brent

4.如果删除父表的数据,那么子表和父表的数据都会被删除,如果删除子表的数据,则不会删除父表的数据

一个子表可以继承多个父表.

 

二.分区表

pg中的分区表是使用继承来实现的.在使用继承实现分区表的时候,一般会让父表为空,数据都存储于子表中.

创建分区表的步骤:

1.创建父表,所有的分区都从它继承.这个表中没有数据,不要在这个表上定义任何检查和约束,除非你想约束所有的分区,同样在其上定义任何索引和约束也没有任何意义.

2.创建几个子表,每个表都是从父表继承,通常这些表不会增加任何字段,我们把子表称为分区,实际上他们就是普通的pg表.

3.给分区表增加约束,定义每个分区允许的键值

4.对于每个分区,在关键字段上创建索引

5.定义一个规则或者触发器,把对父表的数据插入重定向到合适的分区表.

6.确保constraint_exclusion里的配置参数postgresql.conf是打开的,值为partition.打开后,如果查询中的where子句的过滤条件与分区 的约束条件匹配,那么这个查询会智能的查询这个分区,而不会查询其它分区.

注意,在pg10以前需要使用规则或者触发器来实现插入数据到子表.而到了10以后,不需要再手工创建规则或者触发器,即可实现,

下面是具体的实例(适用于pg10以前的版本):

(1)创建父表

 

create table  prud(id int,name varchar(10),logdate date not null);

(2)创建子表

 

CREATE TABLE prud_2014 (CHECK ( logdate >= DATE '2014-01-01' AND logdate < DATE '2015-01-01' )) INHERITS (prud);
CREATE TABLE prud_2015 (CHECK ( logdate >= DATE '2015-01-01' AND logdate < DATE '2016-01-01' )) INHERITS (prud);
CREATE TABLE prud_2016 (CHECK ( logdate >= DATE '2016-01-01' AND logdate < DATE '2017-01-01' )) INHERITS (prud);
CREATE TABLE prud_2017 (CHECK ( logdate >= DATE '2017-01-01' AND logdate < DATE '2018-01-01' )) INHERITS (prud);
CREATE TABLE prud_2018 (CHECK ( logdate >= DATE '2018-01-01' AND logdate < DATE '2019-01-01' )) INHERITS (prud);
CREATE TABLE prud_2019 (CHECK ( logdate >= DATE '2019-01-01' AND logdate < DATE '2020-01-01' )) INHERITS (prud);

根据需要创建索引:

 

CREATE INDEX prud_2014_index ON prud_2014 (logdate);
CREATE INDEX prud_2015_index ON prud_2015 (logdate);
CREATE INDEX prud_2016_index ON prud_2016 (logdate);
CREATE INDEX prud_2017_index ON prud_2017 (logdate);
CREATE INDEX prud_2018_index ON prud_2018 (logdate);
CREATE INDEX prud_2019_index ON prud_2019 (logdate);

(3)创建函数和触发器

 

CREATE OR REPLACE FUNCTION prud_insert_trigger()
RETURNS TRIGGER AS $$
BEGIN
    IF ( NEW.logdate >= DATE '2014-01-01' AND
         NEW.logdate < DATE '2005-01-01' ) THEN
        INSERT INTO prud_2014 VALUES (NEW.*);
    ELSIF ( NEW.logdate >= DATE '2015-01-01' AND
            NEW.logdate < DATE '2016-01-01' ) THEN
        INSERT INTO prud_2015 VALUES (NEW.*);
        ELSIF ( NEW.logdate >= DATE '2016-01-01' AND
            NEW.logdate < DATE '2017-01-01' ) THEN
        INSERT INTO prud_2016 VALUES (NEW.*);
    ELSIF ( NEW.logdate >= DATE '2017-01-01' AND
            NEW.logdate < DATE '2018-01-01' ) THEN
        INSERT INTO prud_2017 VALUES (NEW.*);
    ELSIF ( NEW.logdate >= DATE '2018-01-01' AND
            NEW.logdate < DATE '2019-01-01' ) THEN
        INSERT INTO prud_2018 VALUES (NEW.*);
    ELSIF ( NEW.logdate >= DATE '2019-01-01' AND
            NEW.logdate < DATE '2020-01-01' ) THEN
        INSERT INTO prud_2019 VALUES (NEW.*);
    ELSE
        RAISE EXCEPTION 'Date out of range.  Fix the measurement_insert_trigger() function!';
    END IF;
    RETURN NULL;
END;
$$
LANGUAGE plpgsql;

创建触发器:

 

create trigger insert_prud 
before insert on prud
for each row execute procedure prud_insert_trigger();

(5)测试

 

test=# insert into prud values(1,'brent','2016-02-01');
INSERT 0 0
test=# select * from prud;
 id | name  |  logdate   
----+-------+------------
  1 | brent | 2016-02-01
(1 row)
 
test=# select * from prud_2016;
 id | name  |  logdate   
----+-------+------------
  1 | brent | 2016-02-01
 

如果插入超出分区的数据,则会抛出异常:

 

test=# insert into prud values(1,'brent','2020-02-01');
ERROR:  Date out of range.  Fix the measurement_insert_trigger() function!
CONTEXT:  PL/pgSQL function prud_insert_trigger() line 22 at RAISE
 

查询执行计划,只扫描了一个分区:

 

test=# show constraint_exclusion;
 constraint_exclusion 
----------------------
 partition
(1 row)
 
test=# explain select count(*) from prud where logdate>='2016-01-01' and logdate <'2017-01-01';
                                              QUERY PLAN                                              
------------------------------------------------------------------------------------------------------
 Aggregate  (cost=84.93..84.94 rows=1 width=8)
   ->  Append  (cost=0.00..84.83 rows=37 width=0)
         ->  Seq Scan on prud  (cost=0.00..2.65 rows=1 width=0)
               Filter: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
         ->  Bitmap Heap Scan on prud_2014  (cost=4.21..13.70 rows=6 width=0)
               Recheck Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
               ->  Bitmap Index Scan on prud_2014_index  (cost=0.00..4.21 rows=6 width=0)
                     Index Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
         ->  Bitmap Heap Scan on prud_2015  (cost=4.21..13.70 rows=6 width=0)
               Recheck Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
               ->  Bitmap Index Scan on prud_2015_index  (cost=0.00..4.21 rows=6 width=0)
                     Index Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
         ->  Bitmap Heap Scan on prud_2016  (cost=4.21..13.70 rows=6 width=0)
               Recheck Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
               ->  Bitmap Index Scan on prud_2016_index  (cost=0.00..4.21 rows=6 width=0)
                     Index Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
         ->  Bitmap Heap Scan on prud_2017  (cost=4.21..13.70 rows=6 width=0)
               Recheck Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
               ->  Bitmap Index Scan on prud_2017_index  (cost=0.00..4.21 rows=6 width=0)
                     Index Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
         ->  Bitmap Heap Scan on prud_2018  (cost=4.21..13.70 rows=6 width=0)
               Recheck Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
               ->  Bitmap Index Scan on prud_2018_index  (cost=0.00..4.21 rows=6 width=0)
                     Index Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
         ->  Bitmap Heap Scan on prud_2019  (cost=4.21..13.70 rows=6 width=0)
               Recheck Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
               ->  Bitmap Index Scan on prud_2019_index  (cost=0.00..4.21 rows=6 width=0)
                     Index Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
(28 rows)
 
test=# explain select count(*) from prud where logdate>='2016-01-01' and logdate <'2017-01-01';
                                              QUERY PLAN                                              
------------------------------------------------------------------------------------------------------
 Aggregate  (cost=16.36..16.37 rows=1 width=8)
   ->  Append  (cost=0.00..16.35 rows=7 width=0)
         ->  Seq Scan on prud  (cost=0.00..2.65 rows=1 width=0)
               Filter: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
         ->  Bitmap Heap Scan on prud_2016  (cost=4.21..13.70 rows=6 width=0)
               Recheck Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
               ->  Bitmap Index Scan on prud_2016_index  (cost=0.00..4.21 rows=6 width=0)
                     Index Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))

如果将constraint_exclusion设置为off,则需要扫描所有的子表.

 

test=# set constraint_exclusion='off';
SET
test=# explain select count(*) from prud where logdate>='2016-01-01' and logdate <'2017-01-01';
                                              QUERY PLAN                                              
------------------------------------------------------------------------------------------------------
 Aggregate  (cost=84.93..84.94 rows=1 width=8)
   ->  Append  (cost=0.00..84.83 rows=37 width=0)
         ->  Seq Scan on prud  (cost=0.00..2.65 rows=1 width=0)
               Filter: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
         ->  Bitmap Heap Scan on prud_2014  (cost=4.21..13.70 rows=6 width=0)
               Recheck Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
               ->  Bitmap Index Scan on prud_2014_index  (cost=0.00..4.21 rows=6 width=0)
                     Index Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
         ->  Bitmap Heap Scan on prud_2015  (cost=4.21..13.70 rows=6 width=0)
               Recheck Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
               ->  Bitmap Index Scan on prud_2015_index  (cost=0.00..4.21 rows=6 width=0)
                     Index Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
         ->  Bitmap Heap Scan on prud_2016  (cost=4.21..13.70 rows=6 width=0)
               Recheck Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
               ->  Bitmap Index Scan on prud_2016_index  (cost=0.00..4.21 rows=6 width=0)
                     Index Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
         ->  Bitmap Heap Scan on prud_2017  (cost=4.21..13.70 rows=6 width=0)
               Recheck Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
               ->  Bitmap Index Scan on prud_2017_index  (cost=0.00..4.21 rows=6 width=0)
                     Index Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
         ->  Bitmap Heap Scan on prud_2018  (cost=4.21..13.70 rows=6 width=0)
               Recheck Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
               ->  Bitmap Index Scan on prud_2018_index  (cost=0.00..4.21 rows=6 width=0)
                     Index Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
         ->  Bitmap Heap Scan on prud_2019  (cost=4.21..13.70 rows=6 width=0)
               Recheck Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
               ->  Bitmap Index Scan on prud_2019_index  (cost=0.00..4.21 rows=6 width=0)
                     Index Cond: ((logdate >= '2016-01-01'::date) AND (logdate < '2017-01-01'::date))
(28 rows)
 

将子表从父表中剔除:

 

test=# alter table prud_2015 no inherit prud;

 

下面是适用于10以后的版本的创建方法,不再需要创建触发器或者规则,10支持range和list分区:

(1)创建父表,并且指定分区键

 

create table  prud(id int,name varchar(10),logdate date not null) PARTITION BY RANGE (logdate);

 

(2)创建子表

 

CREATE TABLE prud_2014 partition of prud for values from ('2014-01-01') to ('2015-01-01');
CREATE TABLE prud_2015 partition of prud for values from ('2015-01-01') to ('2016-01-01');
CREATE TABLE prud_2016 partition of prud for values from ('2016-01-01') to ('2017-01-01');
CREATE TABLE prud_2017 partition of prud for values from ('2017-01-01') to ('2018-01-01');
CREATE TABLE prud_2018 partition of prud for values from ('2018-01-01') to ('2019-01-01');
CREATE TABLE prud_2019 partition of prud for values from ('2019-01-01') to ('2020-01-01');

根据需要创建索引:

 

CREATE INDEX prud_2014_index ON prud_2014 (logdate);
CREATE INDEX prud_2015_index ON prud_2015 (logdate);
CREATE INDEX prud_2016_index ON prud_2016 (logdate);
CREATE INDEX prud_2017_index ON prud_2017 (logdate);
CREATE INDEX prud_2018_index ON prud_2018 (logdate);
CREATE INDEX prud_2019_index ON prud_2019 (logdate);

(3)测试

 

test=# insert into prud values(1,'aa','2018-01-01');
INSERT 0 1
test=# select * from prud;
 id | name |  logdate   
----+------+------------
  1 | aa   | 2018-01-01
(1 row)
 
test=# select * from prud_2018;
 id | name |  logdate   
----+------+------------
  1 | aa   | 2018-01-01
(1 row)

 如果插入不在子分区的值,会产生报错:

 

test=# insert into prud values(1,'aa','2013-01-01');
ERROR:  no partition of relation "prud" found for row
DETAIL:  Partition key of the failing row contains (logdate) = (2013-01-01).
 

 

分区表的常用操作,一般如果需要对分区进行操作,则直接对子表进行操作即可,例如添加索引,删除索引,添加约束等.如果需要删除一个分区的数据,直接truncate子表即可.

子表还可以创建子分区,语法如下:

 

test=# CREATE TABLE prud_2020 partition of prud for values from ('2020-01-01') to ('2021-01-01') PARTITION BY RANGE (id);
CREATE TABLE
test=# create table prud_2020_id1 partition of prud_2020 for values from (1) to (100);
CREATE TABLE
 

检查子表的数据:

 

test=# insert into prud values(10,'xxx','2020-01-10');
INSERT 0 1
test=# select * from prud;
 id | name |  logdate   
----+------+------------
  1 | aa   | 2014-01-02
  1 | aa   | 2016-01-02
 10 | xxx  | 2020-01-10
(3 rows)
 
test=# select * from prud_2020;
 id | name |  logdate   
----+------+------------
 10 | xxx  | 2020-01-10
(1 row)
 
test=# select * from prud_2020_id1;
 id | name |  logdate   
----+------+------------
 10 | xxx  | 2020-01-10
 

 

如果需要将子表从父表中删除,但是不删除子表的数据,可以使用如下语法;

 

ALTER TABLE prud DETACH PARTITION prud_2020;
 

删除父表,使用

 

drop table prud cascade;

 

创建list分区语法如下:

 

create table  prud(id int,name varchar(10),logdate date not null) PARTITION BY list (name);
 
CREATE TABLE prud_jack partition of prud for values in ('jack');
CREATE TABLE prud_bob partition of prud for values in ('bob');
CREATE TABLE prud_tom partition of prud for values in ('tom');

 

久违的太阳
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mysql 表继承_PostgreSQL教程(三)：表的继承和分区表详解
weixin_34109083的博客
02-02 824
一、表的继承：这个概念对于很多已经熟悉其他数据库编程的开发人员而言会多少有些陌生，然而它的实现方式和设计原理却是简单易懂，现在就让我们从一个简单的例子开始吧。1. 第一个继承表：CREATE TABLE cities ( --父表name text,population float,altitude int);CREATE TABLE capitals ( --子表sta...
postgresql----继承表INHERITS PARENT TABLE
weixin_34218890的博客
06-21 1086
使用INHERITS创建的新表会继承一个或多个父表，子表只会继承父表的表结构和NOT NULL，DEFAULT，CHECK三种约束，主键，外键和唯一键以及索引不会被继承，所以修改父表的结构（增删字段），NOT NULL，DEFAULT和CHECK约束会自动同步子表修改。 示例1. create table tbl_inherits_parent( a int not null, ...
Postgresql 从小白到高手 五 ：postgresql的继承特性以及分区表创建
最新发布
simensk的博客
04-18 1101
postgresql 继承 分区表
postgresql表继承与分区
weixin_45105610的博客
03-04 1626
目标 掌握表继承相关知识。 掌握分区（V10）相关知识。 数据分区 分区将表拆分为多个表，并且通常以一种访问表的应用程序注意不到任何差异的方式完成。 PG V10之前的版本：继承表+约束+规则或触发器。 PG V10特性：分区表特性，管理分区方便， 数据插入效率高。 表继承 例 创建cities父表，capitals子表继承于cities。 postgres=# create table cities(name text,population float,altitude int);  
[Postgres]关于Postgres的INHERIT，分表
weixin_30486037的博客
09-30 262
实在是很强大的功能 可以通过Check的制约把结构相同的表合并起来，或者反过来说，可以在一个表名下数据库自动的根据Check条件往对应的分表里存储数据 [USER_DATA表] CREATE TABLE test."USER_DATA"( "MAC" character varying(12) NOT NULL, "ID" character(3) NOT NULL, "YEARS" ...
POSTGRESQL O 记数据库的功能 inheritance 继承
sql server的专栏
05-11 287
OBJECT 对象，这个名词其实在数据库的层面很少被提及，4大世面上常用的关系型数据库，可以带有 O 这个标记的也只有POSTGRESQL。 其他数据库可以叫RDBMS, relati...
PostgreSQL教程(三)：表的继承和分区表详解
09-10
5. **分区和约束排除** - 分区表的每个分区可以有自己的约束，但主表可以有全局约束，这些约束对所有分区都有效。 - 使用EXCLUDE约束可以在创建分区时排除特定的数据，以避免数据冗余或不一致。 6. **查询和操作...
PostgreSQL表的继承和分区
07-02
PostgreSQL表的继承和分区
PostgreSQL 创建表分区
09-11
在PostgreSQL数据库系统中，表分区是一种优化大数据存储和查询性能的技术。表分区将一个大表分解成多个小表，每个小表（分区）管理一部分数据。这种设计使得查询和管理大规模数据更为高效，因为数据库可以针对每个...
native 数据迁移_PostgreSQL10 pg_pathman、native、Inherits 分区测试报告
weixin_31894867的博客
01-14 340
背景：哈啰出行旗下包括哈啰单车、助力车、顺风车、打车、电动车、换电等几乎所有业务都基于PostgreSQL数据库构建，PostgreSQL的安全、稳定、高效为哈啰出行的上亿用户提供了强大的基础。随着时间的推移，表里的数据量越来越大，有些需要分库分表处理，有些可以通过简单的分区处理即可，表分区有很多好处：1)：只vacuum 最近分区子表而不是vacuum大表，降低io消耗，减少表膨胀。2...
postgresql表继承详解
xudajian的专栏
06-10 3134
Postgresql继承表研究
postgres中表的继承
文档搬运工
06-23 527
参考文档： http://postgres.cn/docs/10/ddl-inherit.html http://postgres.cn/docs/10/tutorial-inheritance.html -- 创建表 create table p1(id int primary key, info text unique, c1 int check(c1>0), c2 int not null, c3 int unique); create table c1(like p1) inherit
PostgreSql 申明式分区和继承分区
xichji的专栏
08-31 342
-创建表空间（为最大化利用分区表优势，有条件的可按需求将表空间目录挂载到不同的磁盘，频繁访问的数据放到性能较好的磁盘，很少用到的数据放到性能一般的磁盘）--创建表空间（为最大化利用分区表优势，有条件的可按需求将表空间目录挂载到不同的磁盘，频繁访问的数据放到性能较好的磁盘，很少用到的数据放到性能一般的磁盘）--创建表空间（为最大化利用分区表优势，有条件的可按需求将表空间目录挂载到不同的磁盘，频繁访问的数据放到性能较好的磁盘，很少用到的数据放到性能一般的磁盘）版权声明：本文为CSDN博主「脑子进水养啥鱼？
详解PostgreSQL中的继承
我的学习成长日记
10-03 2633
Inheritance是PostgreSQL独有的，也是前文中我们提到的“使用面向对象的思想来组织数据库”的具体体现之一。 一, 表的继承。 这里我们使用官网说明中的例子，原文在这里： https://www.postgresql.org/docs/12/tutorial-inheritance.html CREATE TABLE cities ( name text, population real, elevation int – (in ft) ); CREATE TABLE
pgsql使用积累系列_表分区（继承）
wfl_137724的博客
01-19 268
写在前面：这不是一个知识系列博客，这只是对本人使用过知识的一个记录，最好的资源应该是官方文档。官网doc: https://www.postgresql.org/docs/current/static/plpgsql.html-- 自定义rule性能比触发器好-- 继承实现表分区--创建主表：CREATE TABLE mastermeasure (    city_id         int n
pgsql继承关系案例
Artij的博客
08-29 156
查询灵活性：继承允许在整个继承层次结构上进行查询操作，从而提供了更灵活的查询选项。可以在父表上执行查询，同时自动包含子表的数据，或者只在子表上执行特定条件的查询。在父表上定义的函数、触发器和约束等可以在子表上自动继承和使用，提高了编程的效率和代码的可维护性。通过继承关系，可以确保子表的数据始终与父表保持同步，减少了数据冗余和错误。一个人员表和两个子表：员工表和顾客表，它们通过继承来自父表的属性和功能。查询父表会把所有子表的数据也查出来（父表的字段，不会查出子表独有字段）图形化界面：datagrip。
PgSql表继承
flower_CSDN的博客
02-20 881
创建一个父表 create table ta ( sid integer not null, pid integer not null, cdate text not null ) with ( OIDS=FALSE ); ALTER table ta owner to p1; grant all on table ta to p1; grant select,updat...
Postgresql数据库的继承表，并使用继承表实现本地分区
XiaoCai
07-05 1198
Postgresql数据库的继承表，并使用继承表实现本地分区
postgres表继承分表
debugcool的博客
10-29 378
创建一个father表的子表 CREATE TABLE test_1 () INHERITS (father_table); 分表之后第一件事情当然就是把原有父表的数据分发到各个子表中 首先创建原有数据对应的子表 DO $$ DECLARE father RECORD; BEGIN FOR father IN SELECT item_type FROM father_table G...
postgresql 分区表
08-23
PostgreSQL 支持分区表，它允许将表数据根据特定的条件拆分成多个子表，从而提高查询性能和管理数据。下面是一些关于 PostgreSQL 分区表的基本信息： 1. 分区表定义：在创建表时，可以使用 PARTITION BY 子句指定分区键。常见的分区键类型包括范围（range）、列表（list）和哈希（hash）。 2. 范围分区（Range partitioning）：根据某个列的值范围进行分区，例如按时间范围、按数值范围等。可以使用 CREATE TABLE 语句的 PARTITION OF 子句定义每个分区。 3. 列表分区（List partitioning）：根据某个列的值列表进行分区，例如按地区、按部门等。也可以使用 CREATE TABLE 语句的 PARTITION OF 子句定义每个分区。 4. 哈希分区（Hash partitioning）：根据某个列的哈希值进行分区，通常用于数据平均分布的场景。使用 CREATE TABLE 语句的 PARTITION OF 子句定义每个分区。 5. 分区表管理：分区表可以通过 ALTER TABLE 添加或删除分区。还可以使用 EXCHANGE PARTITION 子句将数据从非分区表或已有分区中交换进入分区表。 6. 查询优化：PostgreSQL 的查询优化器会在执行查询时自动识别并只查询相关分区，从而提高查询性能。同时，可以通过查询约束来进一步减少查询的分区范围。 需要注意的是，分区表在数据库中的使用需要根据具体的业务需求和数据特点来决定，同时需要合理设计和规划分区键，以及考虑数据维护和查询优化等方面的因素。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值