ORACLE中關於外來鍵缺少索引的探討和總結

阿新 • • 發佈：2019-02-18

作者：瀟湘隱者
在ORACLE資料庫中，定義外來鍵約束時，ORACLE是不會自動建立對應索引的，必須手動在外來鍵約束相關的列上建立索引。那麼外來鍵欄位上是否有必要建立索引呢？如果有必要的話，巡檢時，如何找出外來鍵欄位上沒有建立索引的相關表，並生成對應的索引的指令碼呢？

外來鍵缺失索引影響

外來鍵列上缺少索引會帶來三個問題，限制併發性、影響效能、還有可能造成死鎖。所以對於絕大部分場景，我們應該儘量考慮在外來鍵上面建立索引

影響效能。如果子表外來鍵沒有建立索引，那麼當父表查詢關聯子表時，子表將進行全表掃描。影響表連線方式。
影響併發。無論是更新父表主鍵，或者刪除一個父記錄，都會在子表中加一個表鎖（在這條語句完成前，不允許對子表做任何修改）。這就會不必要

地鎖定更多的行，而影響併發性

3：在特殊情況下，還有可能造成死鎖。

我們先來看看一個簡單的例子，看看當外來鍵缺失索引時，子表是否進行全表掃描，如下所示，表EMP與DEPT存在主外來鍵關係：

SQL> set autotrace on;
SQL> 
SQL> SELECT  D.DEPTNO, COUNT(*)
  2  FROM SCOTT.EMP E INNER JOIN SCOTT.DEPT D ON E.DEPTNO =D.DEPTNO
  3  GROUP BY D.DEPTNO;

    DEPTNO   COUNT(*)
---------- ----------
        30          6 

        20          5
        10          3


Execution Plan
----------------------------------------------------------
Plan hash value: 4067220884

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

|   0 | SELECT STATEMENT   |      |     3 |     9 |     4  (25)| 00:00:01 |
|   1 |  HASH GROUP BY     |      |     3 |     9 |     4  (25)| 00:00:01 |
|*  2 |   TABLE ACCESS FULL| EMP  |    14 |    42 |     3   (0)| 00:00:01 |
---------------------------------------------------------------------------
Predicate Information (identified by operation id):
---------------------------------------------------
   2 - filter("E"."DEPTNO" IS NOT NULL)


Statistics
----------------------------------------------------------
          1  recursive calls
          0  db block gets
          7  consistent gets
          0  physical reads
          0  redo size
        665  bytes sent via SQL*Net to client
        524  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          0  sorts (memory)
          0  sorts (disk)
          3  rows processed

這裡寫圖片描述
如上所示，當外來鍵欄位沒有索引時，父表與子表關聯時，子表會進行全表掃描，下面，我在外來鍵欄位建立索引後，就能避免子表表掃描了。

CREATE INDEX SCOTT.IX_DEPTNO ON SCOTT.EMP (“DEPTNO”) TABLESPACE USERS;
這裡寫圖片描述
當然這兩個表的資料量實在是太少了，效能上差別不大，當資料量增長上去後，這個效能差異就會比較明顯了。如下例子所示，我們構造一個數據量相對較大的父表與子表：

create table parent_tb_test 
(
    id         number(10),
    name    varchar2(32),
    constraint pk_parent_tb_test primary key(id)
);

create table child_tb_test
(
     c_id   number(10),
     f_id        number(10),
     child_name    varchar2(32),
     constraint pk_child_tb_test primary key(c_id),
     foreign key(f_id) references parent_tb_test
);


begin

for index_num in 1 .. 10000 loop
    insert into parent_tb_test
    select index_num , 'kerry' || to_char(index_num) from dual;

    if mod(index_num,100) = 0 then
        commit;
    end if;
end loop;

     commit;

end;
/

declare index_num number :=1;
begin

    for index_parent  in 1 .. 10000 loop
        for index_child in 1 .. 1000 loop
             insert into child_tb_test
             select index_num, index_parent, 'child' || to_char(index_child) from dual;

             index_num := index_num +1;
             if mod(index_child,1000) = 0 then
                 commit;
             end if;
        end loop;
    end loop;

    commit;
end;
/


SQL> execute dbms_stats.gather_table_stats(ownname => 'TEST', tabname =>'PARENT_TB_TEST', estimate_percent =>DBMS_STATS.AUTO_SAMPLE_SIZE, method_opt => 'FOR ALL COLUMNS SIZE AUTO');

PL/SQL procedure successfully completed.

SQL> execute dbms_stats.gather_table_stats(ownname => 'TEST', tabname =>'CHILD_TB_TEST', estimate_percent =>DBMS_STATS.AUTO_SAMPLE_SIZE, method_opt => 'FOR ALL COLUMNS SIZE AUTO');

PL/SQL procedure successfully completed.

SQL>

上面指令碼構造了測試用的例子和資料，那麼我們對比看看外來鍵有無索引的區別：

SQL> set linesize 1200
SQL> set autotrace traceonly
SQL> select p.id , p.name,c.child_name
  2  from test.parent_tb_test p
  3  inner join test.child_tb_test c on p.id = c.f_id 
  4  where p.id=1000;

1000 rows selected.


Execution Plan
----------------------------------------------------------
Plan hash value: 901213199

--------------------------------------------------------------------------------------------------
| Id  | Operation                    | Name              | Rows  | Bytes | Cost (%CPU)| Time     |
--------------------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT             |                   |  1009 | 44396 |  4706  (21)| 00:00:07 |
|   1 |  NESTED LOOPS                |                   |  1009 | 44396 |  4706  (21)| 00:00:07 |
|   2 |   TABLE ACCESS BY INDEX ROWID| PARENT_TB_TEST    |     1 |    31 |     1   (0)| 00:00:01 |
|*  3 |    INDEX UNIQUE SCAN         | PK_PARENT_TB_TEST |     1 |       |     1   (0)| 00:00:01 |
|*  4 |   TABLE ACCESS FULL          | CHILD_TB_TEST     |  1009 | 13117 |  4705  (21)| 00:00:07 |
--------------------------------------------------------------------------------------------------
Predicate Information (identified by operation id):
---------------------------------------------------
   3 - access("P"."ID"=1000)
   4 - filter("C"."F_ID"=1000)


Statistics
----------------------------------------------------------
          0  recursive calls
          0  db block gets
      32855  consistent gets
      32772  physical reads
          0  redo size
      29668  bytes sent via SQL*Net to client
       1218  bytes received via SQL*Net from client
         68  SQL*Net roundtrips to/from client
          0  sorts (memory)
          0  sorts (disk)
       1000  rows processed

SQL>

這裡寫圖片描述
建立索引後，我們再來看看其執行計劃，注意對比建立索引前後，執行計劃的差異，如下所示：

SQL> create index ix_child_tb_test on child_tb_test(f_id);

SQL> set linesize 1200
SQL> set autotrace traceonly
SQL> select p.id , p.name,c.child_name
  2  from test.parent_tb_test p
  3  inner join test.child_tb_test c on p.id = c.f_id 
  4  where p.id=1000;

這裡寫圖片描述
接下來，我們再來看看外來鍵缺失索引影響併發，以及造成死鎖的情況，如下所示，建立表dead_lock_parent與dead_lock_foreign，兩者存在主外來鍵關係，分佈插入兩條測試資料：

SQL> create table dead_lock_parent( id number primary key, name varchar2(32));

Table created.

SQL> create table dead_lock_foreign(fid  number, fname varchar2(32), foreign key(fid) references dead_lock_parent);

Table created.

SQL> insert into dead_lock_parent values( 1, 'kerry');

1 row created.

SQL> insert into dead_lock_foreign values(1, 'kerry_fk');  

1 row created.

SQL> insert into dead_lock_parent values(2, 'jimmy');

1 row created.

SQL> insert into dead_lock_foreign values(2, 'jimmy_fk');

1 row created.

SQL> commit;

Commit complete.

SQL>

1：在會話1（會話ID為789）裡面執行下面SQL語句：

SQL> show user;
USER 為 "TEST"
SQL> select * from v$mystat where rownum=1;

       SID STATISTIC#      VALUE
---------- ---------- ----------
       789          0          1

SQL> delete from dead_lock_foreign where fid=1;

已刪除 1 行。

2：在會話2（會話ID為766）裡面執行下面SQL語句：

SQL> show user;
USER is "TEST"
SQL> select * from v$mystat where rownum=1;

       SID STATISTIC#      VALUE
---------- ---------- ----------
       766          0          1

SQL> delete from dead_lock_foreign where fid=2;

1 row deleted.

3：接著在會話1（會話ID為789）裡執行刪除dead_lock_parent中id為1的記錄：

SQL> delete from dead_lock_parent where id=1;

此時你會發現會話被阻塞了，我們可以用下面SQL查詢具體的阻塞資訊。

COL MODE_HELD FOR A14;
COL LOCK_TYPE FOR A8;
COL MODE_REQUESTED FOR A10;
COL OBJECT_TYPE FOR A14;
COL OBJECT_NAME FOR A20;
SELECT LK.SID,
       DECODE(LK.TYPE,
              'TX',
              'Transaction',
              'TM',
              'DML',
              'UL',
              'PL/SQL User Lock',
              LK.TYPE) LOCK_TYPE,
       DECODE(LK.LMODE,
              0,
              'None',
              1,
              'Null',
              2,
              'Row-S (SS)',
              3,
              'Row-X (SX)',
              4,
              'Share',
              5,
              'S/Row-X (SSX)',
              6,
              'Exclusive',
              TO_CHAR(LK.LMODE)) MODE_HELD,
       DECODE(LK.REQUEST,
              0,
              'None',
              1,
              'Null',
              2,
              'Row-S (SS)',
              3,
              'Row-X (SX)',
              4,
              'Share',
              5,
              'S/Row-X (SSX)',
              6,
              'Exclusive',
              TO_CHAR(LK.REQUEST)) MODE_REQUESTED, 
       OB.OBJECT_TYPE,
       OB.OBJECT_NAME,
       LK.BLOCK,
       SE.LOCKWAIT
  FROM V$LOCK LK, DBA_OBJECTS OB, V$SESSION SE
 WHERE LK.TYPE IN ('TM', 'UL')
   AND LK.SID = SE.SID
   AND LK.ID1 = OB.OBJECT_ID(+)
 AND SE.SID IN (766,789)
 ORDER BY SID;

這裡寫圖片描述
上面資訊如果不能讓你理解，那麼可以看看下面指令碼，相信你能看得更詳細。

SQL> SELECT S.SID                             SID, 
         S.USERNAME                        USERNAME, 
         S.MACHINE                         MACHINE, 
         L.TYPE                            TYPE, 
         O.OBJECT_NAME                     OBJECT_NAME, 
         DECODE(L.LMODE, 0, 'None', 
                         1, 'Null', 
                         2, 'Row Share', 
                         3, 'Row Exlusive', 
                         4, 'Share', 
                         5, 'Sh/Row Exlusive', 
                         6, 'Exclusive')   lmode, 
    DECODE(L.REQUEST, 0, 'None', 
                           1, 'Null', 
                           2, 'Row Share', 
                           3, 'Row Exlusive', 
                             4, 'Share', 
                             5, 'Sh/Row Exlusive', 
                           6, 'Exclusive') request, 
         L.BLOCK                           BLOCK 
  FROM   V$LOCK L, 
         V$SESSION S, 
         DBA_OBJECTS O 
  WHERE  L.SID = S.SID 
         AND USERNAME != 'SYSTEM' 
         AND O.OBJECT_ID(+) = L.ID1 
         AND S.SID IN ( 766,789) 
  ORDER  BY S.SID; 

       SID USERNAME MACHINE        TY OBJECT_NAME          LMODE           REQUEST         BLOCK
---------- -------- -------------- -- -------------------- --------------- --------------- -----
       766 TEST     XXXX\GET253194 TX                      Exclusive       None                0
       766 TEST     XXXX\GET253194 TM DEAD_LOCK_FOREIGN    Row Exlusive    None                1
       766 TEST     XXXX\GET253194 TM DEAD_LOCK_PARENT     Row Exlusive    None                0
       883 TEST     DB-Server.loca TX                      Exclusive       None                0
                    ldomain

       883 TEST     DB-Server.loca TM DEAD_LOCK_PARENT     Row Exlusive    None                0
                    ldomain

       883 TEST     DB-Server.loca TM DEAD_LOCK_FOREIGN    Row Exlusive    Sh/Row Exlusive     0
                    ldomain

接著在會話2裡面執行下面SQL，刪除主表中id=2的記錄

SQL> delete from dead_lock_parent where id=2;

你會發現會話1就會出現Deadlock
這裡寫圖片描述
如果你在外來鍵欄位上建立索引，那麼這種情況下的操作就不會出現死鎖。在這裡就不再贅述。有興趣可以測試一下.

外來鍵建立索引建議（Foreign Key Indexing Tips）

雖然增加索引，可能會帶來一些額外的效能開銷（DML操作開銷增加）和磁碟空間方面的開銷，但是相比其帶來的效能改善而言，這些額外的開銷其實完全可以忽略。如果沒有其他特殊情況，建議所有的外來鍵欄位都加上索引。在Oracle Oracle Database 9i/10g/11g程式設計藝術這本書中介紹了在什麼時候不需要對外來鍵加索引. 必須滿足下面三個條件：

1: 不會刪除父表中的行。

2：不論是有意還是無意，總之不會更新父表的唯一/主鍵欄位值。

3：不會從父表聯結到子表，或者更通俗的講，外來鍵列不支援子表的一個重要訪問路徑，而且你在謂詞中沒有使用這些外來鍵累從子表中選擇資料。

找出未索引的外來鍵

我們首先可以通過下面指令碼，找到整個資料庫中那些表有主外來鍵關係，並列出主外來鍵約束.

–檢視整個資料庫下擁有主外來鍵關係的所有表（排除一些系統使用者）

--檢視整個資料庫下擁有主外來鍵關係的所有表（排除一些系統使用者）   
SELECT DC.OWNER                   AS "PARENT_TABLE_OWNER", 
       DC.TABLE_NAME              AS "PARENT_TABLE_NAME", 
       DC.CONSTRAINT_NAME         AS "PRIMARY CONSTRAINT NAME", 
       DF.CONSTRAINT_NAME         AS "REFERENCED CONSTRAINT NAME", 
       DF.OWNER                   AS "CHILD_TABLE_OWNER", 
       DF.TABLE_NAME              AS "CHILD_TABLE_NAME" 
FROM   DBA_CONSTRAINTS DC, 
       (SELECT C.OWNER, 
               C.CONSTRAINT_NAME, 
               C.R_CONSTRAINT_NAME, 
               C.TABLE_NAME 
        FROM   DBA_CONSTRAINTS C 
        WHERE  CONSTRAINT_TYPE = 'R') DF 
WHERE  DC.CONSTRAINT_NAME =DF.R_CONSTRAINT_NAME 
       AND DC.OWNER NOT IN ( 'SYSTEM', 'SYS', 'DBSNMP', 'EXFSYS', 
                            'ORDDATA', 'CTXSYS', 'OLAPSYS', 'MDSYS', 
                            'SYSMAN' );

–檢視某個Schema下擁有主外來鍵關係的所有表

--檢視某個Schema下擁有主外來鍵關係的所有表   
SELECT DC.OWNER           AS "PARENT_TABLE_OWNER", 
       DC.TABLE_NAME      AS "PARENT_TABLE_NAME", 
       DC.CONSTRAINT_NAME AS "PRIMARY CONSTRAINT NAME", 
       DF.CONSTRAINT_NAME AS "REFERENCED CONSTRAINT NAME", 
       DF.OWNER           AS "CHILD_TABLE_OWNER", 
       DF.TABLE_NAME      AS "CHILD_TABLE_NAME" 
FROM   DBA_CONSTRAINTS DC, 
       (SELECT C.OWNER, 
               C.CONSTRAINT_NAME, 
               C.R_CONSTRAINT_NAME, 
               C.TABLE_NAME 
        FROM   DBA_CONSTRAINTS C 
        WHERE  CONSTRAINT_TYPE = 'R') DF 
WHERE  DC.CONSTRAINT_NAME = DF.R_CONSTRAINT_NAME 
       AND DC.OWNER =UPPER('&OWNER');

–檢視某個具體的表是否和其它表擁有主外來鍵關係

--檢視某個具體的表是否和其它表擁有主外來鍵關係  
SELECT DC.OWNER           AS "PARENT_TABLE_OWNER", 
       DC.TABLE_NAME      AS "PARENT_TABLE_NAME", 
       DC.CONSTRAINT_NAME AS "PRIMARY CONSTRAINT NAME", 
       DF.CONSTRAINT_NAME AS "REFERENCED CONSTRAINT NAME", 
       DF.OWNER           AS "CHILD_TABLE_OWNER", 
       DF.TABLE_NAME      AS "CHILD_TABLE_NAME" 
FROM   DBA_CONSTRAINTS DC, 
       (SELECT C.OWNER, 
               C.CONSTRAINT_NAME, 
               C.R_CONSTRAINT_NAME, 
               C.TABLE_NAME 
        FROM   DBA_CONSTRAINTS C 
        WHERE  CONSTRAINT_TYPE = 'R') DF 
WHERE  DC.CONSTRAINT_NAME = DF.R_CONSTRAINT_NAME 
       AND DC.OWNER =UPPER('&OWNER')
       AND DC.TABLE_NAME=UPPER('&TABLE_NAME');

接下來我們要找出在具體的外來鍵欄位是否有索引，指令碼如下所示：

SELECT   CON.OWNER ,
         CON.TABLE_NAME,
         CON.CONSTRAINT_NAME,
         CON.COL_LIST,
         'No Indexed' AS INDEX_STATUS
FROM
     (SELECT CC.OWNER, CC.TABLE_NAME, CC.CONSTRAINT_NAME,
           MAX(DECODE(POSITION, 1,     '"' ||
                  SUBSTR(COLUMN_NAME,1,30) ||'"',NULL)) ||
           MAX(DECODE(POSITION, 2,', '||'"'||
                  SUBSTR(COLUMN_NAME,1,30) ||'"',NULL)) ||
           MAX(DECODE(POSITION, 3,', '||'"'||
                  SUBSTR(COLUMN_NAME,1,30) ||'"',NULL)) ||
           MAX(DECODE(POSITION, 4,', '||'"'||
                  SUBSTR(COLUMN_NAME,1,30) ||'"',NULL)) ||
           MAX(DECODE(POSITION, 5,', '||'"'||
                  SUBSTR(COLUMN_NAME,1,30) ||'"',NULL)) ||
           MAX(DECODE(POSITION, 6,', '||'"'||
                  SUBSTR(COLUMN_NAME,1,30) ||'"',NULL)) ||
           MAX(DECODE(POSITION, 7,', '||'"'||
                  SUBSTR(COLUMN_NAME,1,30) ||'"',NULL)) ||
           MAX(DECODE(POSITION, 8,', '||'"'||
                  SUBSTR(COLUMN_NAME,1,30) ||'"',NULL)) ||
           MAX(DECODE(POSITION, 9,', '||'"'||
                  SUBSTR(COLUMN_NAME,1,30) ||'"',NULL)) ||
           MAX(DECODE(POSITION, 10,', '||'"'||
                  SUBSTR(COLUMN_NAME,1,30) ||'"',NULL)) COL_LIST
           FROM DBA_CONSTRAINTS DC, DBA_CONS_COLUMNS CC
           WHERE DC.OWNER = CC.OWNER
           AND DC.CONSTRAINT_NAME = CC.CONSTRAINT_NAME
           AND DC.CONSTRAINT_TYPE = 'R'
           AND DC.OWNER NOT IN ('SYS', 'SYSTEM', 'OLAPSYS', 'SYSMAN', 'MDSYS', 'ADMIN')
           GROUP BY CC.OWNER, CC.TABLE_NAME, CC.CONSTRAINT_NAME 
     ) CON
      WHERE NOT EXISTS (
        SELECT 1 FROM
                  ( SELECT TABLE_OWNER, TABLE_NAME,   
                       MAX(DECODE(COLUMN_POSITION, 1,     '"'||
                              SUBSTR(COLUMN_NAME,1,30)  ||'"',NULL)) ||
                       MAX(DECODE(COLUMN_POSITION, 2,', '||'"'||
                              SUBSTR(COLUMN_NAME,1,30)  ||'"',NULL)) ||
                       MAX(DECODE(COLUMN_POSITION, 3,', '||'"'||
                              SUBSTR(COLUMN_NAME,1,30)  ||'"',NULL)) ||
                       MAX(DECODE(COLUMN_POSITION, 4,', '||'"'||
                              SUBSTR(COLUMN_NAME,1,30)  ||'"',NULL)) ||
                       MAX(DECODE(COLUMN_POSITION, 5,', '||'"'||
                              SUBSTR(COLUMN_NAME,1,30)  ||'"',NULL)) ||
                       MAX(DECODE(COLUMN_POSITION, 6,', '||'"'||
                              SUBSTR(COLUMN_NAME,1,30)  ||'"',NULL)) ||
                       MAX(DECODE(COLUMN_POSITION, 7,', '||'"'||
                              SUBSTR(COLUMN_NAME,1,30)  ||'"',NULL)) ||
                       MAX(DECODE(COLUMN_POSITION, 8,', '||'"'||
                              SUBSTR(COLUMN_NAME,1,30)  ||'"',NULL)) ||
                       MAX(DECODE(COLUMN_POSITION, 9,', '||'"'||
                              SUBSTR(COLUMN_NAME,1,30)  ||'"',NULL)) ||
                       MAX(DECODE(COLUMN_POSITION, 10,', '||'"'||
                              SUBSTR(COLUMN_NAME,1,30)  ||'"',NULL)) COL_LIST
                       FROM DBA_IND_COLUMNS 
                   WHERE TABLE_OWNER NOT IN ('SYS', 'SYSTEM', 'OLAPSYS', 'SYSMAN', 'MDSYS')
                   GROUP BY TABLE_OWNER, TABLE_NAME, INDEX_NAME ) COL
    WHERE CON.OWNER = COL.TABLE_OWNER 
    AND CON.TABLE_NAME = COL.TABLE_NAME  
    AND CON.COL_LIST = SUBSTR(COL.COL_LIST, 1, LENGTH(CON.COL_LIST) ) )  ;

如果是ORACLE 11g或以上版本，資料庫有分析函式LISTAGG的話，可以使用下面指令碼

SELECT CASE 
         WHEN B.TABLE_NAME IS NULL THEN 'NO INDEXED' 
         ELSE 'INDEXED' 
       END               AS STATUS, 
       A.TABLE_OWNER     AS TABLE_OWNER, 
       A.TABLE_NAME      AS TABLE_NAME, 
       A.CONSTRAINT_NAME AS FK_NAME, 
       A.FK_COLUMNS      AS FK_COLUMNS, 
       B.INDEX_NAME      AS INDEX_NAME, 
       B.INDEX_COLUMNS   AS INDEX_COLUMNS 
FROM   (SELECT A.OWNER                              AS TABLE_OWNER, 
               A.TABLE_NAME                         AS TABLE_NAME, 
               A.CONSTRAINT_NAME                    AS CONSTRAINT_NAME, 
               LISTAGG(A.COLUMN_NAME, ',') 
                 WITHIN GROUP (ORDER BY A.POSITION) FK_COLUMNS 
        FROM   DBA_CONS_COLUMNS A, 
               DBA_CONSTRAINTS B 
        WHERE  A.CONSTRAINT_NAME = B.CONSTRAINT_NAME 
               AND B.CONSTRAINT_TYPE = 'R' 
               AND A.OWNER = B.OWNER 
               AND A.OWNER NOT IN ( 'SYS', 'SYSTEM', 'OLAPSYS', 'SYSMAN', 
                                    'MDSYS' ) 
        GROUP  BY A.OWNER, 
                  A.TABLE_NAME, 
                  A.CONSTRAINT_NAME) A, 
       (SELECT TABLE_OWNER, 
               TABLE_NAME, 
               INDEX_NAME, 
               LISTAGG(C.COLUMN_NAME, ',') 
                 WITHIN GROUP (ORDER BY C.COLUMN_POSITION) INDEX_COLUMNS 
        FROM   DBA_IND_COLUMNS C 
        GROUP  BY TABLE_OWNER, 
                  TABLE_NAME, 
                  INDEX_NAME) B 
WHERE  A.TABLE_NAME = B.TABLE_NAME(+) 
       AND A.TABLE_OWNER = B.TABLE_OWNER(+) 
       AND B.INDEX_COLUMNS(+) LIKE A.FK_COLUMNS 
                                   || '%' 
ORDER  BY 1 DESC

自動生成建立外來鍵索引的指令碼

上面的這些指令碼已經能找出那些外來鍵欄位已經建立或未建立索引，此時如果對外來鍵欄位缺少索引的表手工建立索引的話，如果數量很多的話，那麼工作量也非常大，下面可以用這個指令碼自動生成缺失的索引

/*******************************************************************************************
--指令碼功能描述：
--  對於資料庫中外來鍵缺少索引的欄位，生成對應的索引（排除一些系統賬號，例如sys、system）,如果外來鍵索引超過十個欄位
--  那麼這個指令碼就不能正確的生成對應的索引，當然也很少有外來鍵設定在超過10個欄位的。另外索引表空
--  空間跟資料表空間相同，如有分開的話，建議在此處再做調整。
********************************************************************************************/
SELECT    'CREATE INDEX ' || OWNER || '.' || REPLACE(CONSTRAINT_NAME,'FK_','IX_') || 
        ' ON ' || OWNER || '.' || TABLE_NAME || ' (' || COL_LIST ||') TABLESPACE ' 
        || (SELECT TABLESPACE_NAME FROM DBA_TABLES WHERE OWNER= CON.OWNER AND TABLE_NAME= CON.TABLE_NAME) 
        AS  CREATE_INDEXES_ON_FOREIGN_KEY 
FROM
     (SELECT CC.OWNER, CC.TABLE_NAME, CC.CONSTRAINT_NAME,
           MAX(DECODE(POSITION, 1,     '"' ||
                  SUBSTR(COLUMN_NAME,1,30) ||'"',NULL)) ||
           MAX(DECODE(POSITION, 2,', '||'"'||
                  SUBSTR(COLUMN_NAME,1,30) ||'"',NULL)) ||
           MAX(DECODE(POSITION, 3,', '||'"'||
                  SUBSTR(COLUMN_NAME,1,30) ||'"',NULL)) ||
           MAX(DECODE(POSITION, 4,', '||'"'||
                  SUBSTR(COLUMN_NAME,1,30) ||'"',NULL)) ||
           MAX(DECODE(POSITION, 5,', '||'"'||
                  SUBSTR(COLUMN_NAME,1,30) ||'"',NULL)) ||
           MAX(DECODE(POSITION, 6,', '||'"'||
                  SUBSTR(COLUMN_NAME,1,30) ||'"',NULL)) ||
           MAX(DECODE(POSITION, 7,', '||'"'||
                  SUBSTR(COLUMN_NAME,1,30) ||'"',NULL)) ||
           MAX(DECODE(POSITION, 8,', '||'"'||
                  SUBSTR(COLUMN_NAME,1,30) ||'"',NULL)) ||
           MAX(DECODE(POSITION, 9,', '||'"'||
                  SUBSTR(COLUMN_NAME,1,30) ||'"',NULL)) ||
           MAX(DECODE(POSITION, 10,', '||'"'||
                  SUBSTR(COLUMN_NAME,1,30) ||'"',NULL)) COL_LIST
           FROM DBA_CONSTRAINTS DC, DBA_CONS_COLUMNS CC
           WHERE DC.OWNER = CC.OWNER
           AND DC.CONSTRAINT_NAME = CC.CONSTRAINT_NAME
           AND DC.CONSTRAINT_TYPE = 'R'
           AND DC.OWNER NOT IN ('SYS', 'SYSTEM', 'OLAPSYS', 'SYSMAN', 'MDSYS', 'ADMIN')
           GROUP BY CC.OWNER, CC.TABLE_NAME, CC.CONSTRAINT_NAME 
     ) CON
      WHERE NOT EXISTS (
        SELECT 1 FROM
                  ( SELECT TABLE_OWNER, TABLE_NAME,   
                       MAX(DECODE(COLUMN_POSITION, 1,     '"'||
                              SUBSTR(COLUMN_NAME,1,30)  ||'"',NULL)) ||
                       MAX(DECODE(COLUMN_POSITION, 2,', '||'"'||
                              SUBSTR(COLUMN_NAME,1,30)  ||'"',NULL)) ||
                       MAX(DECODE(COLUMN_POSITION, 3,', '||'"'||
                              SUBSTR(COLUMN_NAME,1,30)  ||'"',NULL)) ||
                       MAX(DECODE(COLUMN_POSITION, 4,', '||'"'||
                              SUBSTR(COLUMN_NAME,1,30)  ||'"',NULL)) ||
                       MAX(DECODE(COLUMN_POSITION, 5,', '||'"'||
                              SUBSTR(COLUMN_NAME,1,30)  ||'"',NULL)) ||
                       MAX(DECODE(COLUMN_POSITION, 6,', '||'"'||
                              SUBSTR(COLUMN_NAME,1,30)  ||'"',NULL)) ||
                       MAX(DECODE(COLUMN_POSITION, 7,', '||'"'||
                              SUBSTR(COLUMN_NAME,1,30)  ||'"',NULL)) ||
                       MAX(DECODE(COLUMN_POSITION, 8,', '||'"'||
                              SUBSTR(COLUMN_NAME,1,30)  ||'"',NULL)) ||
                       MAX(DECODE(COLUMN_POSITION, 9,', '||'"'||
                              SUBSTR(COLUMN_NAME,1,30)  ||'"',NULL)) ||
                       MAX(DECODE(COLUMN_POSITION, 10,', '||'"'||
                              SUBSTR(COLUMN_NAME,1,30)  ||'"',NULL)) COL_LIST
                       FROM DBA_IND_COLUMNS 
                   WHERE TABLE_OWNER NOT IN ('SYS', 'SYSTEM', 'OLAPSYS', 'SYSMAN', 'MDSYS')
                   GROUP BY TABLE_OWNER, TABLE_NAME, INDEX_NAME ) COL
    WHERE CON.OWNER = COL.TABLE_OWNER 
    AND CON.TABLE_NAME = COL.TABLE_NAME  
    AND CON.COL_LIST = SUBSTR(COL.COL_LIST, 1, LENGTH(CON.COL_LIST) ) )  ;

–指令碼使用分析函式LISTAGG，適用於ORACLE 11g以及以上版本，如果資料庫版本是Oracle 11g及以上，就可以使用此指令碼替代上面指令碼。

SELECT 'CREATE INDEX ' 
              || OWNER 
              || '.' 
              || REPLACE(CONSTRAINT_NAME,'FK_','IX_') 
              || ' ON ' 
              || OWNER 
              || '.' 
              || TABLE_NAME 
              || ' (' 
              || FK_COLUMNS 
              ||') TABLESPACE ' 
              || 
       ( 
              SELECT TABLESPACE_NAME 
              FROM   DBA_TABLES 
              WHERE  OWNER= CON.OWNER 
              AND    TABLE_NAME= CON.TABLE_NAME) CREATE_INDEXES_ON_FOREIGN_KEY 
FROM   ( 
                SELECT   CC.OWNER, 
                         CC.TABLE_NAME, 
                         CC.CONSTRAINT_NAME, 
                         LISTAGG(CC.COLUMN_NAME, ',') WITHIN GROUP (ORDER BY CC.POSITION) FK_COLUMNS
                FROM     DBA_CONS_COLUMNS CC, 
                         DBA_CONSTRAINTS DC 
                WHERE    CC.CONSTRAINT_NAME = DC.CONSTRAINT_NAME 
                AND      DC.CONSTRAINT_TYPE = 'R' 
                AND      CC.OWNER = DC.OWNER 
                AND      DC.OWNER NOT IN ( 'SYS', 
                                          'SYSTEM', 
                                          'OLAPSYS', 
                                          'SYSMAN', 
                                          'MDSYS', 
                                          'ADMIN' ) 
                GROUP BY CC.OWNER, 
                         CC.TABLE_NAME, 
                         CC.CONSTRAINT_NAME) CON 
  WHERE NOT EXISTS 
       ( 
              SELECT 1 
              FROM   ( 
                              SELECT   TABLE_OWNER, 
                                       TABLE_NAME, 
                                       INDEX_NAME,
                                       LISTAGG(COLUMN_NAME, ',') WITHIN GROUP (ORDER BY COLUMN_POSITION) FK_COLUMNS
                              FROM     DBA_IND_COLUMNS 
                              WHERE    INDEX_OWNER NOT IN ( 'SYS', 
                                                           'SYSTEM', 
                                                           'OLAPSYS', 
                                                           'SYSMAN', 
                                                           'MDSYS', 
                                                           'ADMIN' ) 

                              GROUP BY TABLE_OWNER, 
                                       TABLE_NAME ,INDEX_NAME) COL 
              WHERE  CON.OWNER = COL.TABLE_OWNER 
              AND    CON.TABLE_NAME = COL.TABLE_NAME 
              AND    CON.FK_COLUMNS = SUBSTR(COL.FK_COLUMNS, 1, LENGTH(CON.FK_COLUMNS)) ) 
              ORDER BY 1;

ORACLE中關於外來鍵缺少索引的探討和總結

ORACLE中關於外來鍵缺少索引的探討和總結

Oracle中主鍵和唯一索引的區別oracle中聯合主鍵的作用

資料庫主鍵和外來鍵及索引

Oracle (05)外來鍵約束.序列.索引.檢視.分頁查詢技術.排序分頁查詢.資料庫表格設計正規化

MySQL中外來鍵的定義、作用、新增和刪除

外來鍵缺乏索引導致的Oracle資料庫死鎖

oracle中比較alter table t move 和alter table t shrink space

oracle中常用的 join on 相關和集合運算的總結

oracle中的替換函數replace和translate函數

Django中外來鍵使用詳解

mysql查詢指定庫的所有表的記錄數、外來鍵、索引、檢視、觸發器等

EF Core中外來鍵關係的DeleteBehavior介紹（轉自MSDN）

MySql多對多關係中外來鍵的應用

oracle建立外來鍵約束的兩種方式

資料庫表中外來鍵的建立

資料庫——主鍵、外來鍵、索引

Oracle中trunc、round 、ceil和floor函式的區別

Mac的VIM中delete鍵失效的原因和解決方案 • cenalulu's Tech Blog

oracle新增外來鍵約束的兩種方式

【0016】MySQL外來鍵約束刪除時和更新時各取值的含義

ORACLE中關於外來鍵缺少索引的探討和總結

相關推薦