lightdb22.4-新增优化器提示cardinality 和ordered_predicates

最新推荐文章于 2024-01-05 19:18:07 发布
最新推荐文章于 2024-01-05 19:18:07 发布
阅读量410 收藏
点赞数
分类专栏： lightdb 数据库 文章标签： 数据库 postgres lightdb hint
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_17713935/article/details/127924170
版权
介绍了 LightDB 22.4 版本中新引入的两个优化器提示功能：cardinality 和 ordered_predicates。前者用于设定表的预估行数以影响查询计划的选择，后者则用于强制保留 SQL 中指定的约束顺序。
摘要由CSDN通过智能技术生成

lightdb 22.4 新增优化器提示cardinality 和ordered_predicates

lightdb 在22.4 新增了如下两个优化器提示：

  • cardinality
  • ordered hint

下面对这两个hint 进行介绍

1. cardinality hint

cardinality hint 用于强制设置表或多表查询结果的预估行数，从而影响优化器选择执行路径，hint的效果体现在对explain 中rows值的印象。

具体请看如下案例：

1.0 前置准备

lightdb@postgres=# create table t1 (key1 int , key2 int);
CREATE TABLE
lightdb@postgres=# create table t2 (key1 int , key2 int);
CREATE TABLE

1.1 影响join算法选择

通过使用cardinality设置t1表预估行数为10，导致走了hashjoin：


lightdb@postgres=# explain select * from t1, t2 where t1.key1 = t2.key1;
                            QUERY PLAN                            
------------------------------------------------------------------
 Merge Join  (cost=317.01..711.38 rows=25538 width=16)
   Merge Cond: (t1.key1 = t2.key1)
   ->  Sort  (cost=158.51..164.16 rows=2260 width=8)
         Sort Key: t1.key1
         ->  Seq Scan on t1  (cost=0.00..32.60 rows=2260 width=8)
   ->  Sort  (cost=158.51..164.16 rows=2260 width=8)
         Sort Key: t2.key1
         ->  Seq Scan on t2  (cost=0.00..32.60 rows=2260 width=8)
(8 rows)

lightdb@postgres=# explain select /*+cardinality(t1 10)*/* from t1, t2 where t1.key1 = t2.key1;
                               QUERY PLAN                               
------------------------------------------------------------------------
 Hash Join  (cost=32.73..74.93 rows=113 width=16)
   Hash Cond: (t2.key1 = t1.key1)
   ->  Seq Scan on t2 @"lt#0"  (cost=0.00..32.60 rows=2260 width=8)
   ->  Hash  (cost=32.60..32.60 rows=10 width=8)
         ->  Seq Scan on t1 @"lt#0"  (cost=0.00..32.60 rows=10 width=8)
(5 rows)

lightdb@postgres=#

1.2 影响内外表选择

对应hashjoin，可以通过把rows 设小，可以强制把设置的表作为内表构建hash表。

lightdb@postgres=# explain select /*+cardinality(t1 20) cardinality(t2 20)*/* from t1, t2 where t1.key1 = t2.key1;
                               QUERY PLAN                               
------------------------------------------------------------------------
 Hash Join  (cost=32.85..65.57 rows=2 width=16)
   Hash Cond: (t1.key1 = t2.key1)
   ->  Seq Scan on t1 @"lt#0"  (cost=0.00..32.60 rows=20 width=8)
   ->  Hash  (cost=32.60..32.60 rows=20 width=8)
         ->  Seq Scan on t2 @"lt#0"  (cost=0.00..32.60 rows=20 width=8)
(5 rows)

lightdb@postgres=# explain select /*+cardinality(t1 10) cardinality(t2 20)*/* from t1, t2 where t1.key1 = t2.key1;
                               QUERY PLAN                               
------------------------------------------------------------------------
 Hash Join  (cost=32.73..65.41 rows=1 width=16)
   Hash Cond: (t2.key1 = t1.key1)
   ->  Seq Scan on t2 @"lt#0"  (cost=0.00..32.60 rows=20 width=8)
   ->  Hash  (cost=32.60..32.60 rows=10 width=8)
         ->  Seq Scan on t1 @"lt#0"  (cost=0.00..32.60 rows=10 width=8)
(5 rows)

lightdb@postgres=# explain select /*+cardinality(t1 20) cardinality(t2 10)*/* from t1, t2 where t1.key1 = t2.key1;
                               QUERY PLAN                               
------------------------------------------------------------------------
 Hash Join  (cost=32.73..65.41 rows=1 width=16)
   Hash Cond: (t1.key1 = t2.key1)
   ->  Seq Scan on t1 @"lt#0"  (cost=0.00..32.60 rows=20 width=8)
   ->  Hash  (cost=32.60..32.60 rows=10 width=8)
         ->  Seq Scan on t2 @"lt#0"  (cost=0.00..32.60 rows=10 width=8)
(5 rows)

lightdb@postgres=#

1.3 影响子查询

lightdb@postgres=# explain select t1.key1 from t1, (select distinct * from t2 ) x where t1.key1 = x.key1 and x.key2>10;
                                 QUERY PLAN                                  
-----------------------------------------------------------------------------
 Hash Join  (cost=49.23..174.72 rows=2509 width=4)
   Hash Cond: (t1.key1 = x.key1)
   ->  Seq Scan on t1  (cost=0.00..32.60 rows=2260 width=4)
   ->  Hash  (cost=46.45..46.45 rows=222 width=4)
         ->  Subquery Scan on x  (cost=42.02..46.45 rows=222 width=4)
               ->  HashAggregate  (cost=42.02..44.23 rows=222 width=8)
                     Group Key: t2.key1, t2.key2
                     ->  Seq Scan on t2  (cost=0.00..38.25 rows=753 width=8)
                           Filter: (key2 > 10)
(9 rows)

lightdb@postgres=# explain select /*+cardinality(x 100)*/t1.key1 from t1, (select distinct * from t2 ) x where t1.key1 = x.key1 and x.key2>10;
                                     QUERY PLAN                              
        
-----------------------------------------------------------------------------
--------
 Hash Join  (cost=47.70..125.50 rows=1130 width=4)
   Hash Cond: (t1.key1 = x.key1)
   ->  Seq Scan on t1 @"lt#0"  (cost=0.00..32.60 rows=2260 width=4)
   ->  Hash  (cost=46.45..46.45 rows=100 width=4)
         ->  Subquery Scan on x @"lt#0"  (cost=42.02..46.45 rows=100 width=4)
               ->  HashAggregate  (cost=42.02..44.23 rows=222 width=8)
                     Group Key: t2.key1, t2.key2
                     ->  Seq Scan on t2 @"lt#1"  (cost=0.00..38.25 rows=753 w
idth=8)
                           Filter: (key2 > 10)
(9 rows)

lightdb@postgres=#

1.4 影响多表

lightdb@postgres=# explain select * from t1 ,t2 ,t1 a where t1.key1=t2.key1 and t2.key1=a.key1;
                                  QUERY PLAN                                 
 
-----------------------------------------------------------------------------
-
 Merge Join  (cost=475.52..5209.87 rows=288579 width=24)
   Merge Cond: (a.key1 = t1.key1)
   ->  Sort  (cost=158.51..164.16 rows=2260 width=8)
         Sort Key: a.key1
         ->  Seq Scan on t1 a  (cost=0.00..32.60 rows=2260 width=8)
   ->  Materialize  (cost=317.01..775.23 rows=25538 width=16)
         ->  Merge Join  (cost=317.01..711.38 rows=25538 width=16)
               Merge Cond: (t1.key1 = t2.key1)
               ->  Sort  (cost=158.51..164.16 rows=2260 width=8)
                     Sort Key: t1.key1
                     ->  Seq Scan on t1  (cost=0.00..32.60 rows=2260 width=8)
               ->  Sort  (cost=158.51..164.16 rows=2260 width=8)
                     Sort Key: t2.key1
                     ->  Seq Scan on t2  (cost=0.00..32.60 rows=2260 width=8)
(14 rows)

lightdb@postgres=# explain select /*+cardinality(t1 t2 100)*/* from t1 ,t2 ,t1 a where t1.key1=t2.key1 and t2.key1=a.key1;
                                      QUERY PLAN                             
         
-----------------------------------------------------------------------------
---------
 Hash Join  (cost=712.63..790.43 rows=1130 width=24)
   Hash Cond: (a.key1 = t1.key1)
   ->  Seq Scan on t1 a @"lt#0"  (cost=0.00..32.60 rows=2260 width=8)
   ->  Hash  (cost=711.38..711.38 rows=100 width=16)
         ->  Merge Join  (cost=317.01..711.38 rows=100 width=16)
               Merge Cond: (t1.key1 = t2.key1)
               ->  Sort  (cost=158.51..164.16 rows=2260 width=8)
                     Sort Key: t1.key1
                     ->  Seq Scan on t1 @"lt#0"  (cost=0.00..32.60 rows=2260 
width=8)
               ->  Sort  (cost=158.51..164.16 rows=2260 width=8)
                     Sort Key: t2.key1
                     ->  Seq Scan on t2 @"lt#0"  (cost=0.00..32.60 rows=2260 
width=8)
(12 rows)

lightdb@postgres=#

note

cardinality hint是rows hint 的别名，在22.4 我们对rows hint 进行了扩展，支持对单表进行设置。

2. ordered_predicates hint

ordered_predicates 用于强制优化器保留约束的顺序，对索引条件无效, 不考虑连接条件。目前具有如下限制：

  • 对于涉及等价推导的约束不起效，包括实际参与推导，和推导参数的约束。

具体案例如下：

2.0 前置准备

chuhx@postgres=# create table test1 (key1 int, key2 int, key3 int);
CREATE TABLE
chuhx@postgres=# create table test2 (key1 int, key2 int, key3 int);
CREATE TABLE
chuhx@postgres=#

2.1 对于where 或on或having后约束 不组合

where
lightdb@postgres=# EXPLAIN (COSTS false) select * from test1 where mod(key2, 10) = 2 and key1 = 1;
                   QUERY PLAN                   
------------------------------------------------
 Seq Scan on test1
   Filter: ((key1 = 1) AND (mod(key2, 10) = 2))
(2 rows)

lightdb@postgres=# EXPLAIN (COSTS false) select/*+ordered_predicates*/ * from test1 where mod(key2, 10) = 2 and key1 = 1;  
                   QUERY PLAN                   
------------------------------------------------
 Seq Scan on test1 @"lt#0"
   Filter: ((mod(key2, 10) = 2) AND (key1 = 1))
(2 rows)

lightdb@postgres=# EXPLAIN (COSTS false) select * from test1 where mod(key2, 10) = 2 and key1 > 1;
                   QUERY PLAN                   
------------------------------------------------
 Seq Scan on test1
   Filter: ((key1 > 1) AND (mod(key2, 10) = 2))
(2 rows)

lightdb@postgres=# EXPLAIN (COSTS false) select/*+ordered_predicates*/ * from test1 where mod(key2, 10) = 2 and key1 > 1;
                   QUERY PLAN                   
------------------------------------------------
 Seq Scan on test1 @"lt#0"
   Filter: ((mod(key2, 10) = 2) AND (key1 > 1))
(2 rows)
on
lightdb@postgres=# EXPLAIN (COSTS false) select * from test1 a join test2 b on a.key1=b.key1 and mod(a.key2, 10) = 2 and  a.key3 = 10; 
                         QUERY PLAN                          
-------------------------------------------------------------
 Hash Join
   Hash Cond: (b.key1 = a.key1)
   ->  Seq Scan on test2 b
   ->  Hash
         ->  Seq Scan on test1 a
               Filter: ((key3 = 10) AND (mod(key2, 10) = 2))
(6 rows)

lightdb@postgres=# EXPLAIN (COSTS false) select/*+ordered_predicates*/ * from test1 a join test2 b on a.key1=b.key1 and mod(a.key2, 10) = 2 and  a.key3 = 10; 
                         QUERY PLAN                          
-------------------------------------------------------------
 Hash Join
   Hash Cond: (b.key1 = a.key1)
   ->  Seq Scan on test2 b @"lt#0"
   ->  Hash
         ->  Seq Scan on test1 a @"lt#0"
               Filter: ((mod(key2, 10) = 2) AND (key3 = 10))
(6 rows)
having
lightdb@postgres=# EXPLAIN (COSTS false) select key1 from test1 group by key1, key2 having mod(key2, 10) = 2 and key1 = 1;
                         QUERY PLAN                         
------------------------------------------------------------
 Group
   Group Key: key1, key2
   ->  Sort
         Sort Key: key2
         ->  Seq Scan on test1
               Filter: ((key1 = 1) AND (mod(key2, 10) = 2))
(6 rows)

lightdb@postgres=# EXPLAIN (COSTS false) select/*+ordered_predicates*/ key1 from test1 group by key1, key2 having mod(key2, 10) = 2 and key1 = 1;
                         QUERY PLAN                         
------------------------------------------------------------
 Group
   Group Key: key1, key2
   ->  Sort
         Sort Key: key2
         ->  Seq Scan on test1 @"lt#0"
               Filter: ((mod(key2, 10) = 2) AND (key1 = 1))
(6 rows)

2.2 on 和where 结合（无等价推导， having 类同where，不再举例）

lightdb@postgres=# EXPLAIN (COSTS false) select * from test1 a join test2 b on a.key1=b.key1 and mod(a.key2, 10) = 2 where mod(b.key2, 10) = 2 and a.key3 = 10; 
                      QUERY PLAN                       
-------------------------------------------------------
 Nested Loop
   Join Filter: (a.key1 = b.key1)
   ->  Seq Scan on test1 a
         Filter: ((key3 = 10) AND (mod(key2, 10) = 2))
   ->  Seq Scan on test2 b
         Filter: (mod(key2, 10) = 2)
(6 rows)

lightdb@postgres=# EXPLAIN (COSTS false) select/*+ordered_predicates*/ * from test1 a join test2 b on a.key1=b.key1 and mod(a.key2, 10) = 2 where mod(b.key2, 10) = 2 and a.key3 = 10; 
                      QUERY PLAN                       
-------------------------------------------------------
 Nested Loop
   Join Filter: (a.key1 = b.key1)
   ->  Seq Scan on test1 a @"lt#0"
         Filter: ((mod(key2, 10) = 2) AND (key3 = 10))
   ->  Seq Scan on test2 b @"lt#0"
         Filter: (mod(key2, 10) = 2)
(6 rows)

2.3 不起效情况

有等价类推导a.key2=b.key2 && b.key2 = 1 导致 b 表上的 ((key2 = 1) AND (mod(key2, 10) = 2)) 不能保持sql 中定义顺序。

lightdb@postgres=# EXPLAIN (COSTS false) select * from test1 a left join test2 b on a.key1=b.key1 and a.key2=b.key2 where mod(b.key2, 10) = 2 and b.key2 = 1; 
e                      QUERY PLAN                      
y2 where mod(b.key2, 10) = 2 and b.key2 = 1; 
------------------------------------------------------
 Nested Loop
   Join Filter: (a.key1 = b.key1)
   ->  Seq Scan on test2 b
         Filter: ((key2 = 1) AND (mod(key2, 10) = 2))
   ->  Seq Scan on test1 a
         Filter: (key2 = 1)
(6 rows)

lightdb@postgres=# EXPLAIN (COSTS false) select/*+ordered_predicates*/ * from test1 a left join test2 b on a.key1=b.key1 and a.key2=b.key2 where mod(b.key2, 10) = 2 and b.key2 = 1; 
                      QUERY PLAN                      
------------------------------------------------------
 Nested Loop
   Join Filter: (a.key1 = b.key1)
   ->  Seq Scan on test2 b @"lt#0"
         Filter: ((key2 = 1) AND (mod(key2, 10) = 2))
   ->  Seq Scan on test1 a @"lt#0"
         Filter: (key2 = 1)
(6 rows)

有等价类推导a.key2=b.key2和a.key2 = 1 导致 a 表上((key2 = 1) AND (mod(key2, 10) = 2)) 不能保留sql中顺序。

这边单独说明是因为在代码内部与上述不起效的原理不同（由于外连接）。

lightdb@postgres=# EXPLAIN (COSTS false) select * from test1 a left join test2 b on a.key1=b.key1 and a.key2=b.key2 where mod(a.key2, 10) = 2 and a.key2 = 1;
y2 where mod(a.key2, 10) = 2 and a.key2 = 1;
                        QUERY PLAN                        
----------------------------------------------------------
 Nested Loop Left Join
   Join Filter: ((a.key2 = b.key2) AND (a.key1 = b.key1))
   ->  Seq Scan on test1 a
         Filter: ((key2 = 1) AND (mod(key2, 10) = 2))
   ->  Seq Scan on test2 b
         Filter: (key2 = 1)
(6 rows)

lightdb@postgres=# EXPLAIN (COSTS false) select /*+ordered_predicates*/* from test1 a left join test2 b on a.key1=b.key1 and a.key2=b.key2 where mod(a.key2, 10) = 2 and a.key2 = 1;
                        QUERY PLAN                        
----------------------------------------------------------
 Nested Loop Left Join
   Join Filter: ((a.key2 = b.key2) AND (a.key1 = b.key1))
   ->  Seq Scan on test1 a @"lt#0"
         Filter: ((key2 = 1) AND (mod(key2, 10) = 2))
   ->  Seq Scan on test2 b @"lt#0"
         Filter: (key2 = 1)
(6 rows)
紫无之紫
关注
专栏目录
机器学习笔记 - 深入了解TensorFlow模型优化工具包
学以致用 知行合一
10-26 1275
TensorFlow 模型优化工具包是一套用于优化 ML 模型以进行部署和执行的工具。TensorFlow 模型优化工具包 (TF MOT) 支持的不同模型优化技术。该工具包支持用于：降低云和边缘设备（例如移动设备、物联网）的延迟和推理成本。将模型部署到对处理、内存、功耗、网络使用和模型存储空间有限制的边缘设备。为现有硬件或新的专用加速器启用执行和优化。使用以下命令安装 TensorFlow 模型优化工具包。
lightdb22.1新特性-新增多种优化器提示
紫无之紫的博客
04-11 893
LightDB 22.1 新特性-新增优化器提示 LightDB 22.1 新增了多种优化器提示，包括use_hash_aggregation，semijoin/antijoin，swap_join_inputs use_hash_aggregation/no_use_hash_aggregation 使用此优化器提示可以控制group by的算法，目前group by有两种算法，一种为排序，另一种为哈希, 通过使用use_hash_aggregation可以控制group by使用hash算法，使用no_
利用ORDERED_PREDICATES优化多个自定函数作为WHERE过滤条件
落落的专栏 专注SQL调优 性能调优
11-18 702
利用ORDERED_PREDICATES优化多个自定函数作为WHERE过滤条件
mysql cardinality 索引选择
在路上
02-17 2995
官方文档的解释： An estimate of the number of unique values in the index. This is updated by running ANALYZE TABLE or myisamchk -a. Cardinality is counted based on statistics stored as integers, so the value
GateWay中的predicates和Filter
热门推荐
蚂蚁大象的博客
06-16 1万+
GateWay中的predicates和Filter路由route的组成部分什么是predicates 路由route的组成部分 id： 路由的ID uri： 匹配路由的转发地址 predicates： 配置该路由的断言，通过PredicateDefinition类进行接收配置。 order： 路由的优先级，数字越小，优先级越高。 Filter: 过滤器 过滤掉一些请求， 满足则转发 什么是predicates 配置该路由的断言，通过PredicateDefinition
DB优化小常识 - 执行计划中Cardinality的计算
cuixie2370的博客
07-18 448
DB中如果我们使用CBO作为优化器，一条SQl语句就会有多种执行路径，那么CBO会计算各个执行路径的访问代价，选择代价最小的作为我们的执行计划。CBO在做访问路径估算的时候有一个很重要的...
Oracle优化器 Cardinality基数与Selectivity选择性
12-14
优化器有两种主要类型：基于规则的优化器（RBO）和基于成本的优化器（CBO）。这两种优化器在选择执行路径时遵循不同的策略。 RBO，即Rule-Based Optimization，依赖于预定义的执行路径等级。Oracle为每种可能的执行...
Better with Fewer Bits - Improving the Performance of Cardinality Estimation of Large Data Streams (INFOCOM2017)-计算机科学
04-22
Better with Fewer Bits - Improving the Performance of Cardinality Estimation of Large Data Streams (INFOCOM2017)-计算机科学
进阶-第47__深入聚合数据分析_cardinality算法之优化内存开销以及HLL算法
qq_35524586的博客
03-15 1065
Cardinality 实际上就是做count(distinct)但是cardinality有5%的错误率，但是性能在100ms左右 1、precision_threshold优化准确率和内存开销 GET /tvs/sales/_search { "size" : 0, "aggs" : { "distinct_brand" : { ...
mysql字典表查询优化_mysql8 参考手册--优化INFORMATION_SCHEMA查询
weixin_39538687的博客
02-08 481
在MySQL中，把 information_schema 看作是一个数据库，确切说是信息数据库。其中保存着关于MySQL服务器所维护的所有其他数据库的信息。如数据库名，数据库的表，表栏的数据类型与访问权 限等。在INFORMATION_SCHEMA中，有数个只读表。它们实际上是视图，而不是基本表，因此，你将无法看到与之相关的任何文件。information_schema数据库表说明:SCHEMAT...
Oracle提高SQL执行效率的三种方法
weixin_34122604的博客
01-18 429
2019独角兽企业重金招聘Python工程师标准>>> ...
Oracle优化器对谓词顺序处理的一个场景
bisal的专栏
03-15 281
最近听了个讲座，其中介绍到了Oracle的谓词，原始版本的例子，如下所示，从数据上能看到，c1='3'的时候，c2的值是个字符串类型的数字，SQL>createtabletes...
oracle hint cardinality,Oracle使用的hints调整机制
weixin_42515372的博客
04-10 677
10g数据库可以使用更多新的optimizer hints来控制优化行为。现在让我们快速解析一下这些强大的新hints：1、spread_min_analysis使用这一hint，你可以忽略一些关于如详细的关系依赖图分析等电子表格的编译时间优化规则。其他的一些优化，如创建过滤以有选择性的定位电子表格访问结构并限制修订规则等，得到了继续使用。由于在规则数非常大的情况下，电子表格分析会很长。这一提示可...
执行计划Est. Rows Rows 偏差很大的处理
最新发布
jnrjian的博客
01-05 559
cardinality( a,10000)
hint---CARDINALITY
ciliting2867的博客
11-20 510
使用CARDINALITY这个hint，可以通过指定返回的记录数来迫使oracle改变执行计划，当优化器对某个结果集返回的行数估计出现较大偏差时，通过这个hint可以尝试让优化器产生正确的执行计划。 sys@EBANK&...
mysql优化级别range和ref_MySQL源码:Range和Ref优化的成本评估
weixin_39897218的博客
01-18 2231
在开始介绍index merge/ROR优化之前，打算先介绍MySQL是如何对range/ref做成本评估的。MySQL是基于成本(cost)模型选择执行计划，在多个range，全表扫描，ref之间会选择成本最小的作为最终的执行计划。仍然强烈建议先阅读登博的slide：《查询优化浅析》，文中在开始介绍index merge/ROR优化之前，打算先介绍MySQL是如何对range/ref做成本评估的...
MySQL 8.x新特性之——优化器索引
冰河的专栏
11-30 1948
MySQL 8.x中新增了三种索引方式，如下所示。 隐藏索引 降序索引 函数索引 一、隐藏索引 1.隐藏索引概述 MySQL 8.0开始支持隐藏索引（invisible index），不可见索引。 隐藏索引不会被优化器使用，但仍然需要进行维护。 应用场景：软删除、灰度发布。 在之前MySQL的版本中，只能通过显式的方式删除索引，如果删除后发现索引删错了，又只能通过创建索引的方式将删除...
Postgresql管理系列-第三章Query Processing(下半部分-join operation介绍)
魂醉的一亩二分地
06-10 1076
接第三章的上半部分 3.5. 连接操作 PostgreSQL 支持三个联接操作: 嵌套循环联接、合并联接和哈希联接。PostgreSQL 中的嵌套循环联接和合并联接有几种变体。 下面, 我们假设读者熟悉这三个连接的基本行为。如果您不熟悉这些术语, 请参阅 [1, 2]。但是, 那里没有太多关于混合哈希联接与 PostgreSQL 支持的倾斜的解释, 因为将在此处进行更详细的解释。 请注意, Pos...
Postgresql杂谈 14—Postgresql执行计划中的扫描和连接类型
Hyman的博客
08-09 1753
一、全表扫描 全表扫描，也叫顺序扫描，扫描时把表中所有的数据块从头到尾遍历一边，找到复合条件的数据块。全表扫描在在explain中使用Seq Scan表示： stock_analysis_data=# explain (analyze,verbose,buffers,costs,timing) select * from t1 where id=10; QUERY PLAN ...
PostgreSQL的查询语句的连接方式与查询计划比较--多表连接（一）
那海蓝蓝的博客
03-13 2059
--Step1：准备数据，创建表，插入数据，注意数据的设计，每个表是3种情况，目的是看字段为NULL时，各种连接的处理方式 create table A (idA INT, c1 int, c2 int); create table B (idB INT, c1 int, c2 int); create table C (idC INT, c1 int, c2 int); create t
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

紫无之紫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值