SQL优化篇之-如何减少耗时查询的调用次数

最新推荐文章于 2024-04-03 17:03:00 发布
最新推荐文章于 2024-04-03 17:03:00 发布
阅读量624 收藏
点赞数
文章标签： sql 数据库 mysql mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lyu1026/article/details/128332896
版权

背景

在查询语句中，如果 Select 子句中，调用较为耗时的函数或子查询，比较各种SQL语句的编写方案，得出其中最优选择。

一、数据准备，SQL 语句

  • 模拟较耗时的用户函数或子查询

确保执行子查询的时长是1秒。

create or replace function f001()
returns int stable language sql
as
$$
  select 1 from pg_sleep(1);
$$;
  • 模拟返回多行数据的子查询

结果集中，关联条件列含有重复值。

test=# create table t1 as select sn, id from (select generate_series(1, 3) sn),    (select generate_series(3, 8) id);
SELECT 18
test=# create table t2 as select generate_series(1, 5) id;
SELECT 5

test=# select * from t1;
 sn | id
----+----
  1 |  3
  2 |  3
  3 |  3
  1 |  4
  2 |  4
  3 |  4
  1 |  5
  2 |  5
  3 |  5
  1 |  6
  2 |  6
  3 |  6
  1 |  7
  2 |  7
  3 |  7
  1 |  8
  2 |  8
  3 |  8
(18 rows)

test=# select * from t2;
 id
----
  1
  2
  3
  4
  5
(5 rows)

二、查询全体数据的优化方案

1、初始SQL

with a as (select sn, id  from t1 )
select a.*, (select  id + f001()  sq_sum from t2 b where b.id = a.id)
from a
where 1 = 1;

 sn | id | sq_sum
----+----+--------
  1 |  3 |      4
  2 |  3 |      4
  3 |  3 |      4
  1 |  4 |      5
  2 |  4 |      5
  3 |  4 |      5
  1 |  5 |      6
  2 |  5 |      6
  3 |  5 |      6
  1 |  6 |
  2 |  6 |
  3 |  6 |
  1 |  7 |
  2 |  7 |
  3 |  7 |
  1 |  8 |
  2 |  8 |
  3 |  8 |

                                                 QUERY PLAN
-------------------------------------------------------------------------------------------------------------
 Seq Scan on t1  (cost=0.00..101806.05 rows=2260 width=12) (actual time=1000.638..9008.584 rows=18 loops=1)
   SubPlan 1
     ->  Seq Scan on t2 b  (cost=0.00..45.03 rows=13 width=4) (actual time=500.465..500.468 rows=0 loops=18)
           Filter: (id = t1.id)
           Rows Removed by Filter: 4
 Planning Time: 0.149 ms
 Execution Time: 9008.667 ms
(7 rows)

2、CTE

使用临时表的结果进行连接，避免循环。注意，这里CTE 有materilaized 选项，主要是把耗时的部分先执行出结果，避免与其他部分查询合并，引发多次执行。

with a as (select sn, id  from t1),
     b as materialized (select id, id + f001() sq_sum from t2 )
select a.*, (select sq_sum from b where b.id = a.id)
from a
where 1 = 1;

                                                  QUERY PLAN
---------------------------------------------------------------------------------------------------------------
 Seq Scan on t1  (cost=676.75..129868.35 rows=2260 width=12) (actual time=5004.377..5004.392 rows=18 loops=1)
   CTE b
     ->  Seq Scan on t2  (cost=0.00..676.75 rows=2540 width=8) (actual time=1000.562..5004.348 rows=5 loops=1)
   SubPlan 2
     ->  CTE Scan on b  (cost=0.00..57.15 rows=13 width=4) (actual time=166.821..278.021 rows=0 loops=18)
           Filter: (id = t1.id)
           Rows Removed by Filter: 4
 Planning Time: 0.107 ms
 Execution Time: 5004.441 ms
(9 rows)

3、LEFT JOIN 子查询

与上例一样，还是利用materialize 特性，避免了函数的多次调用。

with a as (select sn, id from t1)
select a.*, b.sq_sum
from a  left join (select id, id + f001() sq_sum  from t2 ) b on b.id = a.id
where 1 = 1 ;

                                                    QUERY PLAN
-------------------------------------------------------------------------------------------------------------------
 Nested Loop Left Join  (cost=0.00..86821.70 rows=28702 width=12) (actual time=3002.905..5005.627 rows=18 loops=1)
   Join Filter: (t2.id = t1.id)
   Rows Removed by Join Filter: 81
   ->  Seq Scan on t1  (cost=0.00..32.60 rows=2260 width=8) (actual time=0.007..0.011 rows=18 loops=1)
   ->  Materialize  (cost=0.00..689.45 rows=2540 width=8) (actual time=55.621..278.088 rows=5 loops=18)
         ->  Seq Scan on t2  (cost=0.00..676.75 rows=2540 width=8) (actual time=1001.176..5005.568 rows=5 loops=1)
 Planning Time: 0.180 ms
 Execution Time: 5005.650 ms
(8 rows)

三、查询局部数据(过滤主表的条件)的优化方案

1、初始SQL

with a as (select sn, id from t1)
select a.*, (select  id + f001() sq_sum from  t2  b where b.id = a.id)
from a
where 1 = 1 and a.id = 3;

 sn | id | sq_sum
----+----+--------
  1 |  3 |      4
  2 |  3 |      4
  3 |  3 |      4
(3 rows)

                                                  QUERY PLAN
--------------------------------------------------------------------------------------------------------------
 Seq Scan on t1  (cost=0.00..533.61 rows=11 width=12) (actual time=1000.356..3002.635 rows=3 loops=1)
   Filter: (id = 3)
   Rows Removed by Filter: 15
   SubPlan 1
     ->  Seq Scan on t2 b  (cost=0.00..45.03 rows=13 width=4) (actual time=1000.859..1000.866 rows=1 loops=3)
           Filter: (id = t1.id)
           Rows Removed by Filter: 4
 Planning Time: 0.164 ms
 Execution Time: 3002.657 ms
(9 rows)

2、CTE

with a as (select sn, id from t1),
     b as materialized (select id, id + f001() sq_sum from t2)
select a.*, (select sq_sum from b where b.id = a.id) sq_sum 
from a
where 1 = 1 and a.id=3 ;

                                                  QUERY PLAN
---------------------------------------------------------------------------------------------------------------
 Seq Scan on t1  (cost=676.75..1343.65 rows=11 width=12) (actual time=5004.958..5004.965 rows=3 loops=1)
   Filter: (id = 3)
   Rows Removed by Filter: 15
   CTE b
     ->  Seq Scan on t2  (cost=0.00..676.75 rows=2540 width=8) (actual time=1001.387..5004.930 rows=5 loops=1)
   SubPlan 2
     ->  CTE Scan on b  (cost=0.00..57.15 rows=13 width=4) (actual time=1001.132..1668.316 rows=1 loops=3)
           Filter: (id = t1.id)
           Rows Removed by Filter: 4
 Planning Time: 0.105 ms
 Execution Time: 5004.983 ms
(11 rows)

3、LEFT JOIN 子查询

explain analyse
with a as (select sn, id from t1)
select a.*, b.sq_sum
from a left  join (select id, id + f001() sq_sum from t2) b on b.id = a.id
where 1 = 1 and a.id = 3 ;

                                                   QUERY PLAN
----------------------------------------------------------------------------------------------------------------
 Nested Loop Left Join  (cost=0.00..85.46 rows=143 width=12) (actual time=1000.972..1000.980 rows=3 loops=1)
   Join Filter: (t2.id = t1.id)
   ->  Seq Scan on t1  (cost=0.00..38.25 rows=11 width=8) (actual time=0.008..0.009 rows=3 loops=1)
         Filter: (id = 3)
         Rows Removed by Filter: 15
   ->  Materialize  (cost=0.00..45.10 rows=13 width=8) (actual time=333.654..333.656 rows=1 loops=3)
         ->  Seq Scan on t2  (cost=0.00..45.03 rows=13 width=8) (actual time=1000.959..1000.964 rows=1 loops=1)
               Filter: (id = 3)
               Rows Removed by Filter: 4
 Planning Time: 0.107 ms
 Execution Time: 1000.996 ms
(11 rows)

四、查询局部数据(过滤从表的条件)的优化方案

1、初始SQL

with a as (select sn, id from (select generate_series(1, 3) sn), (select generate_series(3, 8) id))
select a.*, (select  id + f001()  sq_sum from  (select  generate_series(1, 5) id) b where b.id = a.id) sq_sum
from a
where 1 = 1 and sq_sum = 6 ;

 sn | id | sq_sum 
----+----+--------
  1 |  5 |      6
  2 |  5 |      6
  3 |  5 |      6
(3 行记录)

时间：6007.526 ms (00:06.008)
                                                         QUERY PLAN                                                         
----------------------------------------------------------------------------------------------------------------------------
 Nested Loop  (cost=0.00..3.43 rows=3 width=12) (actual time=4004.455..6006.681 rows=3 loops=1)
   ->  Subquery Scan on "SYSINTERNAL-4-1"  (cost=0.00..2.27 rows=1 width=4) (actual time=3003.273..3003.289 rows=1 loops=1)
         Filter: ((SubPlan 2) = 6)
         Rows Removed by Filter: 5
         ->  ProjectSet  (cost=0.00..0.05 rows=6 width=4) (actual time=0.001..0.005 rows=6 loops=1)
               ->  Result  (cost=0.00..0.01 rows=1 width=0) (actual time=0.000..0.001 rows=1 loops=1)
         SubPlan 2
           ->  Subquery Scan on b_1  (cost=0.00..0.36 rows=1 width=4) (actual time=500.541..500.544 rows=0 loops=6)
                 Filter: (b_1.id = "SYSINTERNAL-4-1".id)
                 Rows Removed by Filter: 4
                 ->  ProjectSet  (cost=0.00..0.04 rows=5 width=4) (actual time=0.001..0.003 rows=5 loops=6)
                       ->  Result  (cost=0.00..0.01 rows=1 width=0) (actual time=0.000..0.001 rows=1 loops=6)
   ->  ProjectSet  (cost=0.00..0.03 rows=3 width=4) (actual time=0.002..0.006 rows=3 loops=1)
         ->  Result  (cost=0.00..0.01 rows=1 width=0) (actual time=0.000..0.001 rows=1 loops=1)
   SubPlan 1
     ->  Subquery Scan on b  (cost=0.00..0.36 rows=1 width=4) (actual time=1001.116..1001.122 rows=1 loops=3)
           Filter: (b.id = "SYSINTERNAL-4-1".id)
           Rows Removed by Filter: 4
           ->  ProjectSet  (cost=0.00..0.04 rows=5 width=4) (actual time=0.001..0.006 rows=5 loops=3)
                 ->  Result  (cost=0.00..0.01 rows=1 width=0) (actual time=0.000..0.001 rows=1 loops=3)
 Planning Time: 0.121 ms
 Execution Time: 6006.709 ms
(22 行记录)

时间：6007.303 ms (00:06.007)

2、CTE

explain analyse
with a as (select sn, id from (select generate_series(1, 3) sn), (select generate_series(3, 8) id)),
     b as (select id, id + f001() sq_sum from generate_series(1, 5) id)
select a.*, (select sq_sum from b where b.id = a.id) sq_sum
from a
where 1 = 1  and sq_sum = 6 ;

                                                          QUERY PLAN                                                           
-------------------------------------------------------------------------------------------------------------------------------
 Nested Loop  (cost=1.31..2.54 rows=3 width=12) (actual time=5005.414..5005.422 rows=3 loops=1)
   CTE b
     ->  Function Scan on generate_series id  (cost=0.00..1.31 rows=5 width=8) (actual time=1001.093..5005.376 rows=5 loops=1)
   ->  Subquery Scan on "SYSINTERNAL-4-1"  (cost=0.00..0.80 rows=1 width=4) (actual time=5005.406..5005.410 rows=1 loops=1)
         Filter: ((SubPlan 3) = 6)
         Rows Removed by Filter: 5
         ->  ProjectSet  (cost=0.00..0.05 rows=6 width=4) (actual time=0.002..0.005 rows=6 loops=1)
               ->  Result  (cost=0.00..0.01 rows=1 width=0) (actual time=0.000..0.001 rows=1 loops=1)
         SubPlan 3
           ->  CTE Scan on b b_1  (cost=0.00..0.11 rows=1 width=4) (actual time=500.540..834.232 rows=0 loops=6)
                 Filter: (id = "SYSINTERNAL-4-1".id)
                 Rows Removed by Filter: 4
   ->  ProjectSet  (cost=0.00..0.03 rows=3 width=4) (actual time=0.002..0.003 rows=3 loops=1)
         ->  Result  (cost=0.00..0.01 rows=1 width=0) (actual time=0.000..0.000 rows=1 loops=1)
   SubPlan 2
     ->  CTE Scan on b  (cost=0.00..0.11 rows=1 width=4) (actual time=0.001..0.001 rows=1 loops=3)
           Filter: (id = "SYSINTERNAL-4-1".id)
           Rows Removed by Filter: 4
 Planning Time: 0.143 ms
 Execution Time: 5005.449 ms
(20 行记录)

时间：5006.115 ms (00:05.006)

3、LEFT JOIN

explain analyse
with a as (select sn, id from (select generate_series(1, 3) sn), (select generate_series(3, 8) id))
select a.*, b.sq_sum
from a  left  join (select id, id + f001() sq_sum  from generate_series(1, 5) id) b on b.id = a.id
where 1 = 1 and sq_sum = 6 ;

                                                                  QUERY PLAN                                                                   
-----------------------------------------------------------------------------------------------------------------------------------------------
 Nested Loop  (cost=1.39..1.62 rows=3 width=12) (actual time=5005.285..5005.291 rows=3 loops=1)
   ->  Hash Join  (cost=1.39..1.53 rows=1 width=8) (actual time=5005.281..5005.285 rows=1 loops=1)
         Hash Cond: ((generate_series(3, 8)) = b.id)
         ->  ProjectSet  (cost=0.00..0.05 rows=6 width=4) (actual time=0.002..0.005 rows=6 loops=1)
               ->  Result  (cost=0.00..0.01 rows=1 width=0) (actual time=0.001..0.001 rows=1 loops=1)
         ->  Hash  (cost=1.38..1.38 rows=1 width=8) (actual time=5005.270..5005.270 rows=1 loops=1)
               Buckets: 1024  Batches: 1  Memory Usage: 9kB
               ->  Subquery Scan on b  (cost=0.00..1.38 rows=1 width=8) (actual time=5005.264..5005.266 rows=1 loops=1)
                     Filter: (b.sq_sum = 6)
                     Rows Removed by Filter: 4
                     ->  Function Scan on generate_series id  (cost=0.00..1.31 rows=5 width=8) (actual time=1001.089..5005.254 rows=5 loops=1)
   ->  ProjectSet  (cost=0.00..0.03 rows=3 width=4) (actual time=0.002..0.003 rows=3 loops=1)
         ->  Result  (cost=0.00..0.01 rows=1 width=0) (actual time=0.000..0.001 rows=1 loops=1)
 Planning Time: 0.113 ms
 Execution Time: 5005.320 ms
(15 行记录)

时间：5005.873 ms (00:05.006)

4、LATERAL 连接 CTE

explain analyse
with a as (select sn, id from (select generate_series(1, 3) sn), (select generate_series(3, 8) id)),
     b as (select id, id + f001() sq_sum from generate_series(1, 5) id)
select a.*, b.sq_sum
from a join lateral (select * from b where b.id = a.id ) b on true
where 1 = 1  and sq_sum = 6;
                                                          QUERY PLAN                                                           
-------------------------------------------------------------------------------------------------------------------------------
 Nested Loop  (cost=1.44..1.67 rows=3 width=12) (actual time=5005.492..5005.499 rows=3 loops=1)
   CTE b
     ->  Function Scan on generate_series id  (cost=0.00..1.31 rows=5 width=8) (actual time=1001.103..5005.440 rows=5 loops=1)
   ->  Hash Join  (cost=0.12..0.27 rows=1 width=8) (actual time=5005.485..5005.489 rows=1 loops=1)
         Hash Cond: ((generate_series(3, 8)) = b.id)
         ->  ProjectSet  (cost=0.00..0.05 rows=6 width=4) (actual time=0.002..0.006 rows=6 loops=1)
               ->  Result  (cost=0.00..0.01 rows=1 width=0) (actual time=0.000..0.001 rows=1 loops=1)
         ->  Hash  (cost=0.11..0.11 rows=1 width=8) (actual time=5005.472..5005.472 rows=1 loops=1)
               Buckets: 1024  Batches: 1  Memory Usage: 9kB
               ->  CTE Scan on b  (cost=0.00..0.11 rows=1 width=8) (actual time=5005.457..5005.459 rows=1 loops=1)
                     Filter: (sq_sum = 6)
                     Rows Removed by Filter: 4
   ->  ProjectSet  (cost=0.00..0.03 rows=3 width=4) (actual time=0.004..0.005 rows=3 loops=1)
         ->  Result  (cost=0.00..0.01 rows=1 width=0) (actual time=0.001..0.001 rows=1 loops=1)
 Planning Time: 0.205 ms
 Execution Time: 5005.531 ms
(16 行记录)

时间：5006.765 ms (00:05.007)

5、LATERAL 连接子查询

explain analyse
with a as (select sn, id from (select generate_series(1, 3) sn), (select generate_series(3, 8) id))
select a.*, b.sq_sum
from a left join lateral (select id, id + f001() sq_sum  from generate_series(1, 5) id where id = a.id ) b on true
where 1 = 1 and sq_sum = 6 ;
  
                                                              QUERY PLAN                                                               
---------------------------------------------------------------------------------------------------------------------------------------
 Nested Loop  (cost=0.00..2.44 rows=18 width=12) (actual time=3003.267..3003.280 rows=3 loops=1)
   ->  Nested Loop  (cost=0.00..2.15 rows=6 width=8) (actual time=3003.257..3003.268 rows=1 loops=1)
         ->  ProjectSet  (cost=0.00..0.05 rows=6 width=4) (actual time=0.002..0.007 rows=6 loops=1)
               ->  Result  (cost=0.00..0.01 rows=1 width=0) (actual time=0.000..0.002 rows=1 loops=1)
         ->  Subquery Scan on b  (cost=0.00..0.33 rows=1 width=4) (actual time=500.541..500.542 rows=0 loops=6)
               Filter: (b.sq_sum = 6)
               Rows Removed by Filter: 0
               ->  Function Scan on generate_series id  (cost=0.00..0.32 rows=1 width=8) (actual time=500.539..500.540 rows=0 loops=6)
                     Filter: (id = (generate_series(3, 8)))
                     Rows Removed by Filter: 4
   ->  Materialize  (cost=0.00..0.08 rows=3 width=4) (actual time=0.007..0.009 rows=3 loops=1)
         ->  ProjectSet  (cost=0.00..0.03 rows=3 width=4) (actual time=0.005..0.006 rows=3 loops=1)
               ->  Result  (cost=0.00..0.01 rows=1 width=0) (actual time=0.001..0.002 rows=1 loops=1)
 Planning Time: 0.125 ms
 Execution Time: 3003.306 ms
(15 行记录)

时间：3003.950 ms (00:03.004)

总结

  • Select 子句中，表达式会逐行运算，总时长与结果集成正比。
  • CTE子句，先计算全部结果，然后关联主表，总时长是可控。
  • 使用子查询和 LATERAL 连接，可以避免结果集的重复计算。
Kingbase 研究院
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SQL SERVER 的SQL语句优化方式小结
09-11
SQL SERVER的SQL语句优化是数据库管理中的关键环节，它直接影响到系统的性能和资源利用率。以下是一些关于SQL SERVER 2005中SQL语句优化的重要知识点： 1. **SQL Server Profiler**：这是一个强大的工具，用于跟踪...
tencentyun#qcloud-documents#数据库调用分析1
07-25
SQL 监控列表该页面左侧 SQL 列表为您展示了所选时间范围内对应应用和数据库之间所有 SQL 调用，同时展示了每个 SQL 的调用次数、耗时、错误率以及昨日
SQL尽量合并成一个，减少查询次数
y41992910的博客
05-12 260
在某些业务场景中，需要先查询a数据，根据数据是否满足条件，再用a去查b，b去查c。 这样就会有多次查询要执行。 可以考虑大部分都是满足的场景中，直接联合查询，一次查出ABC数据，然后进行判断。 ...
mysql 150万记录查询_mysql 查询语句查询时间过长(加了索引还是需要10s左右),数据量大概在150w左右,如何深度优化sql使查询时间再缩短点...
weixin_34570507的博客
01-19 294
问题描述mysql查询时间过长问题出现的环境背景及自己尝试过哪些方法加过数据表的索引后,时间缩短了很多,但任然不是很理想相关代码SELECTcount(DISTINCT (auo.user_wxopenid)) AS countPeople,count(DISTINCT(auo.session_id)) AS countFROManalysis_user_operation auoLEFT JOI...
执行计划中的NestLoop对比HashJoin对比
最新发布
lyu1026的博客
04-03 527
执行计划中的nestloop join 对比hash join 两种join 方式的定义 NESTE LOOP: 在嵌套循环中，内表被外表驱动，外表返回的每一行都要在内表中检索找到与它匹配的行。两个概念：驱动表(外部表)和内部表，这里用表这个次其实不是很准确，外部表和内部表可以是某张表的结果集。 在执行计划中如何区分外部表和内部表。我的通常习惯是安装前后顺序，nestloop join 里面位于...
提高数据查询速度，减少查询次数，确实可以加快响应时间
热门推荐
Ghjkku的博客
03-20 13万+
当数据量不是特别大时，通过减少sql查询次数，确实可以加快响应时间 ！！ 这个优化法则归纳为5个层次： 1、减少数据访问（减少磁盘访问） 2、返回更少数据（减少网络传输或磁盘访问） 3、减少交互次数（减少网络传输） 4、减少服务器CPU开销（减少CPU及内存开销） 5、利用更多资源（增加资源） 优化法则 性能提升效果 优化成本 减少数据访问 1~1000 ...
减少查询次数。
weixin_30278311的博客
09-23 274
转载于:https://www.cnblogs.com/yangzihong/p/11573242.html
优化Sql语句，避免查询慢
KevinChen2019的博客
01-07 702
前言 在面试过程中，经常会被问到，如果sql语句执行耗时过长，该如何优化sql，提高查询效率，在此我根据自己的实际经验，做如下总结。 一、EXPLAIN分析SQL语句 sql优化经常用到EXPLAIN来查看sql语句的执行计划，以下5点是我们重点关注的地方 EXPLAIN执行sql语句以后显示的执行计划 1、type列 通过type字段，我们可以判断出此次查询是全表扫描还是索引扫描，一个好的sql语句至少达到range级别，避免出现all级别（全表扫描）。 ​ type列常用取值如下： system：
sql查询优化 查询优化
09-02
优化查询以尽可能利用索引，减少全表扫描的次数。 7. 分析查询执行计划： 大多数数据库系统提供了查询执行计划分析工具，可以帮助识别查询中的瓶颈，从而指导优化工作。 8. 减少数据冗余和保持数据一致性： 数据...
bigtable-sql基本使用1
08-08
9. **脚本化**：客户端主要用于测试和验证SQL，最终应将脚本固定并由ETL或后台脚本调用执行。 10. **分页问题**：对于Spark-SQL，预览内容可能不支持分页，可能导致内存溢出，因此建议避免在客户端执行大表的预览...
mybatis 插件: 打印 sql 及其执行时间实现方法
08-30
这个插件可以帮助开发者 debug 和优化 SQL 语句的执行速度，提高应用程序的性能。 MyBatis 的插件机制提供了极大的灵活性，允许开发者自定义实现各种逻辑，例如日志记录、性能监控、安全检查等等。
sql查询速度飞速提升技巧一 ：sql中减少to_timestemp的使用
赏樱看雪撸代码
08-06 361
一般来说数据查询优化是针对批量数据查询，尤其是有关时间段的历史数据之类的。 今天我就教一个小妙招：通过在java中转化成timestamp类型，不要在sql中通过下面的方式来转化，因为在sql执行的时候，会自动把时间字符串转换成时间戳，这个也是需要一些时间的，尤其是在大数据量体现的更加明显，至少页面能够提升2-3秒的速度。如下图所示原先低效率的用法。 有关解决方法，就是在入参进行一个控制，针对s...
一条sql执行过长时间,如何优化?
ddwangbin520的博客
05-26 910
优化查询语句：使用更优化的查询语句，例如：使用JOIN代替子查询，避免使用 DISTINCT ，OR 等不必要的查询语句。 避免使用SELECT *：尽量避免使用SELECT *语句，因为这会查询所有列，包括不必要的列，而且会消耗更多的系统资源。 索引优化：确保表中的字段都有适当的索引，特别是在WHERE、ORDER BY、GROUP BY子句中使用的字段。多表联查时，join on 上的字段添加索引。但要避免过多的索引，因为过多的索引会降低写操作的性能 分页查询：将查询结果分页返回，每次只查
mysql 性能优化，减轻数据库的压力。（减少数据库查询的次数）
行走天下
09-09 1653
查询订单相应的user_id的详细 $arr = array( 1=>array( 'user_id' => 5, 'good_id' => '361' ), 2=>array( 'user_id' => 63, ...
生产环境sql优化记录:大表join性能优化
weixin_41645232的博客
02-14 232
sql优化
如何进行SQL优化
weixin_41422086的博客
07-25 801
在应用的的开发过程中，由于初期数据量小，开发人员写 SQL 语句时更重视功能上的实现，但是当应用系统正式上线后，随着生产数据量的急剧增长，很多 SQL 语句开始逐渐显露出性能问题，对生产的影响也越来越大，此时这些有问题的 SQL 语句就成为整个系统性能的瓶颈，因此我们必须要对它们进行优化。因为InnoDB类型的表是按照主键的顺序保存的，所以将导入的数据按照主键的顺序排列，可以有效的提高导入数据的效率。通过分析每个阶段的时间和资源消耗，可以找到查询中的性能瓶颈，并采取相应的措施来提高查询性能。
查询SQL耗时
sujingnuli
09-22 273
查询sql耗时
sql server 查询耗时
blueskywyf's blog
03-03 1059
declare @time1 datetime declare @time2 datetime set @time1=getdate() --your sql sentence set @time2=getdate() select @time2- @time1 as '用时'
数据量大时慢SQL的优化
Knightppppp的博客
01-13 1209
数据量大时慢SQL的优化
android studio如何调用sql数据库
12-22
在Android Studio中调用SQL数据库可以通过以下步骤实现： 1. 配置依赖项：在项目的build.gradle文件中添加以下依赖项： ```groovy implementation 'com.android.volley:volley:1.2.0' implementation '...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值