join方法介绍

最新推荐文章于 2022-01-13 21:18:10 发布
最新推荐文章于 2022-01-13 21:18:10 发布
阅读量158 收藏
点赞数
文章标签： 运维 数据结构与算法 大数据

NESTED LOOP

nested loop：先从驱动表中i/o一条记录，根据这条记录去扫描被驱动表，查找满足join条件的记录，以此循环(所以nested loop对驱动表的每一条记录执行一次I\O，对被驱动表执行最大I\O，数据库的最大I\O由参数db_file_multiblock_read_count决定)

如：

SQL>  select * from employees e join departments d on e.department_id=d.department_id;

  

  分析如上执行计划可知：该join执行nested loops，由employees表作为驱动表，departments表作为被驱动表        

nested loop中哪张表作为驱动表，哪张表作为被驱动表是由优化器来决定的，而不是由select * from employees e join departments d on e.department_id=d.department_id中是employees e join departments d还是departments d join employees e来决定的

如何决定哪张表作为驱动表：一般来说，尽量用小表作为驱动表，但是，当其中一张表有索引时，则用有索引的哪张表作为被驱动表（上面的例子就是因为departments表有索引，所以用其作为被驱动表）

nested loop一般适用于小表连接，并且有索引的情况
嵌套循环原理

 

嵌套循环Nest Loop Join是一种古老的连接方式。SQL中的连接，本质上就是将两个数据集合依据连接条件进行匹配操作。Nest Loop Join就是通过两层循环手段进行依次的匹配操作，最后返回结果集合。SQL语句只是描述出希望连接的对象和规则，而执行计划和执行操作要切实将一行行的记录进行匹配。

 

 

Nest Loop Join的操作过程很简单，很像我们最简单的排序检索算法，两层循环结构。进行连接的两个数据集合（数据表）分别称为驱动表和被驱动表。首先处理驱动表中每一行符合条件的数据，之后每一行数据和被驱动表进行连接匹配操作。最后可以获取到结果集合。

 

 

具体来说，Nest Loop Join的执行过程如下：

 

ü       Oracle CBO首先将一系列的连接关系，拆分为若干层的Nest Loop Join，确定连接顺序。如a.field1=b.field1 and b.field2=c.field2，就可以组织成表A和表B先进行nest loop join操作，之后操作的结果集合再与数据表C进行nest loop join操作。所以，我们查看到的连接操作，通常都是分层次的；

ü       在确定每次Nest Loop Join的两端对象之后，确定驱动表和被驱动表。根据SQL中对驱动表的连接条件，进行筛选。最后获取到驱动表数据集合；

ü       从驱动表每条记录入手，检索被驱动表记录，获取符合连接条件的记录。形成连接行；

 

 

注意：此处有两个需要注意的问题。其一是驱动表的确定。另一个就是检索被驱动表的方法。这两个问题在CBO时代的回答都是成本问题，Oracle通过成本试算获取到。对Nest Loop Join而言，条件列、连接列上的索引是会很大程度上影响执行计划的。

 

下面是一个SQL语句的执行计划，由于CBO操作的复杂性，本SQL使用hint来进行强制的Nest Loop路径。

 

 

SQL> create table tabs as select * from dba_tables;

Table created

 

SQL> create table cols as select owner,table_name, column_name, data_type from dba_tab_cols;

Table created

 

SQL> create index idx_tabs_owner on tabs(owner);

Index created

 

SQL> create index idx_cols_name on cols(table_name);

Index created

 

SQL> set linesize 10000;

SQL> set pagesize 1000;

SQL> explain plan for select /*+use_nl(tabs,cols) */* from tabs, cols where tabs.table_name=cols.tab

le_name and tabs.owner='SCOTT';

 

已解释。

 

SQL> select * from table(dbms_xplan.display);

PLAN_TABLE_OUTPUT

----------------------------------------------------------------------------------------------------

Plan hash value: 2834620917

------------------------------------------------------------------------------------------------

| Id | Operation                    | Name          | Rows | Bytes | Cost (%CPU)| Time    |

------------------------------------------------------------------------------------------------

|  0 | SELECT STATEMENT             |               | 1355 |  381K|  360  (0)| 00:00:05 |

|  1 | NESTED LOOPS                |               |      |      |           |         |

|  2 |  NESTED LOOPS               |               | 1355 |  381K|  360  (0)| 00:00:05 |

|  3 |   TABLE ACCESS BY INDEX ROWID| TABS          |  117 | 28314 |    9  (0)| 00:00:01 |

|* 4 |    INDEX RANGE SCAN         | IDX_TABS_OWNER |  117 |      |    1  (0)| 00:00:01 |

|* 5 |   INDEX RANGE SCAN          | IDX_COLS_NAME |   12 |      |    2  (0)| 00:00:01 |

|  6 |  TABLE ACCESS BY INDEX ROWID | COLS          |   12 |  552 |    3  (0)| 00:00:01 |

------------------------------------------------------------------------------------------------

 

Predicate Information (identified by operation id):

---------------------------------------------------

 

  4 - access("TABS"."OWNER"='SCOTT')

  5 - access("TABS"."TABLE_NAME"="COLS"."TABLE_NAME")

 

已选择19行。

 

 

在执行计划中，伴随着两个Nest Loop Join。首先，通过条件owner=’SCOTT’，检索索引idx_tabs_owner，获取符合条件的rowid列表。之后利用rowid从tabs表中取出结果集合。这个集合就成为第一层Nest Loop Join的驱动表。

 

被驱动表则是COLS数据表对应的索引IDX_COLS_NAME，进行匹配的条件是table_name相等。第一层Nest Loop Join的结果集合是TABS所有符合条件行字段，外加上对应COLS数据表的rowid。

 

第二层Nest Loop Join就是通过获取到的COLS rowid找到COLS记录的全部内容。

 

 

2、Nest Loop Join检索图示

 

下面通过一张示意，表达在没有连接列索引的情况下，Nest Loop Join的工作方式。

 

17203031_201106012225521.jpg

 

在没有索引的情况下，首先Oracle会检索驱动表（全表扫描），获取到符合外侧表单独条件的记录行集合（Row1和Row2）。

 

之后针对row1和row2，分别对inner表进行全表匹配查询，就是对每个outer的结果行，要进行inner表的所有块查询。最后发现符合条件的row3和row4，将结果返回。

 

 

通过图示，我们也可以发现Nest Loop Join的一个致命缺陷：存在大量的随机读。为每一个驱动表的记录，就需要进行被驱动表的全表扫描。如果被驱动表很庞大，那么这个执行计划效率可想而知。

 

 

3、索引优化与Nest Loop Join

 

在目前的Oracle执行计划中，如果驱动表和被驱动表均没有索引等优化方式，而且不包含那些很复杂的连接对应条件，出现Nest Loop Join的机会还是很低的。因为Oracle CBO会选择其他替代执行计划（如Hash Join）来参与执行计划。

 

在条件列，特别是连接条件列上添加索引，可以大幅度的减少Nest Loop Join的随机读。见下图示意：

 

17203031_201106012226221.jpg

 

如果在被驱动表的连接条件列上添加索引，在进行Nest Loop Join的时候，Row1/Row2可以直接确定符合连接条件的被驱动表数据行对应的rowid。不需要直接对被驱动表进行检索，就可以获取到rowid了。由于索引对应的体积要远远小于被驱动表，所以进行的块读取要少很多。

 

 

结论：如果确定需要使用嵌套循环Nest Loop Join，那么最好考虑保证连接列上能存在索引对象。这样可以很大程度上提高Nest Loop Join的连接效率。

 

可以使用USE_NL(table_name1 table_name2)可是强制CBO 执行嵌套循环连接。


 

HASH JOIN

hash join是优化器做大数据集连接时的常用方式。优化器扫描小表（或数据源），利用连接键（也就是根据连接字段计算hash 值）在内存中建立hash表，然后扫描大表，每读到一条记录就来探测hash表一次，找出与hash表匹配的行。

Hash Join（哈希连接）原理

 

只有CBO才能使用Hash Join操作。本质上说，Hash Join连接是借助Hash算法，连带小规模的Nest Loop Join，同时利用内存空间进行高速数据缓存检索的一种算法。

 

下面我们分步骤介绍Hash Join算法步骤：

 

  i.       Hash Join连接对象依然是两个数据表，首先选择出其中一个“小表”。这里的小表，就是参与连接操作的数据集合数据量小。对连接列字段的所有数据值，进行Hash函数操作。Hash函数是计算机科学中经常使用到的一种处理函数，利用Hash值的快速搜索算法已经被认为是成熟的检索手段。Hash函数处理过的数据特征是“相同数据值的Hash函数值一定相同，不同数据值的Hash函数值可能相同”；

 ii.       经过Hash处理过的小表连接列，连同数据一起存放到Oracle PGA空间中。PGA中存在一块空间为hash_area，专门存放此类数据。并且，依据不同的Hash函数值，进行划分Bucket操作。每个Bucket中包括所有相同hash函数值的小表数据。同时建立Hash键值对应位图。

iii.       之后对进行Hash连接大表数据连接列依次读取，并且将每个Hash值进行Bucket匹配，定位到适当的Bucket上（应用Hash检索算法）；

iv.       在定位到的Bucket中，进行小规模的精确匹配。因为此时的范围已经缩小，进行匹配的成功率精确度高。同时，匹配操作是在内存中进行，速度较Merge Sort Join时要快很多；

 

下面是一个Hash Join的执行计划。

 

 

PLAN_TABLE_OUTPUT

--------------------------------------------------------------------------------

Plan hash value: 779051904

----------------------------------------------------------------------------

| Id | Operation         | Name | Rows | Bytes | Cost (%CPU)| Time    |

----------------------------------------------------------------------------

|  0 | SELECT STATEMENT  |      | 2617 |  572K|  142  (1)| 00:00:02 |

|* 1 | HASH JOIN        |      | 2617 |  572K|  142  (1)| 00:00:02 |

|  2 |  TABLE ACCESS FULL| SEGS | 2503 |  312K|   16  (0)| 00:00:01 |

|  3 |  TABLE ACCESS FULL| OBJTS | 31083 | 2914K|  126  (1)| 00:00:02 |

----------------------------------------------------------------------------

Predicate Information (identified by operation id):

---------------------------------------------------

  1 - access("SEGS"."SEGMENT_NAME"="OBJTS"."OBJECT_NAME")

 

 

从原理过程来看，Hash Join与Nest Loop Join/Merge Sort Join存在一定相似度。

 

首先，Hash Join同Nest Loop Join一样，进行一定的嵌套循环匹配操作，不过差异在于匹配进行随机读的范围是受限范围。不会像Nest Loop Join一样直接频繁进行全表规模的随机读。

 

其次，Hash Join同之前介绍过的Merge Sort Join有相似点，都是利用PGA的空间进行独立操作。Hash Join中的Bucket就是保存在内存的PGA中，有一块专门Hash_Area进行该项操作。选择小表作为驱动连接表，就是尽量争取PGA内存中可以完全装下小表数据，尽量不要使用Temp表空间（当小表可以全部放入内存中，其成本接近全表扫描两个表的成本之和。如果表很大不能完全放入内存，这时优化器会将它分割成若干不同的分区，不能放入内存的部分就把该分区写入磁盘的临时段，此时要有较大的临时段从而尽量提高I/O 的性能。临时段中的分区都需要换进内存做hash join。这时候成本接近于全表扫描小表+分区数*全表扫描大表的代价和。）。这样，进行Hash匹配和精确匹配的速度就是有保证的。

 

 

最后，Hash Join使用的场景是有限制的。其中最大的一个就是连接操作仅能使用“=”连接。因为Hash匹配的过程只能支持相等操作。还有就是连接列的数据分布要尽量做到数据分布均匀，这样产生的Bucket也会尽可能均匀。这样限制匹配的速度才有保证。如果数据列分布偏移严重，Hash Join算法效率会有退化趋势。

使用hash join时，HASH_AREA_SIZE初始化参数必须足够的大，如果是9i及以上版本，Oracle建议使用SQL工作区自动管理，设置WORKAREA_SIZE_POLICY 为AUTO，然后调整PGA_AGGREGATE_TARGET即可 。

以下条件下hash join可能有优势：

两个巨大的表之间的连接。

在一个巨大的表和一个小表之间的连接。

SORT MERGE JOIN

sort merge join的操作通常分三步：对连接的每个表做table access full；对table access full的结果进行排序；进行merge join对排序结果进行合并。sort merge join性能开销几乎都在前两步。一般是在没有索引的情况下，9i开始已经很少出现了，因为其排序成本高，大多为hash join替代了。

通常情况下hash join的效果都比sort merge join要好，然而如果行源已经被排过序，在执行sort merge join时不需要再排序了，这时sort merge join的性能会优于hash join。

在全表扫描比索引范围扫描再通过rowid进行表访问更可取的情况下，sort merge join会比nested loops性能更佳。

 

可以用USE_HASH(table_name1 table_name2)提示来强制使用散列连接。

Merge Sort Join原理机制

 

Nest Loop Join嵌套循环是一种比较古老的连接匹配方式，特点是通过两层的循环结构，将符合条件的数据行整理出来。嵌套循环的最大缺陷之一，就是伴随着驱动表被驱动表之间的选择，以及大量随机读现象。

 

 

Merge Sort Join连接的优势就是可以一定程度上减少随机读的情况。合并排序连接的最大特征是在一次扫描的同时，就判断连接。不会像Nest Loop Join那样频繁的进行数据读取。使用这种方式的前提，就是连接的两个数据集合必须按照连接列的顺序进行排序。具体操作流程如下：

 

ü       对Merge Sort Join连接而言，不存在驱动表和被驱动表的问题。两边的数据集合没有顺序区别，都要进行排序操作；

ü       根据Oracle排序规则和方法，按照连接列的顺序对两个数据集合进行排序；

ü       依次对两边的数据集合进行扫描，由于已经是排序过得结果，可以直接确定连接条件是否匹配；

ü       确定进行连接的两端数据行，再依据筛选列的要求获取数据；

 

下面是一个进行Merge Sort Join的执行计划：

 

//使用Merge Sort Join方法

SQL>select /*+use_merge(segs,tabs)*/* from segs, tabs where segs.segment_name=tabs.table_name;

已选择865行。

 

执行计划

----------------------------------------------------------

Plan hash value: 3475644097

 

------------------------------------------------------------------------------------

| Id | Operation          | Name | Rows | Bytes |TempSpc| Cost (%CPU)| Time    |

------------------------------------------------------------------------------------

|  0 | SELECT STATEMENT   |     |  990 |  354K|      |  144  (2)| 00:00:02 |

|  1 | MERGE JOIN        |     |  990 |  354K|      |  144  (2)| 00:00:02 |

|  2 |  SORT JOIN        |     |  968 |  229K|  712K|   65  (2)| 00:00:01 |

|  3 |   TABLE ACCESS FULL| TABS |  968 |  229K|      |   11  (0)| 00:00:01 |

|* 4 |  SORT JOIN        |     | 2267 |  274K|  824K|   79  (2)| 00:00:01 |

|  5 |   TABLE ACCESS FULL| SEGS | 2267 |  274K|      |   13  (0)| 00:00:01 |

------------------------------------------------------------------------------------

Predicate Information (identified by operation id):

---------------------------------------------------

  4 - access("SEGS"."SEGMENT_NAME"="TABS"."TABLE_NAME")

      filter("SEGS"."SEGMENT_NAME"="TABS"."TABLE_NAME")

统计信息

----------------------------------------------------------

      2010 recursive calls

         0 db block gets

       378 consistent gets

         0 physical reads

         0 redo size

     72346 bytes sent via SQL*Net to client

      1003 bytes received via SQL*Net from client

        59 SQL*Net roundtrips to/from client

        10 sorts (memory)

         0 sorts (disk)

       865 rows processed

 

//使用嵌套循环；

SQL>select /*+use_nl(segs,tabs)*/* from segs, tabs where segs.segment_name=tabs.table_name;

已选择865行。

执行计划

----------------------------------------------------------

Plan hash value: 840690564

---------------------------------------------------------------------------

| Id | Operation         | Name | Rows | Bytes | Cost (%CPU)| Time    |

---------------------------------------------------------------------------

|  0 | SELECT STATEMENT  |     |  990 |  354K| 11075  (1)| 00:02:13 |

|  1 | NESTED LOOPS     |     |  990 |  354K| 11075  (1)| 00:02:13 |

|  2 |  TABLE ACCESS FULL| TABS |  968 |  229K|   11  (0)| 00:00:01 |

|* 3 |  TABLE ACCESS FULL| SEGS |    1 |  124 |   11  (0)| 00:00:01 |

---------------------------------------------------------------------------

Predicate Information (identified by operation id):

---------------------------------------------------

  3 - filter("SEGS"."SEGMENT_NAME"="TABS"."TABLE_NAME")

统计信息

----------------------------------------------------------

      1930 recursive calls

         0 db block gets

     43978 consistent gets

         0 physical reads

         0 redo size

     70556 bytes sent via SQL*Net to client

      1003 bytes received via SQL*Net from client

        59 SQL*Net roundtrips to/from client

         6 sorts (memory)

         0 sorts (disk)

       865 rows processed

 

 

上面代码示例中给出了两个执行计划，给我们如下的信息。

 

首先，我们观察使用use_merge提示的SQL，在Hint的作用下，CBO生成的执行计划中使用Merge Sort Join连接方式。在执行计划中Oracle对两个数据表进行Sort操作，之后对排序过的结果进行Merge连接。其中Oracle对两个数据表进行的都是全表扫描操作。

 

 

另一个执行计划是使用use_nl控制的Nest Loop Join连接方式。中间同样也是没有使用索引等方式。其中，产生了大量逻辑读。见下表对比：

 

对比项目

Merge Sort Join

NestLoopJoin

逻辑读consistent gets

378

43978

排序空间sort

10

6

 

通过数据信息的对比，我们可以明显的看出两个相同结果集合的SQL，由于不同的连接方式而带来的差异。Merge Sort Join可以大大消除由于Nest Loop Join带来的随机读过多的情况。而由于进行的排序操作，Merge Sort Join也要付出相应的排序空间损耗。

 

2、Merge Sort Join与排序空间

 

对Oracle熟悉的朋友们通常对Sort和Group操作是比较敏感的。Sort和Group by都是需要单独对数据集进行的操作，要消耗额外的CPU和内存资源。CPU资源主要消耗在算法排序和结果集合整合上。而内存资源的消耗更加需要关注，排序操作要在专门的PGA排序区内完成。如果PGA中特定的排序大小（pga_aggregat_target:sort_area_size）不足以进行排序操作，也就是说需要排序分组的数据集合特别大的时候，Oracle需要调用Temp表空间的容量来进行操作。

 

 

这也就是问题的所在。Temp表空间数据存储位于磁盘中，速度与内存相差很多。所以，当进行排序操作的数据集合很大，会出现性能急剧的下降可能。在实际业务场景中，对海量数据集合的处理、Data Warehouse应用的操作，都可能出现这种情况。

 

回到Merge Sort Join来，就可以理解这种连接方式的缺陷之处了。要进行Merge Sort Join，其中的Sort过程不可避免。而使用Sort操作带来的优势就是不需要进行过多的随机读。在数据集合量很大的时候，Merge Sort Join的效率可能会很差。

 

 

3、对索引路径的借用

 

在Nest Loop Join中，对连接列进行索引处理，可以很大程度上提升执行计划效率，减少随机读的数量。道理就是借用了索引排序这个现实。而Merge Sort Join对索引的应用效果远不如Nest Loop Join。

 

索引环境构建：

 

//索引构建

SQL> create index idx_tabs_name on tabs(table_name);

Index created

 

SQL> create index idx_segs_name on segs(segment_name);

Index created

 

SQL> exec dbms_stats.gather_table_stats(user,'SEGS',cascade => true);

PL/SQL procedure successfully completed

 

SQL> exec dbms_stats.gather_table_stats(user,'TABS',cascade => true);

PL/SQL procedure successfully completed

 

 

执行计划如下：

 

 

SQL> explain plan for select/*+use_merge(tabs,segs)*/* from segs,tabs where segs.segment_name=tabs.table_name;

Explained

 

SQL> select * from table(dbms_xplan.display);

PLAN_TABLE_OUTPUT

--------------------------------------------------------------------------------

Plan hash value: 3475644097

--------------------------------------------------------------------------------

| Id | Operation          | Name | Rows | Bytes |TempSpc| Cost (%CPU)| Time

--------------------------------------------------------------------------------

|  0 | SELECT STATEMENT   |     |  990 |  354K|      |  144  (2)| 00:00:

|  1 | MERGE JOIN        |     |  990 |  354K|      |  144  (2)| 00:00:

|  2 |  SORT JOIN        |     |  968 |  229K|  712K|   65  (2)| 00:00:

|  3 |   TABLE ACCESS FULL| TABS |  968 |  229K|      |   11  (0)| 00:00:

|* 4 |  SORT JOIN        |     | 2267 |  274K|  824K|   79  (2)| 00:00:

|  5 |   TABLE ACCESS FULL| SEGS | 2267 |  274K|      |   13  (0)| 00:00:

--------------------------------------------------------------------------------

Predicate Information (identified by operation id):

---------------------------------------------------

  4 - access("SEGS"."SEGMENT_NAME"="TABS"."TABLE_NAME")

      filter("SEGS"."SEGMENT_NAME"="TABS"."TABLE_NAME")

18 rows selected

 

 

由于Merge Sort Join本身就带有排序的特性，而且返回的结果集合中包括所有字段。所以通常的执行计划中，即使连接列存在索引，也不会进入到执行计划中。除非进行一些特定列处理。

 

 

SQL> explain plan for select/*+use_merge(tabs,segs)*/segs.segment_name,tabs.table_namefrom segs,tabs where segs.segment_name=tabs.table_name;

Explained

 

SQL> select * from table(dbms_xplan.display);

PLAN_TABLE_OUTPUT

--------------------------------------------------------------------------------

Plan hash value: 712326860

--------------------------------------------------------------------------------

| Id | Operation             | Name         | Rows | Bytes | Cost (%CPU)| Ti

--------------------------------------------------------------------------------

|  0 | SELECT STATEMENT      |              |  990 | 37620 |    9 (23)| 00

|  1 | MERGE JOIN           |              |  990 | 37620 |    9 (23)| 00

|  2 |  SORT JOIN           |              |  968 | 17424 |    4 (25)| 00

|  3 |   INDEX FAST FULL SCAN| IDX_TABS_NAME |  968 | 17424 |    3  (0)| 00

|* 4 |  SORT JOIN           |              | 2267 | 45340 |    5 (20)| 00

|  5 |   INDEX FAST FULL SCAN| IDX_SEGS_NAME | 2267 | 45340 |    4  (0)| 00

--------------------------------------------------------------------------------

Predicate Information (identified by operation id):

---------------------------------------------------

  4 - access("SEGS"."SEGMENT_NAME"="TABS"."TABLE_NAME")

      filter("SEGS"."SEGMENT_NAME"="TABS"."TABLE_NAME")

18 rows selected

 

 

在对返回结果进行处理的情况下，索引路径会出现的。

 

 

可以使用USE_MERGE(table_name1 table_name2)来强制使用排序合并连接.

 

 

因为要对两个表进行排序，而排序操作是一个非常耗CPU的操作，所以一般不常看到MERGE SORT JOIN，只有在如下情况下才会用到MERGE SORT JOIN：

  1.不等值连接

  2.该语句中本身就有order by等需要执行排序的语句

 

 

4、结论

 

Merge Sort Join是一种古老经典的排序模型，类似于数据结构时代的合并排序算法。Merge Sort Join引入的最大优势是避免同Nest Loop Join类似的大量随机读现象，但是同时也引入了Sort空间变化的问题。

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/24984814/viewspace-708008/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/24984814/viewspace-708008/

ckkuc00228
关注
javascript(js) join函数使用方法介绍
10-30
javascript.join函数使用方法介绍 javascript中的join函数是一个非常有用的函数，用于将数组元素连接成一个字符串。这个函数可以将数组中的元素连接成一个字符串，并且可以指定连接符。 join函数的基本用法 join...
Oracle的Filter,Nest loop,Merge sort join和Hash join(原创)
czmmiao的专栏
02-18 332
 Merge Sort Join按照Merge Sort Join连接的两表地位完全相同。这种算法会把每个表按照连接列进行排序，生成两个排序集。然后对两个排序集进行一次遍历便可以得到最终结果集。这个算法的特点是，每个表都需要排序，排序后都需要遍历一次。 以下面的例子说明，Merge Sort Join的执行过程如下：SQL> explain plan for select /*+ us...
Filter的一个测试
Angelina7的博客
05-07 1116
Filter的一个测试： 创建测试表 t1 和t2. create table t1 as select * from dba_objects where rownum<=5000; create table t2 as select * from dba_objects where rownum<=5000; 执行该测试SQL，这里使用了提示来收集真实的执行计划 select /*+ gat
联系生活来简化sql语句
congbao6525的博客
11-01 119
目前生产环境中有一条sql语句的CPU消耗很高。执行时间比较长。从awr中抓到的sql语句如下： SELECT run_request.run_mode, cycle_groups.flow_id, c...
Join的四种方式(Oracle)
weixin_45283159的博客
01-13 1927
1.查询优化器 执行join 语句 [1]判断join两张表还是多张表 多张表会把有唯一约束或主键的表放在前处理 [2]有outer join条件的语句放后面，子查询已经转化为一张表时在outer join后面 [3]优化器根据 join的顺序,方法,访问路径 会产生很多执行计划，优化器评估每个计划的成本,选择最低的一个,作为最终执行计划 成本评估方法 [1]nested loop join 成本 基于读取外表的每一行 并 和在内存里的内表一一匹配的成本，优化器通过统计信息来评估该成本。 [2]hash j
Jieba分词的使用方法
qq_39207897的博客
05-18 274
Jieba分词的使用方法 来源：chinese-nlp 等我看完整本后，会写一个总结，再把PDF上传的。 import jieba import jieba.posseg as psg from collections import Counter content = "今天下雨了，所以不用去跑步了，真开心！" # 精准分词：将橘子最精确的切开，精确分词也是默认分词 segs_1 = jieba.cut(content, cut_all=False) print("/".join(segs_1)
python中join()方法介绍
01-21
Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。 语法 join()方法语法： str . join ( sequence ) 参数 sequence — 要连接的元素序列。 返回值 返回通过指定字符连接序列中元素后生成的...
tp5.1 框架join方法用法实例分析
10-15
主要介绍了tp5.1 框架join方法用法,结合实例形式分析了tp5.1 框架中join方法的基本功能、原理、用法及操作注意事项,需要的朋友可以参考下
js中的push和join方法使用介绍
10-26
JS中的push和join方法是JavaScript数组操作中的重要函数，分别用于向数组末尾添加元素和将数组中的元素连接成字符串。下面详细介绍这两个方法的使用和一些相关知识点。 首先来看push方法，它是一个数组实例方法，...
小时转换为机器学习特征_通过机器学习将pdf转换为有声读物
weixin_26630173的博客
09-23 406
小时转换为机器学习特征This project was originally designed by Kaz Sato. 该项目最初由 Kaz Sato 设计 。 演示地址I made this post into a video. Check it out! 我将此帖子制作成了视频。 看看这个！ Walking — it’s one of covid-19’s greatest (and on...
Postgres的scan filter 和 join filter 比较
lxyhoh的专栏
07-08 1119
scan filter: 普通的过滤条件，一般来自与where ...; having ...子句中的条件。 join filter: 多表联结的时候，表与表之间联结时候的过滤条件 ，来自于on子语 。需要注意的是：在外连接的时候，是不能过滤行的， 在内连接的的时候与普通的filter没有区别。 看下官方文档怎么说的： When dealing with outer joins, you might see join plan nodes with both “Join Filter”...
PostgreSQL difference between filter and join filter
luojinbai的专栏
03-05 1409
PostgreSQL difference between filter and join filter
数据库表在join时的三种方式
weixin_30809173的博客
08-01 437
sql 执行时最重要的两步： 1）通过什么方式获取到数据(index only scan、index scan、table full scan) 2）获取到数据后用什么方式join出结果。 下面说的是第二步 nested loop 嵌套循环 处理等值连接。 对于被连接的数据子集较小的情况，nested loop连接是个较好的选择。 ...
3 ，过滤 - filter ，连接 - join ，排序 ，查看前 10
孙砚秋的博客
11-15 228
1 ，查看前 10 ： resUserRDD.take(10)
Python学习（二） 利用jieba分词及去停用词
热门推荐
高端客户
07-17 1万+
#encoding=utf-8 import sys sys.path.append("../") import jieba import jieba.posseg as pseg from jieba import analyse #加载停用词表 stop = [line.strip().decode('utf-8') for line in open('stop_words.txt').r
oracle 优化小技巧， filter 与 hash join 连接
daiqiulong2的博客
06-26 1638
最近优化SQL时 发现一个SQL，    select * from t_pro  t where         (select count(1)      from t_cost  ac   where data   = 'GZXT'  and ac.prj_id = t.prj_code) = 0; 我靠 哪位高人写的SQL， 一看就知道存在性能隐患，  一个大坑。
浅谈Oracle中的三种Join方法
thy822的专栏
05-16 5293
基本概念   　　Nested loop join： 　　Outer table中的每一行与inner table中的相应记录join，类似一个嵌套的循环。 　　Sort merge join： 　　将两个表排序，然后再进行join。 　　Hash join： 　　将两个表中较小的一个在内存中构造一个Hash 表（对JoinKey），扫描另一个表，同样对JoinKey进行Hash后探
理解执行计划中的一些sort操作
haiross的专栏
12-09 9680
理解sort操作，其实很简单，核心的就是sort，后面括弧里面说明的是排序的目的是什么？版本：9.2.0.8 当需要排序操作时，通常会有一系列sort的操作，下面是一些cbo执行sort的操作： Sort unique(sort的目的是取出所有的唯一值) Sort aggregate(sort的目的是为了聚合) Sort group by(sort的目的是为了分组) Sort join(
PostgreSQL EXPLAIN执行计划学习--多表连接几种Join方式比较
dimawei2225的博客
06-07 2087
转了一部分。稍后再修改。 三种多表Join的算法： 一．NESTED LOOP: 对于被连接的数据子集较小的情况，嵌套循环连接是个较好的选择。在嵌套循环中，内表被外表驱动，外表返回的每一行都要在内表中检索找到与它匹配的行，因此整个查询返回的结果集不能太大（大于1万不适合），要把返回子集较小表的作为外表（CBO默认外表是驱动表），而且在内表的连接字段上一定要有索引。当然也...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值