Saturday, October 2, 2010

db_file_multiblock_read_count not in effect…

 

With reference to one of the question in forum about couple of days where it was asked regarding the Hash join index is favoured  or Nested loops. The part of  the story deals with big and small tables of size 550 MB and 26 GB. You can go through the below link for your reference.

http://forums.oracle.com/forums/thread.jspa?threadID=1319851&tstart=0&start=15

Charles Hooper had provided very interesting test case and it was very informative. Please find the link below for your reference and with couple of questions across..!!

http://hoopercharles.wordpress.com/2010/10/01/first-table-is-550mb-second-table-is-26gb-nested-loops-or-full-table-scan/

I had performed same test case, took the same scripts and perhaps got some interesting points too. There exists some slight change as just went for 10 byte instead of 200 byte fetch and changed the number of rows with respect to tables. T1 – as 1000000 records and T2 – 1000 records.  Looking into the number volume of  data and criteria or records which fetched across Optimizer things works in different way. It’s depends on the order of records, indexes availability and required columns which used against the tables to fetch the appropriate records.

   1: SQL> CREATE TABLE T1 (
   2:   2    COL1 NUMBER,
   3:   3    COL2 NUMBER,
   4:   4    COL3 VARCHAR2(10),
   5:   5    PRIMARY KEY(COL1));
   6:  
   7: Table created.
   8:  
   9: SQL> 
  10: SQL> INSERT INTO
  11:   2    T1
  12:   3  SELECT
  13:   4    ROWNUM,
  14:   5    10000000-ROWNUM,
  15:   6    RPAD(TO_CHAR(ROWNUM),10,'A')
  16:   7  FROM
  17:   8    (SELECT
  18:   9      ROWNUM RN
  19:  10    FROM
  20:  11      DUAL
  21:  12    CONNECT BY
  22:  13      LEVEL<=1000) V1,
  23:  14    (SELECT
  24:  15      ROWNUM RN
  25:  16    FROM
  26:  17      DUAL
  27:  18    CONNECT BY
  28:  19      LEVEL<=1000) V2;
  29:  
  30: 1000000 rows created.
  31:  
  32: SQL> 
  33: SQL> COMMIT;/
  34:   2  ;
  35:  
  36:  
  37: SQL> ALTER TABLE T1 MODIFY(COL2 NOT NULL);
  38:  
  39: Table altered.
  40:  
  41: SQL> 
  42: SQL> CREATE INDEX IND_T1_COL2 ON T1(COL2);
  43:  
  44: Index created.
  45:  
  46: SQL> 
  47: SQL> 
  48: SQL> CREATE TABLE T2 (
  49:   2    COL1 NUMBER,
  50:   3    COL2 NUMBER,
  51:   4    COL3 VARCHAR2(10),
  52:   5    PRIMARY KEY(COL1));
  53:  
  54: Table created.
  55:  
  56: SQL> 
  57: SQL> INSERT INTO
  58:   2    T2
  59:   3  SELECT
  60:   4    ROWNUM,
  61:   5    10000000-ROWNUM,
  62:   6    RPAD(TO_CHAR(ROWNUM),10,'A')
  63:   7  FROM
  64:   8    (SELECT
  65:   9      ROWNUM RN
  66:  10    FROM
  67:  11      DUAL
  68:  12    CONNECT BY
  69:  13      LEVEL<=1000);
  70:  
  71: 1000 rows created.
  72:  
  73: SQL> 
  74: SQL> COMMIT;
  75:  
  76: Commit complete.
  77:  
  78: SQL> 
  79: SQL> ALTER TABLE T2 MODIFY(COL2 NOT NULL);
  80:  
  81: Table altered.
  82:  
  83: SQL> 
  84: SQL> CREATE INDEX IND_T2_COL2 ON T2(COL2);
  85:  
  86: Index created.
  87:  
  88: SQL> EXEC DBMS_STATS.GATHER_TABLE_STATS(OWNNAME=>USER,TABNAME=>'T1',CASCADE=>TRUE)
  89:  
  90: PL/SQL procedure successfully completed.
  91:  
  92: SQL> EXEC DBMS_STATS.GATHER_TABLE_STATS(OWNNAME=>USER,TABNAME=>'T2',CASCADE=>TRUE);
  93:  
  94: PL/SQL procedure successfully completed.
  95:  
  96: SQL> SELECT
  97:   2    T1.COL1,
  98:   3    T1.COL2,
  99:   4    T1.COL3,
 100:   5    T2.COL1,
 101:   6    T2.COL2,
 102:   7    T2.COL3
 103:   8  FROM
 104:   9    T1,
 105:  10    T2
 106:  11  WHERE
 107:  12  ;
 108:  
 109:  
 110: SQL> SET AUTOTRACE TRACEONLY EXPLAIN
 111: SQL> SET LINESIZE 140
 112: SQL> SET PAGESIZE 1000
 113: SQL> SET TRIMSPOOL ON
 114: SQL> SELECT
 115:   2    T1.COL1,
 116:   3    T1.COL2,
 117:   4    T1.COL3,
 118:   5    T2.COL1,
 119:   6    T2.COL2,
 120:   7    T2.COL3
 121:   8  FROM
 122:   9    T1,
 123:  10    T2
 124:  11  WHERE
 125:  12    T1.COL1=T2.COL1;
 126:  
 127: Execution Plan
 128: ----------------------------------------------------------
 129: Plan hash value: 2959412835
 130:  
 131: ---------------------------------------------------------------------------
 132: | Id  | Operation          | Name | Rows  | Bytes | Cost (%CPU)| Time     |
 133: ---------------------------------------------------------------------------
 134: |   0 | SELECT STATEMENT   |      |  1000 | 43000 |  1029   (2)| 00:00:13 |
 135: |*  1 |  HASH JOIN         |      |  1000 | 43000 |  1029   (2)| 00:00:13 |
 136: |   2 |   TABLE ACCESS FULL| T2   |  1000 | 21000 |     3   (0)| 00:00:01 |
 137: |   3 |   TABLE ACCESS FULL| T1   |  1000K|    20M|  1021   (2)| 00:00:13 |
 138: ---------------------------------------------------------------------------
 139: Predicate Information (identified by operation id):
 140: ---------------------------------------------------
 141:    1 - access("T1"."COL1"="T2"."COL1")
 142:  
 143: SQL> SELECT
 144:   2    T1.COL1,
 145:   3    T1.COL2,
 146:   4    T1.COL3,
 147:   5    T2.COL1,
 148:   6    T2.COL2,
 149:   7    T2.COL3
 150:   8  FROM
 151:   9    T1,
 152:  10    T2
 153:  11  WHERE
 154:  12    T1.COL2=T2.COL2;
 155:  
 156: Execution Plan
 157: ----------------------------------------------------------
 158: Plan hash value: 2959412835
 159:  
 160: ---------------------------------------------------------------------------
 161: | Id  | Operation          | Name | Rows  | Bytes | Cost (%CPU)| Time     |
 162: ---------------------------------------------------------------------------
 163: |   0 | SELECT STATEMENT   |      |  1000 | 43000 |  1029   (2)| 00:00:13 |
 164: |*  1 |  HASH JOIN         |      |  1000 | 43000 |  1029   (2)| 00:00:13 |
 165: |   2 |   TABLE ACCESS FULL| T2   |  1000 | 21000 |     3   (0)| 00:00:01 |
 166: |   3 |   TABLE ACCESS FULL| T1   |  1000K|    20M|  1021   (2)| 00:00:13 |
 167: ---------------------------------------------------------------------------
 168: Predicate Information (identified by operation id):
 169: ---------------------------------------------------
 170:    1 - access("T1"."COL2"="T2"."COL2")
 171:  
 172: SQL> SELECT
 173:   2    T1.COL1,
 174:   3    T1.COL2,
 175:   4    T1.COL3,
 176:   5    T2.COL1,
 177:   6    T2.COL2,
 178:   7    T2.COL3
 179:   8  FROM
 180:   9    T1,
 181:  10    T2
 182:  11  WHERE
 183:  12    T1.COL1=T2.COL1
 184:  13    AND T1.COL1 BETWEEN 1 AND 100;
 185:  
 186: Execution Plan
 187: ----------------------------------------------------------
 188: Plan hash value: 251510629
 189:  
 190: ----------------------------------------------------------------------------------------------
 191: | Id  | Operation                     | Name         | Rows  | Bytes | Cost (%CPU)| Time     |
 192: ----------------------------------------------------------------------------------------------
 193: |   0 | SELECT STATEMENT              |              |    99 |  4257 |     5   (0)| 00:00:01 |
 194: |   1 |  NESTED LOOPS                 |              |       |       |            |          |
 195: |   2 |   NESTED LOOPS                |              |    99 |  4257 |     5   (0)| 00:00:01 |
 196: |   3 |    TABLE ACCESS BY INDEX ROWID| T1           |   100 |  2200 |     4   (0)| 00:00:01 |
 197: |*  4 |     INDEX RANGE SCAN          | SYS_C0011233 |   100 |       |     3   (0)| 00:00:01 |
 198: |*  5 |    INDEX UNIQUE SCAN          | SYS_C0011235 |     1 |       |     0   (0)| 00:00:01 |
 199: |   6 |   TABLE ACCESS BY INDEX ROWID | T2           |     1 |    21 |     1   (0)| 00:00:01 |
 200: ----------------------------------------------------------------------------------------------
 201: Predicate Information (identified by operation id):
 202: ---------------------------------------------------
 203:    4 - access("T1"."COL1">=1 AND "T1"."COL1"<=100)
 204:    5 - access("T1"."COL1"="T2"."COL1")
 205:        filter("T2"."COL1"<=100 AND "T2"."COL1">=1)
 206:  
 207: SQL> SELECT
 208:   2    T1.COL1,
 209:   3    T1.COL2,
 210:   4    T1.COL3,
 211:   5    T2.COL1,
 212:   6    T2.COL2,
 213:   7    T2.COL3
 214:   8  FROM
 215:   9    T1,
 216:  10    T2
 217:  11  WHERE
 218:  12    T1.COL1=T2.COL1
 219:  13    AND T1.COL1 BETWEEN 1 AND 1000;
 220:  
 221: Execution Plan
 222: ----------------------------------------------------------
 223: Plan hash value: 251510629
 224:  
 225: ----------------------------------------------------------------------------------------------
 226: | Id  | Operation                     | Name         | Rows  | Bytes | Cost (%CPU)| Time     |
 227: ----------------------------------------------------------------------------------------------
 228: |   0 | SELECT STATEMENT              |              |   999 | 42957 |     9   (0)| 00:00:01 |
 229: |   1 |  NESTED LOOPS                 |              |       |       |            |          |
 230: |   2 |   NESTED LOOPS                |              |   999 | 42957 |     9   (0)| 00:00:01 |
 231: |   3 |    TABLE ACCESS BY INDEX ROWID| T1           |  1000 | 22000 |     8   (0)| 00:00:01 |
 232: |*  4 |     INDEX RANGE SCAN          | SYS_C0011233 |  1000 |       |     4   (0)| 00:00:01 |
 233: |*  5 |    INDEX UNIQUE SCAN          | SYS_C0011235 |     1 |       |     0   (0)| 00:00:01 |
 234: |   6 |   TABLE ACCESS BY INDEX ROWID | T2           |     1 |    21 |     1   (0)| 00:00:01 |
 235: ----------------------------------------------------------------------------------------------
 236: Predicate Information (identified by operation id):
 237: ---------------------------------------------------
 238:    4 - access("T1"."COL1">=1 AND "T1"."COL1"<=1000)
 239:    5 - access("T1"."COL1"="T2"."COL1")
 240:        filter("T2"."COL1">=1 AND "T2"."COL1"<=1000)
 241:  
 242: SQL> SELECT
 243:   2    T1.COL1,
 244:   3    T1.COL2,
 245:   4    T1.COL3,
 246:   5    T2.COL1,
 247:   6    T2.COL2,
 248:   7    T2.COL3
 249:   8  FROM
 250:   9    T1,
 251:  10    T2
 252:  11  WHERE
 253:  12    T1.COL1=T2.COL1
 254:  13    AND T1.COL2 BETWEEN 1 AND 100;
 255:  
 256: Execution Plan
 257: ----------------------------------------------------------
 258: Plan hash value: 930734649
 259:  
 260: ----------------------------------------------------------------------------------------------
 261: | Id  | Operation                     | Name         | Rows  | Bytes | Cost (%CPU)| Time     |
 262: ----------------------------------------------------------------------------------------------
 263: |   0 | SELECT STATEMENT              |              |     1 |    43 |     5   (0)| 00:00:01 |
 264: |   1 |  NESTED LOOPS                 |              |       |       |            |          |
 265: |   2 |   NESTED LOOPS                |              |     1 |    43 |     5   (0)| 00:00:01 |
 266: |   3 |    TABLE ACCESS BY INDEX ROWID| T1           |     1 |    22 |     4   (0)| 00:00:01 |
 267: |*  4 |     INDEX RANGE SCAN          | IND_T1_COL2  |     1 |       |     3   (0)| 00:00:01 |
 268: |*  5 |    INDEX UNIQUE SCAN          | SYS_C0011235 |     1 |       |     0   (0)| 00:00:01 |
 269: |   6 |   TABLE ACCESS BY INDEX ROWID | T2           |     1 |    21 |     1   (0)| 00:00:01 |
 270: ----------------------------------------------------------------------------------------------
 271: Predicate Information (identified by operation id):
 272: ---------------------------------------------------
 273:    4 - access("T1"."COL2">=1 AND "T1"."COL2"<=100)
 274:    5 - access("T1"."COL1"="T2"."COL1")
 275:  
 276: SQL> SELECT
 277:   2    T1.COL1,
 278:   3    T1.COL2,
 279:   4    T1.COL3,
 280:   5    T2.COL1,
 281:   6    T2.COL2,
 282:   7    T2.COL3
 283:   8  FROM
 284:   9    T1,
 285:  10    T2
 286:  11  WHERE
 287:  12    T1.COL1=T2.COL1
 288:  13    AND T1.COL2 BETWEEN 1 AND 1000;
 289:  
 290: Execution Plan
 291: ----------------------------------------------------------
 292: Plan hash value: 930734649
 293:  
 294: ----------------------------------------------------------------------------------------------
 295: | Id  | Operation                     | Name         | Rows  | Bytes | Cost (%CPU)| Time     |
 296: ----------------------------------------------------------------------------------------------
 297: |   0 | SELECT STATEMENT              |              |     1 |    43 |     5   (0)| 00:00:01 |
 298: |   1 |  NESTED LOOPS                 |              |       |       |            |          |
 299: |   2 |   NESTED LOOPS                |              |     1 |    43 |     5   (0)| 00:00:01 |
 300: |   3 |    TABLE ACCESS BY INDEX ROWID| T1           |     1 |    22 |     4   (0)| 00:00:01 |
 301: |*  4 |     INDEX RANGE SCAN          | IND_T1_COL2  |     1 |       |     3   (0)| 00:00:01 |
 302: |*  5 |    INDEX UNIQUE SCAN          | SYS_C0011235 |     1 |       |     0   (0)| 00:00:01 |
 303: |   6 |   TABLE ACCESS BY INDEX ROWID | T2           |     1 |    21 |     1   (0)| 00:00:01 |
 304: ----------------------------------------------------------------------------------------------
 305: Predicate Information (identified by operation id):
 306: ---------------------------------------------------
 307:    4 - access("T1"."COL2">=1 AND "T1"."COL2"<=1000)
 308:    5 - access("T1"."COL1"="T2"."COL1")
 309:  
 310: SQL> SELECT
 311:   2    T1.COL1,
 312:   3    T1.COL2,
 313:   4    T1.COL3,
 314:   5    T2.COL1,
 315:   6    T2.COL2,
 316:   7    T2.COL3
 317:   8  FROM
 318:   9    T1,
 319:  10    T2
 320:  11  WHERE
 321:  12    T1.COL1=T2.COL1
 322:  13    AND T2.COL1 BETWEEN 1 AND 10000;
 323:  
 324: Execution Plan
 325: ----------------------------------------------------------
 326: Plan hash value: 52326019
 327:  
 328: ---------------------------------------------------------------------------------------------
 329: | Id  | Operation                    | Name         | Rows  | Bytes | Cost (%CPU)| Time     |
 330: ---------------------------------------------------------------------------------------------
 331: |   0 | SELECT STATEMENT             |              |  1000 | 43000 |    63   (2)| 00:00:01 |
 332: |*  1 |  HASH JOIN                   |              |  1000 | 43000 |    63   (2)| 00:00:01 |
 333: |*  2 |   TABLE ACCESS FULL          | T2           |  1000 | 21000 |     3   (0)| 00:00:01 |
 334: |   3 |   TABLE ACCESS BY INDEX ROWID| T1           | 10000 |   214K|    59   (0)| 00:00:01 |
 335: |*  4 |    INDEX RANGE SCAN          | SYS_C0011233 | 10000 |       |    21   (0)| 00:00:01 |
 336: ---------------------------------------------------------------------------------------------
 337: Predicate Information (identified by operation id):
 338: ---------------------------------------------------
 339:    1 - access("T1"."COL1"="T2"."COL1")
 340:    2 - filter("T2"."COL1">=1 AND "T2"."COL1"<=10000)
 341:    4 - access("T1"."COL1">=1 AND "T1"."COL1"<=10000)
 342:  
 343: SQL> SELECT
 344:   2    T1.COL1,
 345:   3    T1.COL2,
 346:   4    T1.COL3,
 347:   5    T2.COL1,
 348:   6    T2.COL2,
 349:   7    T2.COL3
 350:   8  FROM
 351:   9    T1,
 352:  10    T2
 353:  11  WHERE
 354:  12    T1.COL1=T2.COL1
 355:  13    AND T2.COL1 BETWEEN 1 AND 100000;
 356:  
 357: Execution Plan
 358: ----------------------------------------------------------
 359: Plan hash value: 52326019
 360:  
 361: ---------------------------------------------------------------------------------------------
 362: | Id  | Operation                    | Name         | Rows  | Bytes | Cost (%CPU)| Time     |
 363: ---------------------------------------------------------------------------------------------
 364: |   0 | SELECT STATEMENT             |              |  1000 | 43000 |   568   (1)| 00:00:07 |
 365: |*  1 |  HASH JOIN                   |              |  1000 | 43000 |   568   (1)| 00:00:07 |
 366: |*  2 |   TABLE ACCESS FULL          | T2           |  1000 | 21000 |     3   (0)| 00:00:01 |
 367: |   3 |   TABLE ACCESS BY INDEX ROWID| T1           |   100K|  2148K|   564   (1)| 00:00:07 |
 368: |*  4 |    INDEX RANGE SCAN          | SYS_C0011233 |   100K|       |   191   (1)| 00:00:03 |
 369: ---------------------------------------------------------------------------------------------
 370: Predicate Information (identified by operation id):
 371: ---------------------------------------------------
 372:    1 - access("T1"."COL1"="T2"."COL1")
 373:    2 - filter("T2"."COL1">=1 AND "T2"."COL1"<=100000)
 374:    4 - access("T1"."COL1">=1 AND "T1"."COL1"<=100000)
 375:  
 376: SQL> SELECT
 377:   2    T1.COL1,
 378:   3    T1.COL2,
 379:   4    T1.COL3,
 380:   5    T2.COL1,
 381:   6    T2.COL2,
 382:   7    T2.COL3
 383:   8  FROM
 384:   9    T1,
 385:  10    T2
 386:  11  WHERE
 387:  12    T1.COL1=T2.COL1
 388:  13    AND T2.COL1 between 1 and 125000;
 389:  
 390: Execution Plan
 391: ----------------------------------------------------------
 392: Plan hash value: 2242062804
 393:  
 394: ---------------------------------------------------------------------------------------------
 395: | Id  | Operation                    | Name         | Rows  | Bytes | Cost (%CPU)| Time     |
 396: ---------------------------------------------------------------------------------------------
 397: |   0 | SELECT STATEMENT             |              |  1000 | 43000 |   709   (1)| 00:00:09 |
 398: |   1 |  MERGE JOIN                  |              |  1000 | 43000 |   709   (1)| 00:00:09 |
 399: |   2 |   TABLE ACCESS BY INDEX ROWID| T1           |   125K|  2685K|   705   (1)| 00:00:09 |
 400: |*  3 |    INDEX RANGE SCAN          | SYS_C0011233 |   125K|       |   238   (1)| 00:00:03 |
 401: |*  4 |   SORT JOIN                  |              |  1000 | 21000 |     4  (25)| 00:00:01 |
 402: |*  5 |    TABLE ACCESS FULL         | T2           |  1000 | 21000 |     3   (0)| 00:00:01 |
 403: ---------------------------------------------------------------------------------------------
 404: Predicate Information (identified by operation id):
 405: ---------------------------------------------------
 406:    3 - access("T1"."COL1">=1 AND "T1"."COL1"<=125000)
 407:    4 - access("T1"."COL1"="T2"."COL1")
 408:        filter("T1"."COL1"="T2"."COL1")
 409:    5 - filter("T2"."COL1">=1 AND "T2"."COL1"<=125000)
 410:  
 411: SQL> 
 412: SQL> SELECT
 413:   2    T1.COL1,
 414:   3    T1.COL2,
 415:   4    T1.COL3,
 416:   5    T2.COL1,
 417:   6    T2.COL2,
 418:   7    T2.COL3
 419:   8  FROM
 420:   9    T1,
 421:  10    T2
 422:  11  WHERE
 423:  12    T1.COL1=T2.COL1
 424:  13    AND T2.COL1 between 1 and 250000;
 425:  
 426: Execution Plan
 427: ----------------------------------------------------------
 428: Plan hash value: 2959412835
 429:  
 430: ---------------------------------------------------------------------------
 431: | Id  | Operation          | Name | Rows  | Bytes | Cost (%CPU)| Time     |
 432: ---------------------------------------------------------------------------
 433: |   0 | SELECT STATEMENT   |      |  1000 | 43000 |  1027   (2)| 00:00:13 |
 434: |*  1 |  HASH JOIN         |      |  1000 | 43000 |  1027   (2)| 00:00:13 |
 435: |*  2 |   TABLE ACCESS FULL| T2   |  1000 | 21000 |     3   (0)| 00:00:01 |
 436: |*  3 |   TABLE ACCESS FULL| T1   |   250K|  5371K|  1022   (2)| 00:00:13 |
 437: ---------------------------------------------------------------------------
 438: Predicate Information (identified by operation id):
 439: ---------------------------------------------------
 440:    1 - access("T1"."COL1"="T2"."COL1")
 441:    2 - filter("T2"."COL1">=1 AND "T2"."COL1"<=250000)
 442:    3 - filter("T1"."COL1"<=250000 AND "T1"."COL1">=1)
 443:  
 444: SQL> spool off;

If you check the explain plans of the queries, you find some interesting case where it went for merge join – instead of nested loops and hash join.


Please find the plan below reference



   1: SQL> SELECT
   2:   2    T1.COL1,
   3:   3    T1.COL2,
   4:   4    T1.COL3,
   5:   5    T2.COL1,
   6:   6    T2.COL2,
   7:   7    T2.COL3
   8:   8  FROM
   9:   9    T1,
  10:  10    T2
  11:  11  WHERE
  12:  12    T1.COL1=T2.COL1
  13:  13    AND T2.COL1 between 1 and 125000;
  14:  
  15: Execution Plan
  16: ----------------------------------------------------------
  17: Plan hash value: 2242062804
  18:  
  19: ---------------------------------------------------------------------------------------------
  20: | Id  | Operation                    | Name         | Rows  | Bytes | Cost (%CPU)| Time     |
  21: ---------------------------------------------------------------------------------------------
  22: |   0 | SELECT STATEMENT             |              |  1000 | 43000 |   709   (1)| 00:00:09 |
  23: |   1 |  MERGE JOIN                  |              |  1000 | 43000 |   709   (1)| 00:00:09 |
  24: |   2 |   TABLE ACCESS BY INDEX ROWID| T1           |   125K|  2685K|   705   (1)| 00:00:09 |
  25: |*  3 |    INDEX RANGE SCAN          | SYS_C0011233 |   125K|       |   238   (1)| 00:00:03 |
  26: |*  4 |   SORT JOIN                  |              |  1000 | 21000 |     4  (25)| 00:00:01 |
  27: |*  5 |    TABLE ACCESS FULL         | T2           |  1000 | 21000 |     3   (0)| 00:00:01 |
  28: ---------------------------------------------------------------------------------------------
  29: Predicate Information (identified by operation id):
  30: ---------------------------------------------------
  31:    3 - access("T1"."COL1">=1 AND "T1"."COL1"<=125000)
  32:    4 - access("T1"."COL1"="T2"."COL1")
  33:        filter("T1"."COL1"="T2"."COL1")
  34:    5 - filter("T2"."COL1">=1 AND "T2"."COL1"<=125000)

As per my knowledge it depends on the percentage of the data which we fetch from out of total volume that drives the things. when we go for the cases where some tables have less data compared across higher volumes of data.  Let’s me test for other sorts of test cases further how optimizer goes…

0 comments:

 
© 2013 Oracle Internals from basics to advanced....