cr13324309138
cr13324309138

一次DBA_FREE_SPACE的优化

sql文本：


  1. SELECT TABLESPACE_NAME,
  2.          FILE_ID,
  3.          COUNT (*) EXTENT_COUNT,
  4.          MIN (BYTES) BYTES_MIN,
  5.          MAX (BYTES) BYTES_MAX,
  6.          ROUND (AVG (BYTES)) BYTES_AVG,
  7.          SUM (BYTES) BYTES
  8.     FROM DBA_FREE_SPACE
  9. GROUP BY TABLESPACE_NAME, FILE_ID;

执行计划：

| Id  | Operation                         | Name             | Starts | E-Rows |E-Bytes| Cost (%CPU)| A-Rows |   A-Time   | Buffers |
-------------------------------------------------------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT                  |                  |      1 |        |       |   319M(100)|   5404 |00:29:22.37 |      81M|
|   1 |  HASH GROUP BY                    |                  |      1 |   5404 |   121K|   319M  (1)|   5404 |00:29:22.37 |      81M|
|   2 |   VIEW                            | DBA_FREE_SPACE   |      1 |    294M|  6457M|   319M  (1)|   1985K|00:29:16.96 |      81M|
|   3 |    UNION-ALL                      |                  |      1 |        |       |            |   1985K|00:29:15.81 |      81M|
|   4 |     NESTED LOOPS                  |                  |      1 |      1 |    66 |     4   (0)|      0 |00:00:00.01 |      30 |
|   5 |      NESTED LOOPS                 |                  |      1 |      1 |    48 |     3   (0)|      0 |00:00:00.01 |      30 |
|   6 |       TABLE ACCESS FULL           | FET$             |      1 |      1 |    39 |     3   (0)|      0 |00:00:00.01 |      30 |
|   7 |       TABLE ACCESS BY INDEX ROWID | FILE$            |      0 |      1 |     9 |     0   (0)|      0 |00:00:00.01 |       0 |
|*  8 |        INDEX UNIQUE SCAN          | I_FILE2          |      0 |      1 |       |     0   (0)|      0 |00:00:00.01 |       0 |
|*  9 |      TABLE ACCESS CLUSTER         | TS$              |      0 |      1 |    18 |     1   (0)|      0 |00:00:00.01 |       0 |
|  10 |     NESTED LOOPS                  |                  |      1 |    520 | 37440 |   145   (0)|    677K|00:09:47.75 |      27M|
|  11 |      NESTED LOOPS                 |                  |      1 |    520 | 32760 |     3   (0)|    677K|00:00:07.85 |     110K|
|* 12 |       TABLE ACCESS FULL           | TS$              |      1 |     26 |   624 |     3   (0)|     26 |00:00:00.01 |      30 |
|* 13 |       FIXED TABLE FIXED INDEX     | X$KTFBFE (ind:1) |     26 |     20 |   780 |     0   (0)|    677K|00:00:07.55 |     110K|
|* 14 |      TABLE ACCESS FULL            | FILE$            |    677K|      1 |     9 |     0   (0)|    677K|00:09:38.88 |      27M|
|  15 |     NESTED LOOPS                  |                  |      1 |    294M|    37G|   319M  (1)|   1307K|00:19:24.13 |      53M|
|  16 |      NESTED LOOPS                 |                  |      1 |   1177M|   140G|   147K(100)|   1307K|00:00:55.39 |   84980 |
|  17 |       MERGE JOIN                  |                  |      1 |  11777 |   724K|     4  (25)|  13085 |00:00:00.20 |     639 |
|  18 |        TABLE ACCESS BY INDEX ROWID| RECYCLEBIN$      |      1 |  13085 |   498K|     0   (0)|  13085 |00:00:00.08 |     609 |
|  19 |         INDEX FULL SCAN           | RECYCLEBIN$_TS   |      1 |      1 |       |     0   (0)|  13085 |00:00:00.03 |     157 |
|* 20 |        SORT JOIN                  |                  |  13085 |      4 |    96 |     4  (25)|  13085 |00:00:00.09 |      30 |
|* 21 |         TABLE ACCESS FULL         | TS$              |      1 |      4 |    96 |     3   (0)|     26 |00:00:00.01 |      30 |
|* 22 |       FIXED TABLE FIXED INDEX     | X$KTFBUE (ind:1) |  13085 |    100K|  6347K|    13 (100)|   1307K|00:00:54.54 |   84341 |
|* 23 |      TABLE ACCESS FULL            | FILE$            |   1307K|      1 |     9 |     0   (0)|   1307K|00:18:26.77 |      53M|
|  24 |     NESTED LOOPS                  |                  |      1 |      1 |   118 |     7   (0)|      0 |00:00:01.09 |     343K|
|  25 |      NESTED LOOPS                 |                  |      1 |      1 |   100 |     6   (0)|      0 |00:00:01.09 |     343K|
|  26 |       NESTED LOOPS                |                  |      1 |      1 |    61 |     6   (0)|      0 |00:00:01.09 |     343K|
|  27 |        TABLE ACCESS FULL          | FILE$            |      1 |      4 |    36 |     2   (0)|   5717 |00:00:00.01 |      41 |
|  28 |        TABLE ACCESS CLUSTER       | UET$             |   5717 |      1 |    52 |     1   (0)|      0 |00:00:01.08 |     343K|
|* 29 |         INDEX RANGE SCAN          | I_FILE#_BLOCK#   |   5717 |      1 |       |     1   (0)|    334K|00:00:00.22 |    9633 |
|* 30 |       TABLE ACCESS BY INDEX ROWID | RECYCLEBIN$      |      0 |  13085 |   498K|     0   (0)|      0 |00:00:00.01 |       0 |
|* 31 |        INDEX RANGE SCAN           | RECYCLEBIN$_TS   |      0 |      1 |       |     0   (0)|      0 |00:00:00.01 |       0 |
|* 32 |      TABLE ACCESS CLUSTER         | TS$              |      0 |      1 |    18 |     1   (0)|      0 |00:00:00.01 |       0 |
|* 33 |       INDEX UNIQUE SCAN           | I_TS#            |      0 |      1 |       |     0   (0)|      0 |00:00:00.01 |       0 |
-------------------------------------------------------------------------------------------------------------------------------------
Query Block Name / Object Alias (identified by operation id):
-------------------------------------------------------------
   1 - SEL$1
   2 - SET$1 / DBA_FREE_SPACE@SEL$1
   3 - SET$1
   4 - SEL$2
   6 - SEL$2 / F@SEL$2
   7 - SEL$2 / FI@SEL$2
   8 - SEL$2 / FI@SEL$2
   9 - SEL$2 / TS@SEL$2
  10 - SEL$3
  12 - SEL$3 / TS@SEL$3
  13 - SEL$3 / F@SEL$3
  14 - SEL$3 / FI@SEL$3
  15 - SEL$4
  18 - SEL$4 / RB@SEL$4
  19 - SEL$4 / RB@SEL$4
  21 - SEL$4 / TS@SEL$4
  22 - SEL$4 / U@SEL$4
  23 - SEL$4 / FI@SEL$4
  24 - SEL$5
  27 - SEL$5 / FI@SEL$5
  28 - SEL$5 / U@SEL$5
  29 - SEL$5 / U@SEL$5
  30 - SEL$5 / RB@SEL$5
  31 - SEL$5 / RB@SEL$5
  32 - SEL$5 / TS@SEL$5
  33 - SEL$5 / TS@SEL$5
Outline Data
-------------
  /*+
      BEGIN_OUTLINE_DATA
      IGNORE_OPTIM_EMBEDDED_HINTS
      OPTIMIZER_FEATURES_ENABLE('11.2.0.3')
      DB_VERSION('11.2.0.3')
      ALL_ROWS
      OUTLINE_LEAF(@"SEL$2")
      OUTLINE_LEAF(@"SEL$3")
      OUTLINE_LEAF(@"SEL$4")
      OUTLINE_LEAF(@"SEL$5")
      OUTLINE_LEAF(@"SET$1")
      OUTLINE_LEAF(@"SEL$1")
      NO_ACCESS(@"SEL$1" "DBA_FREE_SPACE"@"SEL$1")
      USE_HASH_AGGREGATION(@"SEL$1")
      FULL(@"SEL$5" "FI"@"SEL$5")
      INDEX_RS_ASC(@"SEL$5" "U"@"SEL$5" "I_FILE#_BLOCK#")
      INDEX_RS_ASC(@"SEL$5" "RB"@"SEL$5" ("RECYCLEBIN$"."TS#"))
      INDEX(@"SEL$5" "TS"@"SEL$5" "I_TS#")
      LEADING(@"SEL$5" "FI"@"SEL$5" "U"@"SEL$5" "RB"@"SEL$5" "TS"@"SEL$5")
      USE_NL(@"SEL$5" "U"@"SEL$5")
      USE_NL(@"SEL$5" "RB"@"SEL$5")
      USE_NL(@"SEL$5" "TS"@"SEL$5")
      INDEX(@"SEL$4" "RB"@"SEL$4" ("RECYCLEBIN$"."TS#"))
      FULL(@"SEL$4" "TS"@"SEL$4")
      FULL(@"SEL$4" "U"@"SEL$4")
      FULL(@"SEL$4" "FI"@"SEL$4")
      LEADING(@"SEL$4" "RB"@"SEL$4" "TS"@"SEL$4" "U"@"SEL$4" "FI"@"SEL$4")
      USE_MERGE(@"SEL$4" "TS"@"SEL$4")
      USE_NL(@"SEL$4" "U"@"SEL$4")
      USE_NL(@"SEL$4" "FI"@"SEL$4")
      FULL(@"SEL$3" "TS"@"SEL$3")
      FULL(@"SEL$3" "F"@"SEL$3")
      FULL(@"SEL$3" "FI"@"SEL$3")
      LEADING(@"SEL$3" "TS"@"SEL$3" "F"@"SEL$3" "FI"@"SEL$3")
      USE_NL(@"SEL$3" "F"@"SEL$3")
      USE_NL(@"SEL$3" "FI"@"SEL$3")
      FULL(@"SEL$2" "F"@"SEL$2")
      INDEX_RS_ASC(@"SEL$2" "FI"@"SEL$2" ("FILE$"."TS#" "FILE$"."RELFILE#"))
      CLUSTER(@"SEL$2" "TS"@"SEL$2")
      LEADING(@"SEL$2" "F"@"SEL$2" "FI"@"SEL$2" "TS"@"SEL$2")
      USE_NL(@"SEL$2" "FI"@"SEL$2")
      USE_NL(@"SEL$2" "TS"@"SEL$2")
      END_OUTLINE_DATA
  */
Predicate Information (identified by operation id):
---------------------------------------------------
   8 - access("F"."TS#"="FI"."TS#" AND "F"."FILE#"="FI"."RELFILE#")
   9 - filter(("TS"."BITMAPPED"=0 AND "TS"."TS#"="F"."TS#"))
  12 - filter(("TS"."CONTENTS$"=0 AND "TS"."BITMAPPED"<>0 AND INTERNAL_FUNCTION("TS"."ONLINE$")))
  13 - filter("TS"."TS#"="F"."KTFBFETSN")
  14 - filter(("F"."KTFBFETSN"="FI"."TS#" AND "F"."KTFBFEFNO"="FI"."RELFILE#"))
  20 - access("TS"."TS#"="RB"."TS#")
       filter("TS"."TS#"="RB"."TS#")
  21 - filter(("TS"."CONTENTS$"=0 AND "TS"."BITMAPPED"<>0 AND INTERNAL_FUNCTION("TS"."ONLINE$")))
  22 - filter(("U"."KTFBUESEGTSN"="RB"."TS#" AND "U"."KTFBUESEGFNO"="RB"."FILE#" AND "U"."KTFBUESEGBNO"="RB"."BLOCK#"))
  23 - filter(("RB"."TS#"="FI"."TS#" AND "U"."KTFBUEFNO"="FI"."RELFILE#"))
  29 - access("U"."TS#"="FI"."TS#" AND "U"."SEGFILE#"="FI"."RELFILE#")
  30 - filter(("U"."SEGFILE#"="RB"."FILE#" AND "U"."SEGBLOCK#"="RB"."BLOCK#"))
  31 - access("U"."TS#"="RB"."TS#")
  32 - filter("TS"."BITMAPPED"=0)
  33 - access("TS"."TS#"="U"."TS#")
Column Projection Information (identified by operation id):
-----------------------------------------------------------
   1 - "TABLESPACE_NAME"[VARCHAR2,30], "FILE_ID"[NUMBER,22], COUNT("BYTES")[22], COUNT(*)[22], SUM("BYTES")[22], MAX("BYTES")[22], MIN("BYTES")[22]
   2 - "TABLESPACE_NAME"[VARCHAR2,30], "FILE_ID"[NUMBER,22], "BYTES"[NUMBER,22]
   3 - STRDEF[30], STRDEF[22], STRDEF[22]
   4 - "F"."LENGTH"[NUMBER,22], "FI"."FILE#"[NUMBER,22], "TS"."NAME"[VARCHAR2,30], "TS"."BLOCKSIZE"[NUMBER,22]
   5 - "F".ROWID[ROWID,10], "F"."TS#"[NUMBER,22], "F"."LENGTH"[NUMBER,22], "FI"."FILE#"[NUMBER,22]
   6 - "F".ROWID[ROWID,10], "F"."TS#"[NUMBER,22], "F"."FILE#"[NUMBER,22], "F"."LENGTH"[NUMBER,22]
   7 - "FI"."FILE#"[NUMBER,22]
   8 - "FI".ROWID[ROWID,10]
   9 - "TS"."TS#"[NUMBER,22], "TS"."NAME"[VARCHAR2,30], "TS"."BLOCKSIZE"[NUMBER,22], "TS"."BITMAPPED"[NUMBER,22]
  10 - "TS"."NAME"[VARCHAR2,30], "TS"."BLOCKSIZE"[NUMBER,22], "F"."KTFBFEBLKS"[NUMBER,22], "FI"."FILE#"[NUMBER,22]
  11 - "TS"."NAME"[VARCHAR2,30], "TS"."BLOCKSIZE"[NUMBER,22], "F"."KTFBFETSN"[NUMBER,22], "F"."KTFBFEFNO"[NUMBER,22], "F"."KTFBFEBLKS"[NUMBER,22]
  12 - "TS"."TS#"[NUMBER,22], "TS"."NAME"[VARCHAR2,30], "TS"."BLOCKSIZE"[NUMBER,22]
  13 - "F"."KTFBFETSN"[NUMBER,22], "F"."KTFBFEFNO"[NUMBER,22], "F"."KTFBFEBLKS"[NUMBER,22]
  14 - "FI"."FILE#"[NUMBER,22]
  15 - "TS"."NAME"[VARCHAR2,30], "TS"."BLOCKSIZE"[NUMBER,22], "U"."KTFBUEBLKS"[NUMBER,22], "FI"."FILE#"[NUMBER,22]
  16 - "RB"."TS#"[NUMBER,22], "TS"."NAME"[VARCHAR2,30], "TS"."BLOCKSIZE"[NUMBER,22], "U"."KTFBUEFNO"[NUMBER,22], "U"."KTFBUEBLKS"[NUMBER,22]
  17 - "RB"."TS#"[NUMBER,22], "RB"."BLOCK#"[NUMBER,22], "RB"."FILE#"[NUMBER,22], "TS"."NAME"[VARCHAR2,30], "TS"."BLOCKSIZE"[NUMBER,22]
  18 - "RB"."TS#"[NUMBER,22], "RB"."FILE#"[NUMBER,22], "RB"."BLOCK#"[NUMBER,22]
  19 - "RB".ROWID[ROWID,10], "RB"."TS#"[NUMBER,22]
  20 - (#keys=1) "TS"."TS#"[NUMBER,22], "TS"."NAME"[VARCHAR2,30], "TS"."BLOCKSIZE"[NUMBER,22]
  21 - "TS"."TS#"[NUMBER,22], "TS"."NAME"[VARCHAR2,30], "TS"."BLOCKSIZE"[NUMBER,22]
  22 - "U"."KTFBUESEGTSN"[NUMBER,22], "U"."KTFBUESEGFNO"[NUMBER,22], "U"."KTFBUESEGBNO"[NUMBER,22], "U"."KTFBUEFNO"[NUMBER,22], "U"."KTFBUEBLKS"[NUMBER,22]
  23 - "FI"."FILE#"[NUMBER,22]
  24 - "FI"."FILE#"[NUMBER,22], "U"."LENGTH"[NUMBER,22], "TS"."NAME"[VARCHAR2,30], "TS"."BLOCKSIZE"[NUMBER,22]
  25 - "FI"."FILE#"[NUMBER,22], "U"."TS#"[NUMBER,22], "U"."LENGTH"[NUMBER,22]
  26 - "FI"."FILE#"[NUMBER,22], "U"."TS#"[NUMBER,22], "U"."SEGFILE#"[NUMBER,22], "U"."SEGBLOCK#"[NUMBER,22], "U"."LENGTH"[NUMBER,22]
  27 - "FI"."FILE#"[NUMBER,22], "FI"."TS#"[NUMBER,22], "FI"."RELFILE#"[NUMBER,22]
  28 - "U".ROWID[ROWID,10], "U"."TS#"[NUMBER,22], "U"."SEGFILE#"[NUMBER,22], "U"."SEGBLOCK#"[NUMBER,22], "U"."LENGTH"[NUMBER,22]
  29 - "U".ROWID[ROWID,10]
  31 - "RB".ROWID[ROWID,10]
  32 - "TS".ROWID[ROWID,10], "TS"."TS#"[NUMBER,22], "TS"."NAME"[VARCHAR2,30], "TS"."BLOCKSIZE"[NUMBER,22], "TS"."BITMAPPED"[NUMBER,22]
  33 - "TS".ROWID[ROWID,10]
Note
-----
   - cardinality feedback used for this statement

cardinalit y feedback特性作用在了该sql上，但是这个对此sql影响并不大。


问题分析：

通过A-TIME可以发现时间消耗主要在以下步骤：
| Id  | Operation                         | Name             | Starts | E-Rows |E-Bytes| Cost (%CPU)| A-Rows |   A-Time   | Buffers |
-------------------------------------------------------------------------------------------------------------------------------------
|  10 |     NESTED LOOPS                  |                  |      1 |    520 | 37440 |   145   (0)|    677K|00:09:47.75 |      27M|

|  11 |      NESTED LOOPS                 |                  |      1 |    520 | 32760 |     3   (0)|    677K|00:00:07.85 |     110K|
|* 12 |       TABLE ACCESS FULL           | TS$              |      1 |     26 |   624 |     3   (0)|     26 |00:00:00.01 |      30 |
|* 13 |       FIXED TABLE FIXED INDEX     | X$KTFBFE (ind:1) |     26 |     20 |   780 |     0   (0)|    677K|00:00:07.55 |     110K|
|* 14 |      TABLE ACCESS FULL            | FILE$            |    677K|      1 |     9 |     0   (0)|    677K|00:09:38.88 |      27M|
|  15 |     NESTED LOOPS                  |                  |      1 |    294M|    37G|   319M  (1)|   1307K|00:19:24.13 |      53M|
|  16 |      NESTED LOOPS                 |                  |      1 |   1177M|   140G|   147K(100)|   1307K|00:00:55.39 |   84980 |
|  17 |       MERGE JOIN                  |                  |      1 |  11777 |   724K|     4  (25)|  13085 |00:00:00.20 |     639 |
|  18 |        TABLE ACCESS BY INDEX ROWID| RECYCLEBIN$      |      1 |  13085 |   498K|     0   (0)|  13085 |00:00:00.08 |     609 |
|  19 |         INDEX FULL SCAN           | RECYCLEBIN$_TS   |      1 |      1 |       |     0   (0)|  13085 |00:00:00.03 |     157 |
|* 20 |        SORT JOIN                  |                  |  13085 |      4 |    96 |     4  (25)|  13085 |00:00:00.09 |      30 |
|* 21 |         TABLE ACCESS FULL         | TS$              |      1 |      4 |    96 |     3   (0)|     26 |00:00:00.01 |      30 |
|* 22 |       FIXED TABLE FIXED INDEX     | X$KTFBUE (ind:1) |  13085 |    100K|  6347K|    13 (100)|   1307K|00:00:54.54 |   84341 |
|* 23 |      TABLE ACCESS FULL            | FILE$            |   1307K|      1 |     9 |     0   (0)|   1307K|00:18:26.77 |      53M|

 很容易看到性能差的原因就是由于 NESTED LOOPS的关系，对FILE$分别全表扫描了 677K次和 1307K次 ，分别消耗了9分38秒和18分26秒。这里注意E-Rows，CBO的基数评估为1177 M 比A-rows还要多，为何还会选择 NESTED LOOPS的连接方式呢？
  • 1.谓词关联不是等号，不能选择HASH JOIN
  • 2.使用了use_nl的hint

验证：
 23 - filter(("RB"."TS#"="FI"."TS#" AND "U"."KTFBUEFNO"="FI"."RELFILE#")) --第一种可能排除
DBA_FREE_SPACE的视图定义：
  1. SELECT ts.name,
  2.        fi.file#,
  3.        f.block#,
  4.        f.LENGTH * ts.blocksize,
  5.        f.LENGTH,
  6.        f.file#
  7.   FROM sys.ts$ ts, sys.fet$ f, sys.file$ fi
  8.  WHERE ts.ts# = f.ts#
  9.        AND f.ts# = fi.ts#
  10.        AND f.file# = fi.relfile#
  11.        AND ts.bitmapped = 0
  12. UNION ALL
  13. SELECT /*+ ordered use_nl(f) use_nl(fi) */
  14.       ts.name,
  15.        fi.file#,
  16.        f.ktfbfebno,
  17.        f.ktfbfeblks * ts.blocksize,
  18.        f.ktfbfeblks,
  19.        f.ktfbfefno
  20.   FROM sys.ts$ ts, sys.x$ktfbfe f, sys.file$ fi
  21.  WHERE ts.ts# = f.ktfbfetsn
  22.        AND f.ktfbfetsn = fi.ts#
  23.        AND f.ktfbfefno = fi.relfile#
  24.        AND ts.bitmapped <> 0
  25.        AND ts.online$ IN (1, 4)
  26.        AND ts.contents$ = 0
  27. UNION ALL
  28. SELECT /*+ ordered use_nl(u) use_nl(fi) */
  29.       ts.name,
  30.        fi.file#,
  31.        u.ktfbuebno,
  32.        u.ktfbueblks * ts.blocksize,
  33.        u.ktfbueblks,
  34.        u.ktfbuefno
  35.   FROM sys.recyclebin$ rb,
  36.        sys.ts$ ts,
  37.        sys.x$ktfbue u,
  38.        sys.file$ fi
  39.  WHERE ts.ts# = rb.ts#
  40.        AND rb.ts# = fi.ts#
  41.        AND u.ktfbuefno = fi.relfile#
  42.        AND u.ktfbuesegtsn = rb.ts#
  43.        AND u.ktfbuesegfno = rb.file#
  44.        AND u.ktfbuesegbno = rb.block#
  45.        AND ts.bitmapped <> 0
  46.        AND ts.online$ IN (1, 4)
  47.        AND ts.contents$ = 0
  48. UNION ALL
  49. SELECT ts.name,
  50.        fi.file#,
  51.        u.block#,
  52.        u.LENGTH * ts.blocksize,
  53.        u.LENGTH,
  54.        u.file#
  55.   FROM sys.ts$ ts,
  56.        sys.uet$ u,
  57.        sys.file$ fi,
  58.        sys.recyclebin$ rb
  59.  WHERE ts.ts# = u.ts#
  60.        AND u.ts# = fi.ts#
  61.        AND u.segfile# = fi.relfile#
  62.        AND u.ts# = rb.ts#
  63.        AND u.segfile# = rb.file#
  64.        AND u.segblock# = rb.block#
  65.        AND ts.bitmapped = 0
果然是在视图内部使用了hint。但是当库比较大的时候EXTENT会比较多也就是sys.x$ktfbue和sys.x$ktfbue的记录数会非常多，此时选择USE_NL就是不合理的了。

优化：

sql改写：

  1. SELECT TABLESPACE_NAME,
  2.          FILE_ID,
  3.          COUNT (*) EXTENT_COUNT,
  4.          MIN (BYTES) BYTES_MIN,
  5.          MAX (BYTES) BYTES_MAX,
  6.          ROUND (AVG (BYTES)) BYTES_AVG,
  7.          SUM (BYTES) BYTES
  8.     FROM (SELECT ts.name TABLESPACE_NAME,
  9.                  fi.file# FILE_ID,
  10.                  f.block# BLOCK_ID,
  11.                  f.LENGTH * ts.blocksize BYTES,
  12.                  f.LENGTH BLOCKS,
  13.                  f.file# RELATIVE_FNO
  14.             FROM sys.ts$ ts, sys.fet$ f, sys.file$ fi
  15.            WHERE ts.ts# = f.ts#
  16.                  AND f.ts# = fi.ts#
  17.                  AND f.file# = fi.relfile#
  18.                  AND ts.bitmapped = 0
  19.           UNION ALL
  20.           SELECT /*+ opt_param('_optimizer_use_feedback' 'false') leading(ts f fi) use_nl(f) use_hash(fi) swap_join_inputs(fi) */
  21.                 ts.name,
  22.                  fi.file#,
  23.                  f.ktfbfebno,
  24.                  f.ktfbfeblks * ts.blocksize,
  25.                  f.ktfbfeblks,
  26.                  f.ktfbfefno
  27.             FROM sys.ts$ ts, sys.x$ktfbfe f, sys.file$ fi
  28.            WHERE ts.ts# = f.ktfbfetsn
  29.                  AND f.ktfbfetsn = fi.ts#
  30.                  AND f.ktfbfefno = fi.relfile#
  31.                  AND ts.bitmapped <> 0
  32.                  AND ts.online$ IN (1, 4)
  33.                  AND ts.contents$ = 0
  34.           UNION ALL
  35.           SELECT /*+ opt_param('_optimizer_use_feedback' 'false') leading(rb ts u fi) use_nl(ts) use_nl(u) use_hash(fi) swap_join_inputs(fi) */
  36.                 ts.name,
  37.                  fi.file#,
  38.                  u.ktfbuebno,
  39.                  u.ktfbueblks * ts.blocksize,
  40.                  u.ktfbueblks,
  41.                  u.ktfbuefno
  42.             FROM sys.recyclebin$ rb,
  43.                  sys.ts$ ts,
  44.                  sys.x$ktfbue u,
  45.                  sys.file$ fi
  46.            WHERE ts.ts# = rb.ts#
  47.                  AND rb.ts# = fi.ts#
  48.                  AND u.ktfbuefno = fi.relfile#
  49.                  AND u.ktfbuesegtsn = rb.ts#
  50.                  AND u.ktfbuesegfno = rb.file#
  51.                  AND u.ktfbuesegbno = rb.block#
  52.                  AND ts.bitmapped <> 0
  53.                  AND ts.online$ IN (1, 4)
  54.                  AND ts.contents$ = 0
  55.           UNION ALL
  56.           SELECT ts.name,
  57.                  fi.file#,
  58.                  u.block#,
  59.                  u.LENGTH * ts.blocksize,
  60.                  u.LENGTH,
  61.                  u.file#
  62.             FROM sys.ts$ ts,
  63.                  sys.uet$ u,
  64.                  sys.file$ fi,
  65.                  sys.recyclebin$ rb
  66.            WHERE ts.ts# = u.ts#
  67.                  AND u.ts# = fi.ts#
  68.                  AND u.segfile# = fi.relfile#
  69.                  AND u.ts# = rb.ts#
  70.                  AND u.segfile# = rb.file#
  71.                  AND u.segblock# = rb.block#
  72.                  AND ts.bitmapped = 0)
  73. GROUP BY TABLESPACE_NAME, FILE_ID;
这里为了得到更稳定的执行计划在sql级别禁用了_optimizer_use_feedback，并且改变了连接方式和连接顺序。

改写后的执行计划：

-----------------------------------------------------------------------------------------------------
| Id  | Operation                        | Name             | Rows  | Bytes | Cost (%CPU)| Time     |
-----------------------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT                 |                  |    12 |   276 |    33  (46)| 00:00:01 |
|   1 |  HASH GROUP BY                   |                  |    12 |   276 |    33  (46)| 00:00:01 |
|   2 |   VIEW                           |                  |    75 |  1725 |    32  (44)| 00:00:01 |
|   3 |    UNION-ALL                     |                  |       |       |            |          |
|   4 |     NESTED LOOPS                 |                  |     1 |    66 |     4   (0)| 00:00:01 |
|   5 |      NESTED LOOPS                |                  |     1 |    48 |     3   (0)| 00:00:01 |
|   6 |       TABLE ACCESS FULL          | FET$             |     1 |    39 |     3   (0)| 00:00:01 |
|   7 |       TABLE ACCESS BY INDEX ROWID| FILE$            |     1 |     9 |     0   (0)| 00:00:01 |
|*  8 |        INDEX UNIQUE SCAN         | I_FILE2          |     1 |       |     0   (0)| 00:00:01 |
|*  9 |      TABLE ACCESS CLUSTER        | TS$              |     1 |    18 |     1   (0)| 00:00:01 |
|* 10 |     HASH JOIN                    |                  |    72 |  5184 |     6  (17)| 00:00:01 |
|  11 |      TABLE ACCESS FULL           | FILE$            |     4 |    36 |     2   (0)| 00:00:01 |
|  12 |      NESTED LOOPS                |                  |    72 |  4536 |     3   (0)| 00:00:01 |
|* 13 |       TABLE ACCESS FULL          | TS$              |     4 |    96 |     3   (0)| 00:00:01 |
|* 14 |       FIXED TABLE FIXED INDEX    | X$KTFBFE (ind:1) |    20 |   780 |     0   (0)| 00:00:01 |
|* 15 |     HASH JOIN                    |                  |     1 |   137 |    18  (73)| 00:00:01 |
|  16 |      TABLE ACCESS FULL           | FILE$            |     4 |    36 |     2   (0)| 00:00:01 |
|  17 |      NESTED LOOPS                |                  |     1 |   128 |    16  (82)| 00:00:01 |
|  18 |       NESTED LOOPS               |                  |     1 |    63 |     3   (0)| 00:00:01 |
|  19 |        TABLE ACCESS FULL         | RECYCLEBIN$      |     1 |    39 |     2   (0)| 00:00:01 |
|* 20 |        TABLE ACCESS CLUSTER      | TS$              |     1 |    24 |     1   (0)| 00:00:01 |
|* 21 |         INDEX UNIQUE SCAN        | I_TS#            |     1 |       |     0   (0)| 00:00:01 |
|* 22 |       FIXED TABLE FIXED INDEX    | X$KTFBUE (ind:1) |   100K|  6347K|    13 (100)| 00:00:01 |
|  23 |     NESTED LOOPS                 |                  |     1 |   118 |     4   (0)| 00:00:01 |
|  24 |      NESTED LOOPS                |                  |     1 |   100 |     3   (0)| 00:00:01 |
|  25 |       NESTED LOOPS               |                  |     1 |    91 |     3   (0)| 00:00:01 |
|  26 |        TABLE ACCESS FULL         | RECYCLEBIN$      |     1 |    39 |     2   (0)| 00:00:01 |
|  27 |        TABLE ACCESS CLUSTER      | UET$             |     1 |    52 |     1   (0)| 00:00:01 |
|* 28 |         INDEX UNIQUE SCAN        | I_FILE#_BLOCK#   |     1 |       |     0   (0)| 00:00:01 |
|  29 |       TABLE ACCESS BY INDEX ROWID| FILE$            |     1 |     9 |     0   (0)| 00:00:01 |
|* 30 |        INDEX UNIQUE SCAN         | I_FILE2          |     1 |       |     0   (0)| 00:00:01 |
|* 31 |      TABLE ACCESS CLUSTER        | TS$              |     1 |    18 |     1   (0)| 00:00:01 |
|* 32 |       INDEX UNIQUE SCAN          | I_TS#            |     1 |       |     0   (0)| 00:00:01 |
-----------------------------------------------------------------------------------------------------


Elapsed: 00:01:00.96  --仅仅消耗了1分钟
Statistics
----------------------------------------------------------
      18987  recursive calls
     103412  db block gets
     144013  consistent gets
      13983  physical reads
          0  redo size
     236532  bytes sent via SQL*Net to client
       4484  bytes received via SQL*Net from client
        362  SQL*Net roundtrips to/from client
          0  sorts (memory)
          0  sorts (disk)
       5404  rows processed
逻辑读之前为 81M，现在只有144013


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

转载于:http://blog.itpub.net/31347199/viewspace-2121176/

你可能感兴趣的:(一次DBA_FREE_SPACE的优化)

  • 华为OD机试E卷 --增强的strstr--24年OD统一考试（Java & JS & Python & C & C++） 飞码创造者 最新华为OD机试题库2024华为odjavajavascriptpythonc语言
    文章目录题目描述输入描述输出描述用例题目解析JS算法源码Java算法源码python算法源码题目描述C语言有一个库函数:char*strstr(constchar*haystack,constchar*needle),实现在字符串haystack中查找第一次出现字符串needle的位置，如果未找到则返回null。现要求实现一个strstr的增强函数，可以使用带可选段的字符串来模糊查询，strstr
  • 分布式微服务系统架构第87集：kafka 掘金-我是哪吒 分布式微服务系统架构kafka架构
    Kafka就是为了解决上述问题而设计的一款基于发布与订阅的消息系统。它一般被称为“分布式提交日志”或者“分布式流平台”。文件系统或数据库提交日志用来提供所有事务的持久记录，通过重放这些日志可以重建系统的状态。同样地，Kafka的数据是按照一定顺序持久化保存的，可以按需读取。此外，Kafka的数据分布在整个系统里，具备数据故障保护和性能伸缩能力。消息和批次消息和批次Kafka的数据单元被称为消息。如
  • 使用 Python 指定内容 爬取百度引擎搜索结果 m0_74825614 python百度开发语言
    在本篇博客中，我将展示如何使用Python编写一个简单的百度搜索爬虫。这个爬虫可以自动化地从百度获取搜索结果，并提取每个结果的标题和链接。我们将使用requests库来发送HTTP请求，使用BeautifulSoup库来解析HTML内容。需求分析在实现爬虫之前，我们需要明确以下需求：通过构建百度搜索的URL来发送搜索请求。解析百度搜索结果页面，提取每个结果的标题和链接。将搜索结果以列表形式返回，方
  • skynet 源码阅读 -- 核心概念服务 skynet_context Winston-Tao skynet源码阅读skynet游戏开发C语言游戏服务器框架lua
    本文从Skynet源码层面深入解读服务（Service）的创建流程。从最基础的概念出发，逐步深入skynet_context_new函数、相关数据结构（skynet_context,skynet_module,message_queue等），并通过流程图、结构图、以及源码片段的细节分析，希望能对Skynet服务的创建有一个由浅入深的系统认识。1.前言在Skynet中，“服务（Service）”是最
  • 安卓动态设置Unity图形API Jack Yan Unity进阶androidunity游戏引擎
    命令行方式Unity图像api设置为自动，安卓动态设置Vulkan、OpenGLESUnity设置安卓设置创建自定义活动并将其设置为应用程序入口点。在自定义活动中，覆盖字符串UnityPlayerActivity。updateunitycommandlineararguments（StringcmdLine）方法。在该方法中，将cmdLine参数与您自己的启动参数连接起来，然后返回结果。重要：cm
  • CTF学记之云影密码 Z时代.bug(゜▽゜*) CTF密码学
    2023.10.22表现形式1，2，4，8这四个数字，可以通过加法来表示0-9中的任何一个数字。之后再用1-26来表示26个英文字母，就有了密文与明文之间的对应关系。引入0来作为间隔，以免出现混乱。所以云影密码又叫“01248密码”。示例1：1A28J1288S2B128K488T12C48L1488U4D148M2488V14E248N12488W24F1248O888X124G88P1888Y
  • Effective C++ 规则42：了解typename的用法 哎呦，帅小伙哦 C++c++
    1、typename的用途typename是一个上下文敏感的关键字，用来告诉编译器某个嵌套类型名是一个类型，而不是变量或其他实体。它有两种主要使用的场景。1.1、在模板定义中声明嵌套类型当在模板中访问嵌套类型（比如类型别名或类型定义），如果该类型是依赖于模板参数的，就必须使用typename。如果不使用typename会导致编译错误，下面是代码示例：templateclassContainer{p
  • stm32内存溢出怎么办 嵌入式小强工作室 stm32java嵌入式硬件
    STM32内存溢出是一个常见的问题，可能由多种原因引起，如数组定义过大、函数调用层级过深、堆栈空间不足等。针对这个问题，可以采取以下几种解决方法：一、增加堆栈大小堆栈溢出通常是由于堆栈空间不足以容纳函数调用和局部变量的信息。因此，增加堆栈大小是一种有效的解决方法。在STM32的工程中，可以通过修改链接脚本文件（.ld文件）中的堆栈大小参数来增加堆栈空间。通常，堆栈大小设置为RAM的一小部分，但需要
  • android14的下拉栏定制 little six androidjava
    将android14的下拉栏进行修改，要求实现要实现这种效果1.修改tile的形状要将形状从之前的长方形改成圆形我们需要对他找到他生成tile的地方，他是通过diff--gita/src/com/android/systemui/qs/tileimpl/QSFactoryImpl.javab/src/com/android/systemui/qs/tileimpl/QSFactoryImpl.ja
  • python连接MYSQL数据库（连接MYSQL数据库报错解决方法） Oblinto 数据库学习数据库mysql
    一、连接前的准备（如果报错可以从以下几个方面检查一下）1.检查mysql服务查看mysql服务是否开启sudosystemctlstatusmysql若没开启，开启mysql服务sudosystemctlstartmysql2.检查mysql的3306端口查看3306端口是否打开netstat-an|grep3306若没打开，打开3306端口sudoufwallow3306/tcp3.修改配置文件
  • RabbitMQ-SpringBoot案例 -topic模式 毕竟尹稳健 RabbitMQSpringBootrabbitmqspringbootjava
    生产者工程1、RabbitTemplate配置类无,其实并不是没有，而是将配置类的方式换成了注解的。但实际上开发建议用配置类，注解也就图一乐。2、消息发送服务packagecom.sky.service.impl;importcom.sky.service.OrderService;importorg.springframework.amqp.rabbit.core.RabbitTemplate;
  • springboot实现webservice的发布和调用 梦星剑魂 springbootmvcjavaspring
    springboot使用cxf发布调用webservice发布webservicepom文件org.apache.cxfcxf-spring-boot-starter-jaxws3.2.5webservice接口packagecom.example.webservicedemo.fabu;importjavax.jws.WebMethod;importjavax.jws.WebParam;impo
  • SpringBoot WebService IDEA版本 客户端调用（postman调用） SmileDark SpringSpringBootWebServiceSpringBootWebServiceWebServicespringbootwspostman调用WebSericepostmanwebservice
    webservice是什么网上的解释很多，其实就是跨语言和操作系统的的远程调用技术。比如亚马逊，可以将自己的服务以webservice的服务形式暴露出来，我们就可以通过web调用这些，无论我们使用的语言是java还是c，这也是SOA应用一种表现形式。注意点讲在前面1.命名空间（nameSpase）.xsd文件targetNamespace==Endpoint的NAMESPACE_URI1.新建sp
  • github上的python代码怎么运行_使用 Python 在 GitHub 上运行你的博客 -Fun言 weixin_39946300
    使用Pelican创建博客，这是一个基于Python的平台，与GitHub配合的不错。GitHub是一个非常流行的用于源代码控制的Web服务，它使用Git同步本地文件和GitHub服务器上保留的副本，这样你就可以轻松地共享和备份你的工作。除了为代码仓库提供用户界面之外，GitHub还运允许用户直接从仓库发布网页。GitHub推荐的网站生成软件包是Jekll，是使用Ruby编写的。因为我是Pytho
  • java jdbc实验_实验七Java之Jdbc weixin_39969976 javajdbc实验
    实验七Jdbc编程1．实验目的(1)掌握通过JDBC方式操作数据库的基本步骤。(2)掌握增、删、改、查记录等的方法。(3)掌握查询记录以及遍历查询结果的方法。2．实验内容实验题1学生信息管理。创建student表，包含学生的学号、姓名、年龄信息。①根据学号，可以查询到学生的姓名和年龄；②给定学生的学号、姓名、年龄，在表中追加一行信息；③给定学生的学号，可以从表中删除该学生的信息；[基本要求]对上面
  • python execjs库_python3调用js的库之execjs 一盏Online pythonexecjs库
    针对现在大部分的网站都是使用js加密，js加载的，并不能直接抓取出来，这时候就不得不适用一些三方类库来执行js语句执行JS的类库：execjs，PyV8，selenium，node这里主要讲一下execjs，一个比较好用且容易上手的类库(支持py2，与py3)，支持JSruntime。(一)安装：pipinstallPyExecJSoreasy_installPyExecJS(二)运行时环境exe
  • Python 执行 javascript PyExecJS 模块 weixin_30376083 pythonjavascriptjsonViewUI
    PyExecJS安装pipinstallPyExecJSPyExecJS的基本使用:>>>importexecjs>>>execjs.eval("'redyellowblue'.split('')")['red','yellow','blue']>>>ctx=execjs.compile("""...functionadd(x,y){...returnx+y;...}...""")>>>ctx.c
  • C++深入学习string类成员函数（4）：字符串的操作 舞武零落 c++学习开发语言
    引言在c++中，std::string提供了许多字符串操作符函数，让我们能够秦松驾驭文本数据，而与此同时，非成员函数的重载更是为string类增添了别样的魅力，输入输出流的重载让我们像处理基本类型的数据一样方便地读取和输出字符串，连接操作符的重载使得字符串的拼接变得简洁直观。在这篇博客中，我们将一同深入剖析C++中string类的字符串操作符和非成员函数的重载，为大家在编程之旅中增添一份有力的武器
  • Transformer大模型实战 BART模型的架构 AI天才研究院 大数据AI人工智能AI大模型企业级应用开发实战AI大模型应用入门实战与进阶计算科学神经计算深度学习神经网络大数据人工智能大型语言模型AIAGILLMJavaPython架构设计AgentRPA
    Transformer大模型实战BART模型的架构作者：禅与计算机程序设计艺术/ZenandtheArtofComputerProgramming/TextGenWebUILLMTransformer大模型实战BART模型的架构1.背景介绍1.1问题的由来随着大规模预训练模型的兴起，如BERT、GPT系列等，研究人员发现基于Transformer架构的模型在自然语言处理任务上表现出了显著的优势。为
  • 【大模型应用开发 动手做AI Agent】Agent的各种记忆机制 AI天才研究院 AI大模型企业级应用开发实战大数据AI人工智能计算科学神经计算深度学习神经网络大数据人工智能大型语言模型AIAGILLMJavaPython架构设计AgentRPA
    1.背景介绍AIAgent的核心特点是能够自主地与环境进行交互，以实现某种目标。为了实现这一目标，Agent需要对环境进行感知和理解，并对其进行探索和利用。对于Agent来说，记忆是实现这些功能的关键。Agent的记忆可以分为两类：短期记忆和长期记忆。短期记忆用于存储暂时性的信息，而长期记忆用于存储永久性的信息。以下是Agent的各种记忆机制的详细解释。2.核心概念与联系Agent的记忆机制可以分
  • 团体程序设计天梯赛-练习集——L1-019 谁先倒 SY师弟 GPLT天梯赛算法c语言数据结构c++GPLTc#
    前言这道题15分，稍有难度，难度不大，题目很有意思，可以学会了出去装B，下面直接看题L1-019谁先倒划拳是古老中国酒文化的一个有趣的组成部分。酒桌上两人划拳的方法为：每人口中喊出一个数字，同时用手比划出一个数字。如果谁比划出的数字正好等于两人喊出的数字之和，谁就输了，输家罚一杯酒。两人同赢或两人同输则继续下一轮，直到唯一的赢家出现。下面给出甲、乙两人的酒量（最多能喝多少杯不倒）和划拳记录，请你判
  • 自动控制原理实验：解锁典型环节时域响应的奥秘 戒了9 人工智能网络算法课程设计
    实验背景与目的在自动控制原理的学习旅程中，实验环节犹如一把钥匙，为我们打开了通往深入理解和实际应用的大门。它不仅仅是理论知识的简单验证，更是将抽象概念转化为实际认知的关键桥梁。通过实验，我们能够在实践中探索自动控制的奥秘，将书本上的公式和原理与真实的系统行为联系起来，从而深化对知识的理解，提升解决实际问题的能力。本次实验聚焦于典型环节的时域响应，这是自动控制领域中至关重要的研究内容。典型环节作为构
  • 【面试】【详解】计算机网络（TCP 三次握手，四次挥手） 患得患失949 面试考题专栏（前后端）面试计算机网络tcp/ip
    一、计算机网络详解（一）计算机网络概述定义：计算机网络是通过传输介质将多台计算机连接起来，以实现数据通信和资源共享的系统。功能：(1)数据通信：实现不同设备之间的数据传输。(2)资源共享：硬件资源（如打印机）和软件资源（如数据库）共享。(3)分布式处理：多台计算机协作完成任务。（二）TCP三次握手1.定义TCP（三次握手）是建立可靠连接的重要步骤，确保双方准备好通信并初始化必要的参数。2.过程详解
  • 「QT」经验篇 之 界面代码与逻辑代码的分离思想 何曾参静谧 「QT」QT5程序设计qt系统架构数据库
    ✨博客主页何曾参静谧的博客（✅关注、点赞、⭐收藏、转发）全部专栏（专栏会有变化，以最新发布为准）「Win」Windows程序设计「IDE」集成开发环境「定制」定制开发集合「C/C++」C/C++程序设计「DSA」数据结构与算法「UG/NX」NX二次开发「QT」QT5程序设计「File」数据文件格式「UG/NX」BlockUI集合「Py」Python程序设计「Math」探秘数学世界「PK」Paras
  • 鸿蒙系统崛起：开发者的机遇、挑战与战略 飞起来fly呀 harmonyos华为鸿蒙系统
    随着科技的迅猛发展，鸿蒙操作系统以其独特的分布式架构和多设备协同能力，在全球操作系统市场中脱颖而出。它不仅与安卓和iOS形成了三足鼎立之势，还在智能手机、智能穿戴、车载系统以及智能家居等多个领域中获得了广泛应用。面对这一新兴生态系统，开发者如何抓住机遇，同时应对开发中的各种挑战，创造出更加卓越的应用体验？本文将围绕这些内容进行深度探讨。一、鸿蒙操作系统的技术特色与发展背景1.1鸿蒙系统的诞生与初衷
  • 技术文档的艺术：从知识传承到团队合作的实践指南 飞起来fly呀 编程开发语言程序人生
    在技术领域，文档不仅仅是文字的堆砌，它是知识的桥梁，是团队成员之间的信息纽带，更是掌握和传递技术精髓的重要工具。一份好的技术文档就像一份精确的航海图，使得技术团队能够在复杂的技术海洋中顺畅航行。然而，撰写出色的技术文档并不是一件简单的事情，尤其是对初学者来说。在本篇文章中，我将分享撰写技术文档的经验和最佳实践，从文档结构、内容组织、语言表达等多个方面进行详细探讨，帮助大家构建一份优秀的技术文档。一
  • 使用 Azure Functions 开发 Serverless 应用：详解与实战 孟章豪 azureserverlessflask
    使用AzureFunctions开发Serverless应用：详解与实战随着云计算的发展，Serverless（无服务器架构）已成为构建现代应用的重要模式。它能够让开发者专注于业务逻辑，而不需要关注底层的服务器管理、扩展等问题。AzureFunctions是微软提供的Serverless计算服务，具有高度的可扩展性和易用性。本篇博客将详细介绍如何使用AzureFunctions开发Serverle
  • 在Python中运行JavaScript代码（使用execjs模块） 飞起来fly呀 Pythonpython开发语言
    使用execjs模块可以在Python中运行JavaScript代码。以下是使用execjs模块的基本步骤：1.安装execjs模块:可以使用pip命令进行安装:pipinstall execjs2.导入execjs模块:import execjs3.使用compile方法可以将JavaScript代码编译为可执行的函数compiled_func = execjs.compile(code)#执行
  • rem适配布局Tips Sun_小杰杰哇 #JavaScript布局适配rem
    简介使用rem+以下函数+设计稿的尺寸就可以适配页面。(function(doc,win){vardocEl=doc.documentElement,resizeEvt='orientationchange'inwindow?'orientationchange':'resize',recalc=function(){varclientWidth=docEl.clientWidth;if(!cli
  • 清除redux数据（hooks写法） Sun_小杰杰哇 #Reactweb框架reduxreact清除web
    清除redux数据的场景A页面初始化调用A接口，希望在当前页面生效，跳转页面不保存数据，但redux中已经存有历史数据，所以在页面销毁时清除redux数据。A页面请求A接口useEffect(()=>{initData();},[orderCode]);constinitData=async()=>{setLoading(true);constaction=awaitActions.getData
  • 基本数据类型和引用类型的初始值 3213213333332132 java基础
    package com.array; /** * @Description 测试初始值 * @author FuJianyong * 2015-1-22上午10:31:53 */ public class ArrayTest { ArrayTest at; String str; byte bt; short s; int i; long
  • 摘抄笔记--《编写高质量代码：改善Java程序的151个建议》 白糖_ 高质量代码
            记得3年前刚到公司，同桌同事见我无事可做就借我看《编写高质量代码：改善Java程序的151个建议》这本书，当时看了几页没上心就没研究了。到上个月在公司偶然看到，于是乎又找来看看，我的天，真是非常多的干货，对于我这种静不下心的人真是帮助莫大呀。           看完整本书，也记了不少笔记
  • 【备忘】Django 常用命令及最佳实践 dongwei_6688 django
    注意：本文基于 Django 1.8.2 版本   生成数据库迁移脚本（python 脚本） python manage.py makemigrations polls  说明：polls 是你的应用名字，运行该命令时需要根据你的应用名字进行调整   查看该次迁移需要执行的 SQL 语句（只查看语句，并不应用到数据库上）： python manage.p
  • 阶乘算法之一N! 末尾有多少个零 周凡杨 java算法阶乘面试效率
                                     &n
  • spring注入servlet g21121 Spring注入
    传统的配置方法是无法将bean或属性直接注入到servlet中的，配置代理servlet亦比较麻烦，这里其实有比较简单的方法，其实就是在servlet的init()方法中加入要注入的内容： ServletContext application = getServletContext(); WebApplicationContext wac = WebApplicationContextUtil
  • Jenkins 命令行操作说明文档 510888780 centos
    假设Jenkins的URL为http://22.11.140.38:9080/jenkins/ 基本的格式为 java 基本的格式为 java -jar jenkins-cli.jar [-s JENKINS_URL] command [options][args] 下面具体介绍各个命令的作用及基本使用方法 1. &nb
  • UnicodeBlock检测中文用法 布衣凌宇 UnicodeBlock
    /**  * 判断输入的是汉字  */ public static boolean isChinese(char c) {        Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);    
  • java下实现调用oracle的存储过程和函数 aijuans javaorale
    1.创建表：STOCK_PRICES     2.插入测试数据：     3.建立一个返回游标：  PKG_PUB_UTILS   4.创建和存储过程：P_GET_PRICE     5.创建函数：   6.JAVA调用存储过程返回结果集 JDBCoracle10G_INVO
  • Velocity Toolbox antlove 模板toolboxvelocity
    velocity.VelocityUtil package velocity; import org.apache.velocity.Template; import org.apache.velocity.app.Velocity; import org.apache.velocity.app.VelocityEngine; import org.apache.velocity.c
  • JAVA正则表达式匹配基础 百合不是茶 java正则表达式的匹配
      正则表达式;提高程序的性能,简化代码,提高代码的可读性,简化对字符串的操作   正则表达式的用途; 字符串的匹配 字符串的分割 字符串的查找 字符串的替换       正则表达式的验证语法     [a] //[]表示这个字符只出现一次 ,[a] 表示a只出现一
  • 是否使用EL表达式的配置 bijian1013 jspweb.xmlELEasyTemplate
            今天在开发过程中发现一个细节问题，由于前端采用EasyTemplate模板方法实现数据展示，但老是不能正常显示出来。后来发现竟是EL将我的EasyTemplate的${...}解释执行了，导致我的模板不能正常展示后台数据。         网
  • 精通Oracle10编程SQL(1-3)PLSQL基础 bijian1013 oracle数据库plsql
    --只包含执行部分的PL/SQL块 --set serveroutput off begin dbms_output.put_line('Hello,everyone!'); end; select * from emp; --包含定义部分和执行部分的PL/SQL块 declare v_ename varchar2(5); begin select
  • 【Nginx三】Nginx作为反向代理服务器 bit1129 nginx
    Nginx一个常用的功能是作为代理服务器。代理服务器通常完成如下的功能：   接受客户端请求 将请求转发给被代理的服务器 从被代理的服务器获得响应结果 把响应结果返回给客户端 实例 本文把Nginx配置成一个简单的代理服务器 对于静态的html和图片，直接从Nginx获取 对于动态的页面，例如JSP或者Servlet，Nginx则将请求转发给Res
  • Plugin execution not covered by lifecycle configuration: org.apache.maven.plugin blackproof maven报错
    转：http://stackoverflow.com/questions/6352208/how-to-solve-plugin-execution-not-covered-by-lifecycle-configuration-for-sprin   maven报错： Plugin execution not covered by lifecycle configuration:
  • 发布docker程序到marathon ronin47 docker 发布应用
    1 发布docker程序到marathon 1.1 搭建私有docker registry 1.1.1 安装docker regisry docker pull docker-registry docker run -t -p 5000:5000 docker-registry 下载docker镜像并发布到私有registry docker pull consol/tomcat-8.0
  • java-57-用两个栈实现队列&&用两个队列实现一个栈 bylijinnan java
    import java.util.ArrayList; import java.util.List; import java.util.Stack; /* * Q 57 用两个栈实现队列 */ public class QueueImplementByTwoStacks { private Stack<Integer> stack1; pr
  • Nginx配置性能优化 cfyme nginx
    转载地址：http://blog.csdn.net/xifeijian/article/details/20956605   大多数的Nginx安装指南告诉你如下基础知识——通过apt-get安装，修改这里或那里的几行配置，好了，你已经有了一个Web服务器了。而且，在大多数情况下，一个常规安装的nginx对你的网站来说已经能很好地工作了。然而，如果你真的想挤压出Nginx的性能，你必
  • [JAVA图形图像]JAVA体系需要稳扎稳打,逐步推进图像图形处理技术 comsci java
         对图形图像进行精确处理，需要大量的数学工具，即使是从底层硬件模拟层开始设计，也离不开大量的数学工具包，因为我认为，JAVA语言体系在图形图像处理模块上面的研发工作，需要从开发一些基础的，类似实时数学函数构造器和解析器的软件包入手，而不是急于利用第三方代码工具来实现一个不严格的图形图像处理软件......   &nb
  • MonkeyRunner的使用 dai_lm androidMonkeyRunner
    要使用MonkeyRunner，就要学习使用Python，哎 先抄一段官方doc里的代码 作用是启动一个程序（应该是启动程序默认的Activity），然后按MENU键，并截屏 # Imports the monkeyrunner modules used by this program from com.android.monkeyrunner import MonkeyRun
  • Hadoop-- 海量文件的分布式计算处理方案 datamachine mapreducehadoop分布式计算
    csdn的一个关于hadoop的分布式处理方案，存档。 原帖：http://blog.csdn.net/calvinxiu/article/details/1506112。     Hadoop 是Google MapReduce的一个Java实现。MapReduce是一种简化的分布式编程模式，让程序自动分布到一个由普通机器组成的超大集群上并发执行。就如同ja
  • 以資料庫驗證登入 dcj3sjt126com yii
    以資料庫驗證登入 由於 Yii 內定的原始框架程式, 採用綁定在UserIdentity.php 的 demo 與 admin 帳號密碼:    public function authenticate()    {        $users=array( &nbs
  • github做webhooks：[2]php版本自动触发更新 dcj3sjt126com githubgitwebhooks
    上次已经说过了如何在github控制面板做查看url的返回信息了。这次就到了直接贴钩子代码的时候了。 工具/原料 git github 方法/步骤   在github的setting里面的webhooks里把我们的url地址填进去。   钩子更新的代码如下： error_reportin
  • Eos开发常用表达式 蕃薯耀 Eos开发Eos入门Eos开发常用表达式
    Eos开发常用表达式 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2014年8月18日 15:03:35 星期一     &
  • SpringSecurity3.X--SpEL 表达式 hanqunfeng SpringSecurity
    使用 Spring 表达式语言配置访问控制，要实现这一功能的直接方式是在<http>配置元素上添加 use-expressions 属性：   <http auto-config="true" use-expressions="true"> 这样就会在投票器中自动增加一个投票器：org.springframework
  • Redis vs Memcache IXHONG redis
    1. Redis中，并不是所有的数据都一直存储在内存中的，这是和Memcached相比一个最大的区别。 2. Redis不仅仅支持简单的k/v类型的数据，同时还提供list，set，hash等数据结构的存储。 3. Redis支持数据的备份，即master-slave模式的数据备份。 4. Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。 Red
  • Python - 装饰器使用过程中的误区解读 kvhur JavaScriptjqueryhtml5css
    大家都知道装饰器是一个很著名的设计模式，经常被用于AOP(面向切面编程)的场景，较为经典的有插入日志，性能测试，事务处理，Web权限校验， Cache等。 原文链接：http://www.gbtags.com/gb/share/5563.htm Python语言本身提供了装饰器语法（@），典型的装饰器实现如下：   @function_wrapper de
  • 架构师之mybatis-----update 带case when 针对多种情况更新 nannan408 case when
    1.前言.    如题. 2. 代码.   <update id="batchUpdate" parameterType="java.util.List"> <foreach collection="list" item="list" index=&
  • Algorithm算法视频教程 栏目记者 Algorithm算法
    课程：Algorithm算法视频教程 百度网盘下载地址： http://pan.baidu.com/s/1qWFjjQW 密码: 2mji 程序写的好不好,还得看算法屌不屌！Algorithm算法博大精深。 一、课程内容： 课时1、算法的基本概念 + Sequential search 课时2、Binary search 课时3、Hash table 课时4、Algor
  • C语言算法之冒泡排序 qiufeihu c算法
    任意输入10个数字由小到大进行排序。 代码： #include <stdio.h> int main() { int i,j,t,a[11]; /*定义变量及数组为基本类型*/ for(i = 1;i < 11;i++){ scanf("%d",&a[i]); /*从键盘中输入10个数*/ } for
  • JSP异常处理 wyzuomumu Webjsp
    1.在可能发生异常的网页中通过指令将HTTP请求转发给另一个专门处理异常的网页中: <%@ page errorPage="errors.jsp"%>   2.在处理异常的网页中做如下声明： errors.jsp: <%@ page isErrorPage="true"%>，这样设置完后就可以在网页中直接访问exc
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他