postgresql 中的慢 OR 语句

2023-12-24

我目前的 postgresql 查询由于 OR 语句而变慢。因此，它显然没有使用索引。到目前为止，重写此查询失败。

查询：

EXPLAIN ANALYZE SELECT a0_.id AS id0
FROM   advert a0_
       INNER JOIN advertcategory a1_
               ON a0_.advert_category_id = a1_.id
WHERE  a0_.advert_category_id IN ( 1136 )
        OR a1_.parent_id IN ( 1136 )
ORDER  BY a0_.created_date DESC
LIMIT  15;  

                                                                           QUERY PLAN                                                                                
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 Limit  (cost=0.00..27542.49 rows=15 width=12) (actual time=1.658..50.809 rows=15 loops=1)
   ->  Nested Loop  (cost=0.00..1691109.07 rows=921 width=12) (actual time=1.657..50.790 rows=15 loops=1)
         ->  Index Scan Backward using advert_created_date_idx on advert a0_  (cost=0.00..670300.17 rows=353804 width=16) (actual time=0.013..16.449 rows=12405 loops=1)
         ->  Index Scan using advertcategory_pkey on advertcategory a1_  (cost=0.00..2.88 rows=1 width=8) (actual time=0.002..0.002 rows=0 loops=12405)
               Index Cond: (id = a0_.advert_category_id)
               Filter: ((a0_.advert_category_id = 1136) OR (parent_id = 1136))
               Rows Removed by Filter: 1
 Total runtime: 50.860 ms

缓慢的原因：Filter: ((a0_.advert_category_id = 1136) OR (parent_id = 1136))

我尝试使用 INNER JOIN 而不是 WHERE 语句：

EXPLAIN ANALYZE  SELECT a0_.id AS id0
FROM   advert a0_
       INNER JOIN advertcategory a1_
               ON a0_.advert_category_id = a1_.id
                  AND ( a0_.advert_category_id IN ( 1136 )
                         OR a1_.parent_id IN ( 1136 ) )
ORDER  BY a0_.created_date DESC
LIMIT  15;  

                                                                                QUERY PLAN                                                                                
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 Limit  (cost=0.00..27542.49 rows=15 width=12) (actual time=4.667..139.955 rows=15 loops=1)
   ->  Nested Loop  (cost=0.00..1691109.07 rows=921 width=12) (actual time=4.666..139.932 rows=15 loops=1)
         ->  Index Scan Backward using advert_created_date_idx on advert a0_  (cost=0.00..670300.17 rows=353804 width=16) (actual time=0.019..100.765 rows=12405 loops=1)
         ->  Index Scan using advertcategory_pkey on advertcategory a1_  (cost=0.00..2.88 rows=1 width=8) (actual time=0.002..0.002 rows=0 loops=12405)
               Index Cond: (id = a0_.advert_category_id)
               Filter: ((a0_.advert_category_id = 1136) OR (parent_id = 1136))
               Rows Removed by Filter: 1
 Total runtime: 140.048 ms

当我删除一个 OR 条件时，查询速度会加快。所以我做了一个 UNION 来查看结果。速度非常快！但我不认为这是一个解决方案：

EXPLAIN ANALYZE 
 (SELECT a0_.id AS id0
 FROM   advert a0_
        INNER JOIN advertcategory a1_
                ON a0_.advert_category_id = a1_.id
 WHERE  a0_.advert_category_id IN ( 1136 )
 ORDER  BY a0_.created_date DESC
 LIMIT  15)
UNION
(SELECT a0_.id AS id0
 FROM   advert a0_
        INNER JOIN advertcategory a1_
                ON a0_.advert_category_id = a1_.id
 WHERE  a1_.parent_id IN ( 1136 )
 ORDER  BY a0_.created_date DESC
 LIMIT  15);  

                                                                               QUERY PLAN                                                                                    
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 HashAggregate  (cost=4125.70..4126.00 rows=30 width=12) (actual time=7.945..7.951 rows=15 loops=1)
   ->  Append  (cost=1120.82..4125.63 rows=30 width=12) (actual time=6.811..7.929 rows=15 loops=1)
         ->  Subquery Scan on "*SELECT* 1"  (cost=1120.82..1121.01 rows=15 width=12) (actual time=6.810..6.840 rows=15 loops=1)
               ->  Limit  (cost=1120.82..1120.86 rows=15 width=12) (actual time=6.809..6.825 rows=15 loops=1)
                     ->  Sort  (cost=1120.82..1121.56 rows=295 width=12) (actual time=6.807..6.813 rows=15 loops=1)
                           Sort Key: a0_.created_date
                           Sort Method: top-N heapsort  Memory: 25kB
                           ->  Nested Loop  (cost=10.59..1113.59 rows=295 width=12) (actual time=1.151..6.639 rows=220 loops=1)
                                 ->  Index Only Scan using advertcategory_pkey on advertcategory a1_  (cost=0.00..8.27 rows=1 width=4) (actual time=1.030..1.033 rows=1 loops=1)
                                       Index Cond: (id = 1136)
                                       Heap Fetches: 1
                                 ->  Bitmap Heap Scan on advert a0_  (cost=10.59..1102.37 rows=295 width=16) (actual time=0.099..5.287 rows=220 loops=1)
                                       Recheck Cond: (advert_category_id = 1136)
                                       ->  Bitmap Index Scan on idx_54f1f40bd4436821  (cost=0.00..10.51 rows=295 width=0) (actual time=0.073..0.073 rows=220 loops=1)
                                             Index Cond: (advert_category_id = 1136)
         ->  Subquery Scan on "*SELECT* 2"  (cost=3004.43..3004.62 rows=15 width=12) (actual time=1.072..1.072 rows=0 loops=1)
               ->  Limit  (cost=3004.43..3004.47 rows=15 width=12) (actual time=1.071..1.071 rows=0 loops=1)
                     ->  Sort  (cost=3004.43..3005.99 rows=626 width=12) (actual time=1.069..1.069 rows=0 loops=1)
                           Sort Key: a0_.created_date
                           Sort Method: quicksort  Memory: 25kB
                           ->  Nested Loop  (cost=22.91..2989.07 rows=626 width=12) (actual time=1.056..1.056 rows=0 loops=1)
                                 ->  Index Scan using idx_d84ab8ea727aca70 on advertcategory a1_  (cost=0.00..8.27 rows=1 width=4) (actual time=1.054..1.054 rows=0 loops=1)
                                       Index Cond: (parent_id = 1136)
                                 ->  Bitmap Heap Scan on advert a0_  (cost=22.91..2972.27 rows=853 width=16) (never executed)
                                       Recheck Cond: (advert_category_id = a1_.id)
                                       ->  Bitmap Index Scan on idx_54f1f40bd4436821  (cost=0.00..22.70 rows=853 width=0) (never executed)
                                             Index Cond: (advert_category_id = a1_.id)
 Total runtime: 8.940 ms
(28 rows)

尝试反转 IN 语句：

EXPLAIN ANALYZE  SELECT a0_.id AS id0
FROM   advert a0_
       INNER JOIN advertcategory a1_
               ON a0_.advert_category_id = a1_.id
WHERE  1136 IN ( a0_.advert_category_id, a1_.parent_id )
ORDER  BY a0_.created_date DESC
LIMIT  15;  

                                                                               QUERY PLAN                                                                                
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 Limit  (cost=0.00..27542.49 rows=15 width=12) (actual time=1.848..62.461 rows=15 loops=1)
   ->  Nested Loop  (cost=0.00..1691109.07 rows=921 width=12) (actual time=1.847..62.441 rows=15 loops=1)
         ->  Index Scan Backward using advert_created_date_idx on advert a0_  (cost=0.00..670300.17 rows=353804 width=16) (actual time=0.028..27.316 rows=12405 loops=1)
         ->  Index Scan using advertcategory_pkey on advertcategory a1_  (cost=0.00..2.88 rows=1 width=8) (actual time=0.002..0.002 rows=0 loops=12405)
               Index Cond: (id = a0_.advert_category_id)
               Filter: ((1136 = a0_.advert_category_id) OR (1136 = parent_id))
               Rows Removed by Filter: 1
 Total runtime: 62.506 ms
(8 rows)

尝试使用 EXISTS：

EXPLAIN ANALYZE  SELECT a0_.id AS id0
FROM   advert a0_
       INNER JOIN advertcategory a1_
               ON a0_.advert_category_id = a1_.id
WHERE  EXISTS(SELECT test.id
              FROM   advert test
                     INNER JOIN advertcategory test_cat
                             ON test_cat.id = test.advert_category_id
              WHERE  test.id = a0_.id
                     AND ( test.advert_category_id IN ( 1136 )
                            OR test_cat.parent_id IN ( 1136 ) ))
ORDER  BY a0_.created_date DESC
LIMIT  15;  

                                                                          QUERY PLAN                                                                           
---------------------------------------------------------------------------------------------------------------------------------------------------------------
 Limit  (cost=45538.18..45538.22 rows=15 width=12) (actual time=524.654..524.673 rows=15 loops=1)
   ->  Sort  (cost=45538.18..45540.48 rows=921 width=12) (actual time=524.651..524.658 rows=15 loops=1)
         Sort Key: a0_.created_date
         Sort Method: top-N heapsort  Memory: 25kB
         ->  Hash Join  (cost=39803.59..45515.58 rows=921 width=12) (actual time=497.362..524.436 rows=220 loops=1)
               Hash Cond: (a0_.advert_category_id = a1_.id)
               ->  Nested Loop  (cost=39786.88..45486.21 rows=921 width=16) (actual time=496.748..523.501 rows=220 loops=1)
                     ->  HashAggregate  (cost=39786.88..39796.09 rows=921 width=4) (actual time=496.705..496.872 rows=220 loops=1)
                           ->  Hash Join  (cost=16.71..39784.58 rows=921 width=4) (actual time=1.210..496.294 rows=220 loops=1)
                                 Hash Cond: (test.advert_category_id = test_cat.id)
                                 Join Filter: ((test.advert_category_id = 1136) OR (test_cat.parent_id = 1136))
                                 Rows Removed by Join Filter: 353584
                                 ->  Seq Scan on advert test  (cost=0.00..33134.04 rows=353804 width=8) (actual time=0.002..177.953 rows=353804 loops=1)
                                 ->  Hash  (cost=9.65..9.65 rows=565 width=8) (actual time=0.622..0.622 rows=565 loops=1)
                                       Buckets: 1024  Batches: 1  Memory Usage: 22kB
                                       ->  Seq Scan on advertcategory test_cat  (cost=0.00..9.65 rows=565 width=8) (actual time=0.005..0.327 rows=565 loops=1)
                     ->  Index Scan using advert_pkey on advert a0_  (cost=0.00..6.17 rows=1 width=16) (actual time=0.117..0.118 rows=1 loops=220)
                           Index Cond: (id = test.id)
               ->  Hash  (cost=9.65..9.65 rows=565 width=4) (actual time=0.604..0.604 rows=565 loops=1)
                     Buckets: 1024  Batches: 1  Memory Usage: 20kB
                     ->  Seq Scan on advertcategory a1_  (cost=0.00..9.65 rows=565 width=4) (actual time=0.010..0.285 rows=565 loops=1)
 Total runtime: 524.797 ms

广告表（精简）：

353804 rows
                                                                   Table "public.advert"
           Column            |              Type              |                      Modifiers                      | Storage  | Stats target | Description 
-----------------------------+--------------------------------+-----------------------------------------------------+----------+--------------+-------------
 id                          | integer                        | not null default nextval('advert_id_seq'::regclass) | plain    |              | 
 advert_category_id          | integer                        | not null                                            | plain    |              | 
Indexes:
    "idx_54f1f40bd4436821" btree (advert_category_id)
    "advert_created_date_idx" btree (created_date)
Foreign-key constraints:
    "fk_54f1f40bd4436821" FOREIGN KEY (advert_category_id) REFERENCES advertcategory(id) ON DELETE RESTRICT
Has OIDs: no

类别表（精简）：

565 rows

                           Table "public.advertcategory"
  Column   |  Type   |                          Modifiers                          
-----------+---------+-------------------------------------------------------------
 id        | integer | not null default nextval('advertcategory_id_seq'::regclass)
 parent_id | integer | 
 active    | boolean | not null
 system    | boolean | not null
Indexes:
    "advertcategory_pkey" PRIMARY KEY, btree (id)
    "idx_d84ab8ea727aca70" btree (parent_id)
Foreign-key constraints:
    "fk_d84ab8ea727aca70" FOREIGN KEY (parent_id) REFERENCES advertcategory(id) ON DELETE RESTRICT

简短的服务器配置：

                                                   version                                                    
--------------------------------------------------------------------------------------------------------------
 PostgreSQL 9.2.4 on x86_64-unknown-linux-gnu, compiled by gcc (GCC) 4.4.7 20120313 (Red Hat 4.4.7-3), 64-bit

            name            |  current_setting   |        source        
----------------------------+--------------------+----------------------
 shared_buffers             | 1800MB             | configuration file
 work_mem                   | 4MB                | configuration file

正如您所看到的，没有任何适当的解决方案可以提高速度。只有采用UNION方案来拆分OR语句才能提高性能。但我无法使用它，因为这个查询是通过我的 ORM 框架与许多其他过滤器选项一起使用的。另外，如果我可以做到这一点，为什么优化器不这样做呢？这似乎是一个非常简单的优化。

对此有任何提示吗？这个小问题的解决方案将不胜感激！

全新的方法。你的where条件在两个表上，但这似乎没有必要。

第一个改变是：

where a1_.id = 1136 or a1_.parent_id = 1136

我认为您想要的结构是扫描类别表，然后从广告表中获取。为了提供帮助，您可以创建索引advert(advert_category_id, created_date).

我很想通过移动来编写查询where子查询中的子句。我不知道这是否会影响性能：

SELECT a0_.id AS id0
FROM   advert a0_ INNER JOIN
       (select ac.*
        from advertcategory ac
        where ac.id = 1136 or ac.parent_id = 1136
       ) ac
       ON a0_.advert_category_id = ac.id
ORDER  BY a0_.created_date DESC
LIMIT  15;

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

sql

postgresql

postgresql 中的慢 OR 语句的相关文章

MySQL“LIKE”搜索不起作用

我通过 LOAD DATA INFILE 在 MySQL 中导入了一个 txt 数据库一切似乎都正常唯一的问题是如果我使用以下查询在数据库上搜索记录 SELECT FROM hobby WHERE name LIKE Beading
将 .MDF SQL Server 数据库与 ASP.NET 结合使用与使用 SQL Server

我目前正在 ASP NET MVC 中编写一个网站我的数据库其中还没有任何数据只有正确的表使用 SQL Server 2008 我已将其安装在我的开发计算机上我使用服务器资源管理器从应用程序连接到数据库然后使用 LINQ to
有没有办法阻止 SQL Express 2008 空闲？

我使用 SQL Express 2008 作为 Web 应用程序的后端问题是 Web 应用程序是在工作时间使用的因此有时在午餐或休息时间如果 20 分钟内没有用户登录 SQL Express 将进入空闲状态模式并释放其缓存我知道这一
SQL：如何在按部分分组的查询中使用子查询？

如何在按部分分组的查询中使用子查询我使用 SQL Server 2008 R2 和 Delphi 2010 我收到此错误 Cannot perform an aggregate function on an expression cont
PostgreSQL 中“-”处或附近的语法错误

我正在尝试运行查询来更新用户密码 alter user dell sys with password Pass 133 但因为它给了我这样的错误 ERROR syntax error at or near LINE 1 alter use
无法为数据库添加 SSL 支持

我正在使用 Spring 3 Hibernate 和 postgres 9 2 为了启用 SSL 数据库连接我按照以下步骤操作创建自签名证书参考 http www postgresql org docs 9 2 static ssl
如何搜索例程的内容/（SP-触发函数）

我需要在数据库内所有例程的例程主体存储过程函数触发器中搜索文本我该怎么做 Thanks SELECT OBJECT NAME object id FROM sys sql modules WHERE definition LIKE
PostgreSQL-过滤日期范围

我是一名 SQL 开发人员大部分时间都花在 MSSQL 上我正在寻找一种更好的方法来过滤 PostgreSQL 数据库中的无时区时间戳字段我在用着 Where DateField gt 2010 01 01 and DateFie
MySQL中如何声明变量？

如何在mysql中声明一个变量以便我的第二个查询可以使用它我想写一些类似的东西 SET start 1 SET finish 10 SELECT FROM places WHERE place BETWEEN start AND fin
为 Rails 上的 postgresql 创建用户

我选择 postgresql 作为我的 Rails 数据库但当我尝试运行 rake db create all 时我遇到了一个明显常见的错误即致命角色 app 不存在我找到了两种解决方案但我不确定哪一种是正确的有一个网站说
st_intersects 与 st_overlaps

这两个查询有什么区别 select a gid sum length b the geom from polygons as a roads as b where st intersects a the geom b the geom gr
在 SQL Server 上执行分页的最佳方式是什么？

我有一个数据库超过200万记录我需要执行分页以在我的 Web 应用程序上显示该应用程序每页必须有 10 条记录DataGrid 我已经尝试使用ROW NUMBER 但是这种方式会选择所有 200 万条记录然后只得到 10 条记录我也
H2 用户定义的聚合函数 ListAgg 不能在第一个参数上使用 DISTINCT 或 TRIM()

所以我有一个 DB2 生产数据库我需要在其中使用可用的函数 ListAgg 我希望使用 H2 的单元测试能够正确测试此功能不幸的是H2不直接支持ListAgg 但是我可以创建一个用户定义的聚合函数 import java sql Co
如何使用 django ORM 在外键字段上连接两个表？

假设我有以下模型 class Position models Model name models CharField class PositionStats models Model position models ForeignKey P
如何在 DB2 中创建返回序列值的函数？

如何在 DB2 中创建一个从序列中获取值并返回该值的函数应该可以在 select 或 insert 语句中使用该函数例如 select my func from xxx insert into xxx values my func 基本
数字表与递归 CTE 生成一系列数字

为什么使用数字表比使用递归 CTE 动态生成它们要快得多在我的机器上给定一张桌子numbers单列n 主键包含从1到100000的数字查询如下 select n from numbers 大约需要 400 毫秒才能完成使用递归 C
从 Getdate() 获取时间

我想采取Getdate 结果例如 2011 10 05 11 26 55 000 into 11 26 55 AM 我看过其他地方并发现 Select RIGHT CONVERT VARCHAR GETDATE 100 7 这给了我 11
Spark SQL 中的 SQL LIKE

我正在尝试使用 LIKE 条件在 Spark SQL 中实现联接我正在执行连接的行看起来像这样称为修订 Table A 8NXDPVAE Table B 4 8 NXD V 在 SQL Server 上执行联接 A revision
如何在 pg-promise 中设置模式

我正在搜索的文档pg 承诺 https github com vitaly t pg promise特别是在创建客户端时但我无法找到设置连接中使用的默认架构的选项它始终使用public架构我该如何设置通常为数据库或角色设置默认架构
如何将 PostgreSql 与 EntityFramework 6.0.2 集成？ [复制]

这个问题在这里已经有答案了我收到以下错误实体框架提供程序类型的实例成员 Npgsql NpgsqlServices Npgsql 版本 2 0 14 2 文化中性 PublicKeyToken 5d8b90d52f46fda7 没

随机推荐

dplyr：在数据帧中使用连续重复 n 次的整数来改变新列

我正在努力解决一个可能很简单的问题我有一个 1 列 n 行的数据框 n 是 3 的倍数我想添加第二列其中包含整数例如 1 1 1 2 2 2 3 3 3 4 4 4 5 5 5 如何实现此目的dplyr 作为不同长度行均为 3 的
如何使用 cx_freeze 在 python 中创建 .EXE 文件

我有一个用 python 3 2 开发的应用程序它有内置模块例如 Tkinter matplotlib openpyxl 用户定义的模块和类例如 draw graph generate report 图标文件日志文件 csv doc
如何在 Kotlin 中将数据类转换为 ByteBuffer？

我正在尝试使用 Kinesis 它需要字节缓冲区格式的数据到目前为止我看到的所有示例都是用 Java 编写的并传递简单的字符串任何人都可以知道如何将 kotlin 数据类转换为 bytebuffer 吗例如数据类 abc 变种
强制使用 xsd 元素

我有一个 xml 文件正在尝试针对 xsd 文件进行验证工作正常我想修改 xsd 以强制元素值我该如何做到这一点以便当我验证 xml 文件时如果该元素我希望它失败FirstName为空
为什么 IsNull 比合并慢两倍（相同查询）？

我们在 SQL Server 2008 SP1 10 0 2531 0 X64 Win2008 SP2 X64 上遇到了奇怪的情况这是一个繁重的查询 select t1 id t2 id from t1 t2 where t1 id t2
Linux 内核模块 (*.ko) 内核之间的兼容性

我有一个简单的内核对象用于探测内核内存如果我在 64 位 Ubuntu 3 2 机器上构建它它就可以在该机器上正常运行但它不会在我的 64 位 Ubuntu 3 9 机器上安装反之亦然如果我尝试在内核版本上运行它而不是我构建它的
跨多个 Browserify 或 Webpack 捆绑包共享通过 NPM 加载的模块的简单解决方案

把我的头发拉出来寻找simple通过 NPM 跨多个 Browserify 或 Webpack 捆绑包共享代码的解决方案思考是否存在文件桥梁这样的东西这不是由于编译时间我知道 watchify 而是由于希望将所有供应商特定的库提
如何在 Angular 2 中制作这个 jQuery 事件处理程序？

我正在 Angular 2 中创建一个 Web 应用程序在其中一个页面上我使用了一个名为的 jQuery 插件jquery 评论 https github com Viima jquery comments 启用用户评论现在如果用户
插入期间字符串未被识别为有效的日期时间

当我尝试转换为日期时间时出现以下错误字符串未被识别为有效的日期时间 cost b date DateTime Parse c date Text c date Text 12 28 2012 然后我尝试 string date strin
Java2D OpenGL 图形加速不起作用

我想将 Swing 与 Java2D OpenGL 图形加速一起使用然而它不起作用我自己回答了这个问题因为我寻找解决方案很长一段时间这是我的代码 import javax swing JFrame import javax swi
回滚 GitHub Desktop（或 Windows 版 Github）中未提交的更改

我在用着Github 桌面 https desktop github com 以前称为适用于 Windows 的 GitHub https windows github com 并且我对本地文件做了很多更改事情变得如此混乱我决定只想将本
WordPress 上的 Google Analytics 事件跟踪

我试图在单击特定菜单项时发送事件我的头脚本如下
BI 设计器多对多关系

我是 Microsoft Power BI 设计器的新手注意到了这一点文档 https support powerbi com knowledgebase articles 464155 create and manage relatio
使用霍夫变换、OpenCV 和 python 进行平行线检测

我需要有关我一直在研究的算法的帮助我试图检测阈值图像中的所有线条检测所有线条然后仅输出平行的线条阈值图像输出我感兴趣的对象然后我通过精明的边缘检测器过滤该图像然后将该边缘图像通过概率霍夫变换现在我希望该算法能够检测任何图像中
将 Java byte[] 对象插入 H2 表中，然后再次检索它

我正在尝试将 Java byte 插入 H2 数据库表中然后再次检索它但我没有取得成功根据这一页 http www h2database com html datatypes html binary type BINARY 数据类型直
无法使用 jdbcStorageHandler 创建 Hive 外部表

我正在 Amazone EMR 中运行一个小型集群以便使用 Apache Hive 2 3 5 据我了解 Apache Hive 可以从远程数据库导入数据并让集群运行查询我正在遵循 Apache Hive Web 文档中提供的示例 ht
遵循 Python/Flask Heroku 教程时出现“foreman start”错误

遵循所有指示运行的时候出现这个错误foreman start C Program Files x86 ruby 1 9 3 lib ruby gems 1 9 1 gems foreman 0 47 0 lib fo reman engi
使窗口成为桌面的一部分

我想创建一个窗口 CreateWindowEx WS EX TOOLWINDOW WS EX LAYERED wc lpszClassName 0 WS POPUP WS VISIBLE WS SYSMENU a part桌面的我知道这可
2020 年以上，Typescript 在运行时使用类型防护按类型或接口检查对象

对我来说大多数时候需要动态检查来验证获取响应我在想对于具有多个道具和附加检查的任何类型的对象可以使用用户定义的类型保护以通用方式完成此操作因此可以使用类似的方法这是一个带有示例对象的示例但我想要一个没有它的函数 https
postgresql 中的慢 OR 语句

我目前的 postgresql 查询由于 OR 语句而变慢因此它显然没有使用索引到目前为止重写此查询失败查询 EXPLAIN ANALYZE SELECT a0 id AS id0 FROM advert a0 INNER JOI

postgresql 中的慢 OR 语句

postgresql 中的慢 OR 语句 的相关文章

随机推荐

热门标签

postgresql 中的慢 OR 语句的相关文章