性能调优工具01–Sql Tuning Advisor工具的使用

Posted on 2014-06-01 by royalwzy

STA(Sql Tuning Advisor)工具的使用

STA工具其实就是DBMS_SQLTUNE包,要使用STA的话,必须是在CBO模式下使用;
执行DBMS_SQLTUNE包,需要有advisor角色权限;
DBMS_SQLTUNE包介绍:
1. DBMS_SQLTUNE.CREATE_TUNING_TASK(sql_text, bind_list, user_name, scope, time_limit, task_name, DESCRIPTION) RETURN VARCHAR2;
  1. sql_text:需要优化的sql语句;
  2. bind_list:绑定的变量列表,默认为NULL;
  3. user_name:要优化的sql语句通过哪个用户执行,默认为NULL;
  4. scope:优化范围,有两个取值,limited-分析时不使用推荐的SQL Profile,大约每个语句1s时间;comprehensive-分析时使用推荐的SQL Profile,可能花费的时间较长,默认值;
  5. time_limit:优化过程的时间限制,默认为TIME_LIMIT_DEFAULT;
  6. task_name:优化任务的名称,默认为NULL;
  7. decription:描述信息,默认为NULL;
2. DBMS_SQLTUNE.EXECUTE_TUNING_TASK(task_name);
  1. task_name:要执行的优化任务的名称;
3. DBMS_SQLTUNE.REPORT_TUNING_TASK(task_name, type, level, section, object_id, result_limit);
  1. task_name:要查看的优化任务的名称;
  2. type:优化报告的类型,TEXT,HTML或者XML,默认是TEXT;
  3. level:格式化的级别,TYPICAL, BASIC, ALL.默认是TYPICAL;
  4. section:优化报告的部分,FINDING,PLAN,INFORMATION,ERROR或者ALL,默认是ALL;
  5. 调用方法:SELECT DBMS_SQLTUNE.REPORT_TUNING_TASK(‘task_name’) from dual;
4. DBMS_SQLTUNE.DROP_TUNING_TASK(task_name);
  1. task_name:要删除的优化任务的名称;
5. DBMS_SQLTUNE.RESET_TUNING_TASK(task_name):重置优化任务的结果;
  1. task_name:优化任务的名称;
  2. 执行过之后就可以重新执行EXECUTE_TUNING_TASK过程了;
一般的步骤:
1. 创建优化任务;
2. 执行优化任务;
3. 显示优化结果;
4. 根据建议来做相应的优化;
5. 删除优化任务;
创建测试用户:SQLTUNE;
创建测试表;
执行查询语句:SELECT COUNT(*) FROM bigtable a, smalltable b WHERE a.object_name = b.object_name;
1. 需要的时间;
2. 执行计划;
3. 统计信息;
创建优化任务;
执行优化任务,并查看优化任务的执行进度;
查询优化结果;
1. 关于这次优化任务的基本信息:如任务名称,执行时间,范围,涉及到的语句,发现问题的类型及个数的信息等等;
2. 发现的问题:两个表没有收集统计信息;
3. 发现的问题:两个表没有索引;
4. 按照优化建议修改前后的执行计划的对比;
按照建议做相应的修改,然后执行语句验证优化的结果;
删除优化任务:
如果需要对多条语句进行优化时,应该使用STS(Sql Tuning Set);
1. STS可以从多种数据源(Cursor Cache, AWR, STS)获取SQL;
2. 创建一个STS:DBMS_SQLTUNE.CREATE_SQLSET(sqlset_name => ‘sts_test’);
3. 使用Cursor Cache加载STS:DBMS_SQLTUNE.LOAD_SQLSET();
4. 查看STS的内容:SELECT * FROM TABLE(DBMS_SQLTUNE.SELECT_SQLSET(‘sts_test’));
5. 使用STS创建一个优化任务:DBMS_SQLTUNE.CREATE_TUNING_TASK(sqlset_name=>’sts_test’, task_name=>’sta_test’);
使用EM,在EM->Performance->Advisor Central->SQL Advisors->SQL Tuning Advisor;
单条sql的调优可以使用sqltrpt.sql(执行SQL>@?/rdbms/admin/sqltrpt.sql sqlid即可)脚本传入sqlid即可;对于多条sql语句可以使用dbmssqlt.sql脚本,这个脚本给出了dbms_sqltune包的定义和相关的例子;

— 创建测试用户SQLTUNE;

CREATE USER SQLTUNE IDENTIFIED BY “oracle”;
GRANT CONNECT, RESOURCE, ADVISOR TO SQLTUNE;
CONN SQLTUNE/ORACLE;

— 创建测试表;

CREATE TABLE bigtable AS SELECT rownum id, t.* FROM sys.all_objects t;
CREATE TABLE smalltable AS SELECT rownum id, t.* FROM sys.all_objects t;
INSERT INTO bigtable SELECT * FROM bigtable;
INSERT INTO bigtable SELECT * FROM bigtable;
INSERT INTO bigtable SELECT * FROM bigtable;
COMMIT;

— 创建优化任务;

DECLARE
my_task_name VARCHAR2(30);
my_sqltext CLOB;
BEGIN
my_sqltext := ‘SELECT COUNT(*) FROM bigtable a, smalltable b WHERE a.object_name = b.object_name’;
my_task_name := DBMS_SQLTUNE.CREATE_TUNING_TASK(sql_text => my_sqltext, user_name => ‘SQLTUNE’, task_name => ‘sta_test’);
END;

— 执行优化任务;

EXEC DBMS_SQLTUNE.EXECUTE_TUNING_TASK(‘sta_test’);

SELECT task_name,status FROM USER_ADVISOR_TASKS WHERE task_name =’sta_test’;

— 查看优化结果;

SELECT DBMS_SQLTUNE.REPORT_TUNING_TASK(‘sta_test’) from dual;

— 执行优化建议;

CREATE INDEX IDX_BIGTABLE_OBJECTNAME ON BIGTABLE(‘OBJECT_NAME’);
CREATE INDEX IDX_SMALLTABLE_OBJECTNAME ON SMALLTABLE(‘OBJECT_NAME’);
EXEC dbms_stats.gather_table_stats(USER, ‘BIGTABLE’, CASCADE=>TRUE);
EXEC dbms_stats.gather_table_stats(USER, ‘SMALLTABLE’, CASCADE=>TRUE);

— 删除优化任务;

EXEC DBMS_SQLTUNE.DROP_TUNING_TASK(‘sta_test’);

— 创建SQL Tuning Set创建优化任务;

— create a STS
BEGIN
dbms_sqltune.create_sqlset(sqlset_name => ‘my_sts’);
END;
/

— load STS using cursor cache
DECLARE
l_cur dbms_sqltune.sqlset_cursor;
BEGIN
OPEN l_cur FOR
SELECT VALUE(t)
FROM TABLE(dbms_sqltune.select_cursor_cache(‘sql_id in (”588rxmp05xt7g”,”7rucbfq8vcr7d”)’)) t;

dbms_sqltune.load_sqlset(sqlset_name => ‘sts_test’, populate_cursor => l_cur);
END;
/

— display contents of STS
SELECT * FROM TABLE(dbms_sqltune.select_sqlset(‘sts_test’));

— drop a sql tuning task
BEGIN
dbms_sqltune.drop_tuning_task(task_name => ‘my_sql_tuning_task’);
END;
/

— create a sql tuning task by using STS
DECLARE
l_task_name VARCHAR2(30);
l_sqltext CLOB;
BEGIN
l_task_name := dbms_sqltune.create_tuning_task(sqlset_name => ‘sts_test’, task_name => ‘my_sql_tuning_task’);

END;
/

调优实践02–ALTER SYSTEM/SESSION SET EVENTS转储

Posted on 2014-05-15 by royalwzy

ALTER SYSTEM/SESSION SET EVENTS

语法:alter system|session set events ‘[eventnumber|immediate] trace name eventname [forever] [, level levelnumber] : ……’; 通过[:]符号,可以连续设置多个事件,也可以通过连续使用alter session set events来设置多个事件;
参数说明:
1. eventnumber:指触发dump的事件号,事件号可以是Oracle错误号(出现相应错误时跟踪指定的事件)或oralce内部事件号(内部事件号在10000到10999之间),不能与immediate关键字同用;
2. immediate:关键字表示命令发出后,立即将指定的结构dump到跟踪文件中,这个关键字只用在alter session语句中,并且不能与eventnumber/forever关键字同用;
3. eventname:指事件名称,即要进行dump的实际结构名;若eventname为context,则指根据内部事件号进行跟踪;
4. forever:关键字表示事件在实例或会话的周期内保持有效状态,不能与immediate同用;
5. level:为事件级别关键字,但在dump错误栈(errorstack)时不存在级别;
6. levelnumber:表示事件级别号,一般从1到10,1表示只dump结构头部信息,10表示dump结构的所有信息;
常用的事件名称和级别:
1. Memory Dumps:
  1. Global Area:ALTER SESSION SET EVENTS ‘immediate trace name global_area level n’;
    1. 1 包含PGA
    2. 2 包含SGA
    3. 4 包含UGA
    4. 8 包含indrect memory
  2. Library Cache:ALTER SESSION SET EVENTS ‘immediate trace name library_cache level n’;
    1. 1 library cache统计信息
    2. 2 包含hash table histogram
    3. 3 包含object handle
    4. 4 包含object结构
  3. Row Cache:ALTER SESSION SET EVENTS ‘immediate trace name row_cache level n’;
    1. 1 row cache统计信息
    2. 2 包含hash table histogram
    3. 8 包含object结构
  4. Buffers:ALTER SESSION SET EVENTS ‘immediate trace name buffers level n’;
    1. 1 buffer header
    2. 2 level 1 + block header
    3. 3 level 2 + block contents
    4. 4 level 1 + hash chain
    5. 5 level 2 + hash chain
    6. 6 level 3 + hash chain
    7. 8 level 4 + users/waiters
    8. 9 level 5 + users/waiters
    9. 10 level 6 + users/waiters
  5. Buffer:ALTER SESSION SET EVENTS ‘immediate trace name buffer level n’;
    1. n为某个指定block的rdba,该命令可以转储某个block在buffer中的所有版本;
  6. Heap:ALTER SESSION SET EVENTS ‘immediate trace name heapdump level n’;
    1. 1 PGA摘要
    2. 2 SGA摘要
    3. 4 UGA摘要
    4. 8 Current call(CGA)摘要
    5. 16 User call(CGA)摘要
    6. 32 Large call(LGA)摘要
    7. 1025 PGA内容
    8. 2050 SGA内容
    9. 4100 UGA内容
    10. 8200 Current call内容
    11. 16400 User call内容
    12. 32800 Large call内容
  7. Sub Heap:
    1. ALTER SESSION SET EVENTS ‘immediate trace name heapdump_addr level n’;(oracle 9.0.1版本之前)
      1. 若n为subheap的地址，转储的是subheap的摘要信息
      2. 若n为subheap的地址+1，转储的则是subheap的内容
    2. ALTER SESSION SET EVENTS ‘immediate trace name heapdump_addr level n, addr m’;(oracle 9.2.0版本之后)
      1. 其中m为subheap的地址
      2. n为1转储subheap的摘要，n为2转储subheap的内容
  8. Process State:ALTER SESSION SET EVENTS ‘immediate trace name processstate level n’;
  9. System State:ALTER SESSION SET EVENTS ‘immediate trace name systemstate level n’;
  10. Error State:ALTER SESSION SET EVENTS ‘immediate trace name errorstack level n’;
    1. 0 Error stack
    2. 1 level 0 + function call stack
    3. 2 level 1 + process state
    4. 3 level 2 + context area
  11. Hang Analysis:ALTER SESSION SET EVENTS ‘immediate trace name hanganalyze level n’;
  12. Work Area:ALTER SESSION SET EVENTS ‘immediate trace name workareatab_dump level n’;
    1. 1 SGA信息
    2. 2 Workarea Table摘要信息
    3. 3 Workarea Table详细信息
  13. Latches:ALTER SESSION SET EVENTS ‘immediate trace name latches level n’;
    1. 1 latch信息
    2. 2 统计信息
  14. Events:ALTER SESSION SET EVENTS ‘immediate trace name events level n’;
    1. 1 session
    2. 2 process
    3. 3 system
  15. Locks:ALTER SESSION SET EVENTS ‘immediate trace name locks level n’;
  16. Shared Server Process:ALTER SESSION SET EVENTS ‘immediate trace name shared_server_state level n’;
    1. n取值为1~14
  17. Background Messages:ALTER SESSION SET EVENTS ‘immediate trace name bg_messages level n’;
    1. n为pid+1
2. File Dumps:
  1. Block:
    1. ALTER SESSION SET EVENTS ‘immediate trace name blockdump level n’;(oracle 7之前)
      1. n为block的rdba
    2. ALTER SYSTEM DUMP DATAFILE file# BLOCK block#;(oracle8以后)
    3. ALTER SYSTEM DUMP DATAFILE file# BLOCK MIN minimum_block# BLOCK MAX maximum_block#;
  2. Tree Dump:ALTER SESSION SET EVENTS ‘immediate trace name treedump level n’;
    1. n为object_id
  3. Undo Segment Header:ALTER SYSTEM DUMP UNDO_HEADER ‘segment_name’;
  4. Undo for a Transaction:ALTER SYSTEM DUMP UNDO BLOCK ‘segment_name’ XID xidusn xidslot xidsqn;
  5. File Header:ALTER SESSION SET EVENTS ‘immediate trace name file_hdrs level n’;
    1. 1 控制文件中的文件头信息
    2. 2 level 1 + 文件头信息
    3. 3 level 2 + 数据文件头信息
    4. 10 level 3
  6. Control file:ALTER SESSION SET EVENTS ‘immediate trace name controlf level n’;
    1. 1 文件头信息
    2. 2 level 1 + 数据库信息 + 检查点信息
    3. 3 level 2 + 可重用节信息
    4. 10 level 3
  7. Redo log Header:ALTER SESSION SET EVENTS ‘immediate trace name redohdr level n’;
    1. 1 控制文件中的redo log信息
    2. 2 level 1 + 文件头信息
    3. 3 level 2 + 日志文件头信息
    4. 10 level 3
  8. Redo log
    1. ALTER SYSTEM DUMP LOGFILE ‘FileName’;
    2. ALTER SYSTEM DUMP LOGFILE ‘FileName’
      1. SCN MIN MinimumSCN
      2. SCN MAX MaximumSCN
      3. TIME MIN MinimumTime
      4. TIME MAX MaximumTime
      5. LAYER Layer
      6. OPCODE Opcode
      7. DBA MIN FileNumber . BlockNumber
      8. DBA MAX FileNumber . BlockNumber
      9. RBA MIN LogFileSequenceNumber . BlockNumber
      10. RBA MAX LogFileSequenceNumber . BlockNumber;
    3. 其中time = (((((yyyy – 1988)) * 12 + mm – 1) * 31 + dd – 1) * 24 + hh) * 60 + mi) * 60 + ss;
  9. Loghist:ALTER SESSION SET EVENTS ‘immediate trace name loghist level n’;
    1. 1 dump控制文件中最早和最迟的日志历史项
    2. >1 dump 2^n个日志历史项
事件编号和对应的描述;
获得对应trace文件的脚本;
例子:
1. alter session set events ‘10046 trace name context forever,level 12’;
2. alter session set events ‘immediate trace name controlf level 12’;

———————————- 获得对应trace文件的脚本 ———————————-

SELECT a.VALUE || b.symbol || c.instance_name || ‘_ora_’ || d.spid || ‘.trc’ trace_file
FROM (SELECT VALUE FROM v$parameter WHERE NAME = ‘user_dump_dest’) a,
(SELECT substr(VALUE, -6, 1) symbol FROM v$parameter WHERE NAME = ‘user_dump_dest’) b,
(SELECT instance_name FROM v$instance) c,
(SELECT spid
FROM v$session s, v$process p, v$mystat m
WHERE s.paddr = p.addr AND
s.sid = m.sid AND
m.statistic# = 0) d;

———————————- 获得对应trace文件的脚本 ———————————-

———————————- 事件编号和对应的描述 ———————————-
10000 Controlfile debug event, name ‘control_file’
10001 Controlfile crash event1
10002 Controlfile crash event2
10003 Controlfile crash event3
10004 Controlfile crash event4
10005 Trace latch operations for debugging
10006 Testing – block recovery forced
10007 Log switch debug crash after new log select, thread %s
10008 Log switch debug crash after new log header write, thread %s
10009 Log switch debug crash after old log header write, thread %s
10010 Begin Transaction
10011 End Transaction
10012 Abort Transaction
10013 Instance Recovery
10014 Roll Back to Save Point
10015 Undo Segment Recovery
10016 Undo Segment extend
10017 Undo Segment Wrap
10018 Data Segment Create
10019 Data Segment Recovery
10020 Partial link restored to linked list (KSG)
10021 Latch cleanup for state objects (KSS)
10022 Trace ktsgsp
10023 Create Save Undo Segment
10024 Write to Save Undo
10025 Extend Save Undo Segment
10026 Apply Save Undo
10027 Latch cleanup for enqueue locks (KSQ)
10028 Latch cleanup for enqueue resources (KSQ)
10029 Session logon (KSU)
10030 Session logoff (KSU)
10031 Sort debug event (S*)
10032 Sort statistics (SOR*)
10033 Sort run information (SRD*/SRS*)
10034 Access path analysis (APA*)
10035 Parse SQL statement (OPIPRS)
10036 Create remote row source (QKANET)
10037 Allocate remote row source (QKARWS)
10038 Dump row source tree (QBADRV)
10039 Type checking (OPITCA)
10040 Dirty cache list
10041 Dump undo records skipped
10042 Trap error during undo application
10043 Check consistency of owner/waiter/converter lists in KSQ
10044 Free list undo operations
10045 Free list update operations – ktsrsp, ktsunl
10046 Enable SQL statement timing
10047 Trace switching of sessions
10048 Undo segment shrink
10049 Protect library cache memory heaps
10050 Sniper trace
10051 Trace OPI calls
10052 Don’t clean up obj$
10053 CBO Enable optimizer trace
10054 Trace UNDO handling in MLS
10055 Trace UNDO handing
10056 Dump analyze stats (kdg)
10057 Suppress file names in error messages
10058 Use table scan cost in tab$.spare1
10059 Simulate error in logfile create/clear
10060 CBO Enable predicate dump
10061 Disable SMON from cleaning temp segment
10062 Disable usage of OS Roles in osds
10063 Disable usage of DBA and OPER privileges in osds
10064 Thread enable debug crash level %s, thread %s
10065 Limit library cache dump information for state object dump
10066 Simulate failure to verify file
10067 Force redo log checksum errors – block number
10068 Force redo log checksum errors – file number
10069 Trusted Oracle test event
10070 Force datafile checksum errors – block number
10071 Force datafile checksum errors – file number
10072 Protect latch recovery memory
10073 Have PMON dump info before latch cleanup
10074 Default trace function mask for kst
10075 CBO Disable outer-join to regular join conversion
10076 CBO Enable cartesian product join costing
10077 CBO Disable view-merging optimization for outer-joins
10078 CBO Disable constant predicate elimination optimization
10079 Trace data sent/received via SQL*Net
10080 Dump a block on a segment list which cannot be exchanged
10081 Segment High Water Mark has been advanced
10082 Free list head block is the same as the last block
10083 A brand new block has been requested from space management
10084 Free list becomes empty
10085 Free lists have been merged
10086 CBO Enable error if kko and qka disagree on oby sort
10087 Disable repair of media corrupt data blocks
10088 CBO Disable new NOT IN optimization
10089 CBO Disable index sorting
10090 Invoke other events before crash recovery
10091 CBO Disable constant predicate merging
10092 CBO Disable hash join
10093 CBO Enable force hash joins
10094 Before resizing a data file
10095 Dump debugger commands to trace file
10096 After the cross instance call when resizing a data file
10097 After generating redo when resizing a data file
10098 After the OS has increased the size of a data file
10099 After updating the file header with the new file size
10100 After the OS has decreased the size of a data file
10101 Atomic redo write recovery
10102 Switch off anti-joins
10103 CBO Disable hash join swapping
10104 Dump hash join statistics to trace file
10105 CBO Enable constant pred trans and MPs w WHERE-clause
10106 CBO Disable evaluating correlation pred last for NOT IN
10107 CBO Always use bitmap index
10108 CBO Don’t use bitmap index
10109 CBO Disable move of negated predicates
10110 CBO Try index rowid range scans
10111 Bitmap index creation switch
10112 Bitmap index creation switch
10113 Bitmap index creation switch
10114 Bitmap index creation switch
10115 CBO Bitmap optimization use maximal expression
10116 CBO Bitmap optimization switch
10117 CBO Disable new parallel cost model
10118 CBO Enable hash join costing
10119 QKA Disable GBY sort elimination
10120 Generate relative file # different from absolute
10121 CBO Don’t sort bitmap chains
10122 Disable transformation of count(col) to count(*)
10123 QKA Disable Bitmap And-EQuals
10124 Force creation of segmented arrays by kscsAllocate
10125 Disable remote sort elimination
10126 Debug oracle java xa
10127 Disable remote query block operation
10128 Dump Partition Pruning Information
10129 Alter histogram lookup for remote queries
10130 Sort disable readaheads
10131 Use v$sql_plan code path for explain plan
10132 Dump plan after compilation
10133 Testing for SQL Memory Management
10134 Tracing for SQL Memory Management for session
10135 CBO do not count 0 rows partitions
10136 CBO turn off fix for bug 1089848
10137 CBO turn off fix for bug 1344111
10138 CBO turn off fix for bug 1577003
10139 CBO turn off fix for bug 1386119
10140 CBO turn off fix for bug 1332980
10141 CBO disable additional keys for inlist in bitmap optimization
10142 CBO enable dynamic selectivity estimation
10143 CBO force dynamic selectivity estimation (if enabled)
10145 Test auditing network errors
10146 Enable Oracle TRACE collection
10148 Use pre-7.3.3 random generator
10149 Allow the creation of constraints with illegal date constants
10150 Import exceptions
10151 Force duplicate dependency removal
10152 CBO don’t consider function costs in plans
10153 Switch to use public synonym if private one does not translate
10154 Switch to disallow synonyms in DDL statements
10155 CBO disable generation of transitive OR-chains
10156 CBO disable index fast full scan
10157 CBO disable index access path for in-list
10158 CBO preserve predicate order in post-filters
10159 CBO disable order-by sort pushdown into domain indexes
10160 CBO disable use of join index
10161 CBO recursive semi-join on/off-switch
10162 CBO join-back elimination on/off-switch
10163 CBO join-back elimination on/off-switch
10164 CBO disable subquery-adjusted cardinality fix
10165 Mark session to be aborted during shutdown normal
10166 Trace long operation statistics updates
10167 CBO use old index MIN/MAX optimization
10168 CBO disable single-table predicate predicate generation
10169 CBO disable histograms for multi partitions
10170 CBO use old bitmap costing
10171 CBO disable transitive join predicates
10172 CBO force hash join back
10173 CBO no constraint-based join-back elimination
10174 View join-back elimination switch
10175 CBO star transformation switch
10176 CBO colocated join switch
10177 CBO colocated join switch
10178 CBO turn off hash cluster filtering through memcmp
10179 CBO turn off transitive predicate replacement
10180 Temp table transformation print error messages
10181 CBO disable multi-column in-list processing
10182 CBO disable generation of implied predicates
10183 CBO disable cost rounding
10184 CBO disable OR-exp if long inlist on bitmap column
10185 CBO force index joins
10186 CBO disable index join
10187 CBO additional index join switch
10188 “CBO additional index join switch
10189 CBO turn off FFS null fix
10190 Analyze use old frequency histogram collection and density
10191 Avoid conversion of in-lists back to OR-expanded form
10192 Nopushdown when number of groups exceed number of rows
10193 Force repeatable sampling with specified seed
10194 CBO disable new LIKE selectivity heuristic
10195 CBO don’t use check constraints for transitive predicates
10196 CBO disable index skip scan
10197 CBO force index skip scan
10198 Check undo record
10199 Set parameter in session
10200 Consistent read buffer status
10201 Consistent read undo application
10202 Consistent read block header
10203 Block cleanout
10204 Signal recursive extend
10205 Row cache debugging
10206 Transaction table consistent read
10207 Consistent read transactions’ status report
10208 Consistent read loop check
10209 Enable simulated error on controlfile
10210 Check data block integrity
10211 Check index block integrity
10212 Check cluster integrity
10213 Crash after controlfile write
10214 Simulate write errors on controlfile
10215 Simulate read errors on controlfile
10216 Dump controlfile header
10217 Debug sequence numbers
10218 Dump uba of applied undo
10219 Monitor multi-pass row locking
10220 Show updates to the transaction table
10221 Show changes done with undo
10222 Row cache
10223 Transaction layer – turn on verification codes
10224 Index block split/delete trace
10225 Free/used extent row cache
10226 Trace CR applications of undo for data operations
10227 Verify (multi-piece) row structure
10228 Trace application of redo by kcocbk
10229 Simulate I/O error against datafiles
10230 Check redo generation by copying before applying
10231 Skip corrupted blocks on _table_scans_
10232 Dump corrupted blocks symbolically when kcbgotten
10233 Skip corrupted blocks on index operations
10234 Trigger event after calling kcrapc to do redo N times
10235 Check memory manager internal structures
10236 Library cache manager
10237 Simulate ^C (for testing purposes)
10238 Instantiation manager
10239 Multi-instance library cache manager
10240 Dump dba’s of blocks that we wait for
10241 Remote SQL execution tracing/validation
10242 Suppress OER 2063 (for testing distrib w/o different error log)
10243 Simulated error for test %s of K2GTAB latch cleanup
10244 Make tranids in error msgs print as 0.0.0 (for testing)
10245 Simulate lock conflict error for testing PMON
10246 Print trace of PMON actions to trace file
10247 Turn on scgcmn tracing. (VMS ONLY)
10248 Turn on tracing for dispatchers
10249 Turn on tracing for multi-stated servers
10250 Trace all allocate and free calls to the topmost SGA heap
10251 Check consistency of transaction table and undo block
10252 Simulate write error to data file header
10253 Simulate write error to redo log
10254 Trace cross-instance calls
10255 Pl/sql parse checking
10256 Turn off shared server load balancing
10257 Trace shared server load balancing
10258 Force shared servers to be chosen round-robin
10259 Get error message text from remote using explicit call
10260 Trace calls to SMPRSET (VMS ONLY)
10261 Limit the size of the PGA heap
10262 Don’t check for memory leaks
10263 Don’t free empty PGA heap extents
10264 Collect statistics on context area usage (x$ksmcx)
10265 Keep random system generated output out of error messages
10266 Trace OSD stack usage
10267 Inhibit KSEDMP for testing
10268 Don’t do forward coalesce when deleting extents
10269 Don’t do coalesces of free space in SMON
10270 Debug shared cursors
10271 Distributed transaction after COLLECT
10272 Distributed transaction before PREPARE
10273 Distributed transaction after PREPARE
10274 Distributed transaction before COMMIT
10275 Distributed transaction after COMMIT
10276 Distributed transaction before FORGET
10277 Cursor sharing (or not) related event (used for testing)
10278 Internal testing
10279 Simulate block corruption in kdb4chk
10280 Internal testing – segmentation fault during crash recovery
10281 Maximum time to wait for process creation
10282 Inhibit signalling of other backgrounds when one dies
10283 Simulate asynch I/O never completing
10284 Simulate zero/infinite asynch I/O buffering
10285 Simulate controlfile header corruption
10286 Simulate controlfile open error
10287 Simulate archiver error
10288 Do not check block type in ktrget
10289 Do block dumps to trace file in hex rather than fromatted
10290 Kdnchk – checkvalid event – not for general purpose use.
10291 Die in tbsdrv to test controlfile undo
10292 Dump uet entries on a 1561 from dtsdrv
10293 Dump debugging information when doing block recovery
10294 Enable PERSISTENT DLM operations on non-compliant systems
10295 Die after file header update durning cf xact
10296 Disable ORA-379
10297 Customize dictionary object number cache
10298 Ksfd i/o tracing
10299 Trace prefetch tracking decisions made by CKPT
10300 Disable undo compatibility check at database open
10301 Enable LCK timeout table consistency check
10302 Trace create or drop internal trigger
10303 Trace loading of library cache for internal triggers
10304 Trace replication trigger
10305 Trace updatable materialized view trigger
10306 Trace materialized view log trigger
10307 Trace RepCat execution
10308 Replication testing event
10309 Trigger Debug event
10310 Trace synchronous change table trigger
10311 Disable Flashback Table Timestamp checking
10312 Allow disable to log rows into the mapping table
10319 Trace PGA statistics maintenance
10320 Enable data layer (kdtgrs) tracing of space management calls
10321 Datafile header verification debug failure.
10323 Before committing an add datafile command
10324 Enable better checking of redo logs errors
10325 Trace control file record section expand and shrink operations
10326 Clear logfile debug crash at %s, log %s
10327 Simulate ORA-00235 error for testing
10328 Disable first-to-mount split-brain error, for testing
10329 Simulate lost write, test detection by two-pass recovery
10330 Clear MTTR statistics in checkpoint progress record
10331 Simulate resilvering during recovery
10332 Force ALTER SYSTEM QUIESCE RESTRICTED command to fail
10336 Do remote object transfer using remote SQL
10337 Enable padding owner name in slave sql
10340 Buffer queues sanity check for corrupted buffers
10341 Simulate out of PGA memory in DBWR during object reuse
10342 Raise unknown exception in ACQ_ADD when checkpointing
10343 Raise an out of memory exception-OER 4031 in ACQ_ADD
10344 Simulate kghxal returning 0 in ACQ_ADD but no exception
10345 Validate queue when linking or unlinking a buffer
10346 Check that all buffers for checkpoint have been written
10347 Dump active checkpoint entries and checkpoint buffers
10348 Test abnormal termination of process initiating file checkpoint
10349 Do not allow ckpt to complete
10350 Simulate more than one object & tsn id in object reuse
10351 Size of slots
10352 Report direct path statistics
10353 Number of slots
10354 Turn on direct read path for parallel query
10355 Turn on direct read path for scans
10356 Turn on hint usage for direct read
10357 Turn on debug information for direct path
10359 Turn off updates to control file for direct writes
10360 Enable dbwr consistency checking
10365 Turn on debug information for adaptive direct reads
10370 Parallel query server kill event
10371 Disable TQ hint
10372 Parallel query server kill event proc
10373 Parallel query server kill event
10374 Parallel query server interrupt (validate lock value)
10375 Turn on checks for statistics rollups
10376 Turn on table queue statistics
10377 Turn off load balancing
10378 Force hard process/range affinity
10379 Direct read for rowid range scans (unimplemented)
10380 Kxfp latch cleanup testing event
10381 Kxfp latch cleanup testing event
10382 Parallel query server interrupt (reset)
10383 Auto parallelization testing event
10384 Parallel dataflow scheduler tracing
10385 Parallel table scan range sampling method
10386 Parallel SQL hash and range statistics
10387 Parallel query server interrupt (normal)
10388 Parallel query server interrupt (failure)
10389 Parallel query server interrupt (cleanup)
10390 Trace parallel query slave execution
10391 Trace PX granule allocation/assignment
10392 Parallel query debugging bits
10393 Print parallel query statistics
10394 Generate a fake load to test adaptive and load balancing
10395 Adjust sample size for range table queues
10396 Circumvent range table queues for queries
10397 Suppress verbose parallel coordinator error reporting
10398 Enable timeouts in parallel query threads
10399 Trace buffer allocation
10400 Turn on system state dumps for shutdown debugging
10401 Turn on IPC (ksxp) debugging
10402 Turn on IPC (skgxp) debugging
10403 Fake CPU number for default degree of parallelism
10404 Crash dbwr after write
10405 Emulate broken mirrors
10406 Enable datetime TIMESTAMP, INTERVAL datatype creation
10407 Enable datetime TIME datatype creation
10408 Disable OLAP builtin window function usage
10410 Trigger simulated communications errors in KSXP
10411 Simulate errors in IMR
10412 Trigger simulated errors in CGS/CM interface
10425 Enable global enqueue service open event trace
10426 Enable global enqueue service convert event trace
10427 Enable global enqueue service traffic controller event trace
10428 Enable tracing of global enqueue service distributed resource
10429 Enable tracing of global enqueue service IPC calls
10430 Enable tracing of global enqueue service AST calls
10431 Enable verification messages on pi consistency
10432 Enable tracing of global cache service fusion calls
10433 Global enqueue service testing event
10434 Enable tracing of global enqueue service muliple LMS
10435 Enable tracing of global enqueue service deadlock detetction
10450 Signal ctrl-c in kdddca (drop column) after n rows
10500 Turn on traces for SMON
10510 Turn off SMON check to offline pending offline rollback segment
10511 Turn off SMON check to cleanup undo dictionary
10512 Turn off SMON check to shrink rollback segments
10515 Turn on event to use physical cleanout
10550 Signal error during create as select/create index after n rows
10560 Block type ‘%s’
10561 Block type ‘%s’, data object# %s
10562 Error occurred while applying redo to data block (file# %s, block# %s)
10563 Test recovery had to corrupt data block (file# %s, block# %s) in order to proceed
10564 Tablespace %s
10565 Another test recovery session is active
10566 Test recovery has used all the memory it can use
10567 Redo is inconsistent with data block (file# %s, block# %s)
10568 Failed to allocate recovery state object: out of SGA memory
10570 Test recovery complete
10571 Test recovery canceled
10572 Test recovery canceled due to errors
10573 Test recovery tested redo from change %s to %s
10574 Test recovery did not corrupt any data block
10575 Give up restoring recovered datafiles to consistent state: out of memory
10576 Give up restoring recovered datafiles to consistent state: some error occurred
10577 Can not invoke test recovery for managed standby database recovery
10578 Can not allow corruption for managed standby database recovery
10579 Can not modify control file during test recovery
10580 Can not modify datafile header during test recovery
10581 Can not modify redo log header during test recovery
10582 The control file is not a backup control file
10583 Can not recovery file %s renamed as missing during test recovery
10584 Can not invoke parallel recovery for test recovery
10585 Test recovery can not apply redo that may modify control file
10586 Test recovery had to corrupt 1 data block in order to proceed
10587 Invalid count for ALLOW n CORRUPTION option
10588 Can only allow 1 corruption for normal media/standby recovery
10589 Test recovery had to corrupt %s data blocks in order to proceed
10590 Kga (argus debugger) test flags
10591 Kga (argus debugger) test flags
10592 Kga (argus debugger) test flags
10593 Kga (argus debugger) test flags
10594 Kga (argus debugger) test flags
10595 Kga (argus debugger) test flags
10596 Kga (argus debugger) test flags
10597 Kga (argus debugger) test flags
10598 Kga (argus debugger) test flags
10599 Kga (argus debugger) test flags
10600 Check cursor frame allocation
10601 Turn on debugging for cursor_sharing (literal replacement)
10602 Cause an access violation (for testing purposes)
10603 Cause an error to occur during truncate (for testing purposes)
10604 Trace parallel create index
10605 Enable parallel create index by default
10606 Trace parallel create index
10607 Trace index rowid partition scan
10608 Trace create bitmap index
10609 Trace for array index insertion
10610 Trace create index pseudo optimizer
10611 Causes migration to fail – testing only
10612 Prints debug information for auto-space managed segments
10613 Prints debug information for auto-space managed segments
10614 Operation not allowed on this segment
10615 Invalid tablespace type for temporary tablespace
10616 Operation not allowed on this tablespace
10617 Cannot create rollback segment in this tablespace
10618 Operation not allowed on this segment
10619 Avoid assertions when possible
10620 Operation not allowed on this segment
10621 Data block does not belong to the segment
10622 Test/trace online index (re)build
10623 Enable Index range scan Prefetch – testing only
10650 Disable cache-callback optimisation
10651 Incorrect file number block number specified
10666 Do not get database enqueue name
10667 Cause sppst to check for valid process ids
10690 Set shadow process core file dump type (Unix only)
10691 Set background process core file type (Unix only)
10700 Alter access violation exception handler
10701 Dump direct loader index keys
10702 Enable histogram data generation
10703 Simulate process death during enqueue get
10704 Print out information about what enqueues are being obtained
10705 Print Out Tracing information for every I/O done by ODSs
10706 Print out information about global enqueue manipulation
10707 Simulate process death for instance registration
10708 Print out Tracing information for skxf multi instance comms
10709 Enable parallel instances in create index by default
10710 Trace bitmap index access
10711 Trace bitmap index merge
10712 Trace bitmap index or
10713 Trace bitmap index and
10714 Trace bitmap index minus
10715 Trace bitmap index conversion to rowids
10716 Trace bitmap index compress/decompress
10717 Trace bitmap index compaction trace for index creation
10718 Event to disable automatic compaction after index creation
10719 Trace bitmap index dml
10720 Trace db scheduling
10721 Internal testing – temp table transformation
10722 Set parameters for CPU frequency calculation (debug)
10723 Internal testing – release buffer for buffer cache shrink
10730 Trace row level security policy predicates
10731 Dump SQL for CURSOR expressions
10740 Disables fix for bug 598861
10750 Test rollback segment blksize guessing for index array insert
10800 Disable Smart Disk scan
10801 Enable Smart Disk trace
10802 Reserved for Smart Disk
10803 Write timing statistics on cluster database recovery scan
10804 Reserved for ksxb
10806 Switch to 7.3 mode when detaching sessions
10807 Disable user id check when switching to a global transaction
10810 Trace snapshot too old
10811 Trace block cleanouts
10812 Trace Consistent Reads
10830 Trace group by sort row source
10841 Default un-inintialized charact set form to SQLCS_IMPLICIT
10850 Enable time manager tracing
10851 Allow Drop command to drop queue tables
10852 Enable dumping of the AQ statistics hash table
10853 Event for AQ statistics latch cleanup testing
10856 Disable AQ propagator from using streaming
10857 Force AQ propagator to use two-phase commit
10858 Crash the AQ propagator at different stages of commit
10859 Disable updates of message retry count
10860 Event for AQ admin disable new name parser
10861 Disable storing extended message properties
10862 Resolve default queue owner to current user in enqueue/dequeue
10900 Extent manager fault insertion event #%s
10902 Disable seghdr conversion for ro operation
10903 Force tablespaces to become locally managed
10904 Allow locally managed tablespaces to have user allocation
10905 Do cache verification (kcbcxx) on extent allocation
10906 Unable to extend segment after insert direct load
10907 Trace extent management events
10908 Trace temp tablespace events
10909 Trace free list events
10924 Import storage parse error ignore event
10925 Trace name context forever
10926 Trace name context forever
10927 Trace name context forever
10928 Trace name context forever
10929 Trace name context forever
10930 Trace name context forever
10931 Trace name context forever
10932 Trace name context forever
10933 Trace name context forever
10934 Reserved. Used only in version 7.x.
10935 Reserved. Used only in version 7.x.
10936 Trace name context forever
10937 Trace name context forever
10938 Trace name context forever
10939 Trace name context forever
10940 Trace name context forever
10941 Trace name context forever
10943 Trace name context forever
10944 Trace name context forever
10945 Trace name context forever
10975 Trace execution of parallel propagation
10976 Internal package related tracing
10977 Trace event for RepAPI
10979 Trace flags for join index implementation
10980 Prevent sharing of parsed query during Materialized View query generation
10981 Dscn computation-related event in replication
10982 Event to turn off CDC-format MV Logs
10983 Event to enable Create_Change_Table debugging
10984 Subquery materialized view-related event
10985 Event for NULL refresh of materialized views
10986 Do not use HASH_AJ in refresh
10987 Event for the support of caching table with object feature
10988 Event to get exclusive lock during materialized view refresh in IAS
10989 Event to internally create statistics MV
10999 Do not get database enqueue name
10999 End Pseudo-error debugging events

———————————- 事件编号和对应的描述 ———————————-

调优实践01–Oracle常见的等待事件及解决方案

Posted on 2014-04-15 by royalwzy

Oracle常见的等待事件及解决方案

等待事件的相关知识:
1. 等待事件主要可以分为两类,即空闲(IDLE)等待事件和非空闲(NON-IDLE)等待事件;
  1. 空闲等待事件指ORACLE正等待某种工作,在诊断和优化数据库的时候,不用过多注意这部分事件;
  2. 非空闲等待事件专门针对ORACLE的活动,指数据库任务或应用运行过程中发生的等待,这些等待事件是在调整数据库的时候需要关注与研究的;
  3. 在Oracle 10g中的等待事件有872个,11gR2中等待事件1152个;可以通过v$event_name视图来查看等待事件的相关信息;
2. 查看等待事件的总个数:SELECT COUNT(*) FROM v$event_name;
3. 查看等待事件每个分类的分布:SELECT wait_class#, wait_class_id, wait_class, COUNT(*) FROM v$event_name GROUP BY wait_class#, wait_class_id, wait_class ORDER BY wait_class#;
4. 相关的视图:
  1. V$SESSION:连接到数据库的会话信息;
  2. V$SESSION_WAIT:当前会话正在等待的资源,此视图已经与v$session视图合并了;
  3. V$SESSION_WAIT_HISTORY:是对V$SESSION_WAIT的简单增强,记录活动SESSION的最近10次等待;
  4. V$SYSTEM_EVENT:由于V$SESSION记录的是动态信息,和SESSION的生命周期相关,而并不记录历史信息,所以ORACLE提供视图V$SYSTEM_EVENT来记录数据库自启动以来所有等待事件的汇总信息;通过这个视图,用户可以迅速获得数据库运行的总体概况;
  5. V$SQL:查看某个session正在执行的sql语句(SELECT t1.sid, t2.sql_text FROM v$session t1 INNER JOIN v$sql t2 ON t1.sql_id = t2.sql_id;SELECT t1.sid, t2.sql_text FROM v$session t1 INNER JOIN v$sql t2 ON t1.sql_address = t2.address;);
  6. V$ACTIVE_SESSION_HISTORY:是ASH的核心,用以记录活动SESSION的历史等待信息,每秒采样一次,这部分内容记录在内存中,记录一个小时的内容;
  7. DBA_HIST_ACTIVE_SESS_HISTORY:通过这个视图进行ASH历史数据的访问;
5. 可以从v$event_name视图中查看等待事件的类型(SELECT NAME, parameter1, parameter2, parameter3 FROM v$event_name;),v$session中P1-3表示等待的资源是什么;
buffer busy waits:
1. 从本质上讲,这个等待事件的产生仅说明了一个会话在等待一个Buffer(数据块),但是导致这个现象的原因却有很多种,常见的两种是:
  1. 当一个会话试图修改一个数据块,但这个数据块正在被另一个会话修改时;
  2. 当一个会话需要读取一个数据块,但这个数据块正在被另一个会话读取到内存中时;
2. Oracle操作的最小单位是块(Block),即使你要修改一条记录,也需要对这条记录所在的这个数据块做操作;当你对这个数据块做修改时,其他的会话将被阻止对这个数据块上的数据做修改(即使其他用户修改的不是当前用户修改的数据),但是可以以一致性的方式读取这个数据块(使用UNDO构建CR块);当前的用户修改完这个数据块后,将会立即释放掉加在这个数据块上的排他锁,这样另一个会话就可以继续修改它;修改操作是一个非常短暂的时间,这种加锁的机制我们叫Latch;
3. 当一个会话修改一个数据块时,是按照以下步骤来完成的:
  1. 以排他的方式获得这个数据块(Latch);
  2. 修改这个数据块;
  3. 释放Latch;
4. Buffer busy waits等待事件常见于数据库中存在的热快的时候,当多个用户频繁地读取或者修改同样的数据块时,这个等待事件就会产生;如果等待的时间很长,我们在AWR或者statspack报告中就可以看到;
5. 解决办法:
  1. 如果等待处于字段头部,应增加自由列(freelist)的组数,或者增加pctused到pctfree之间的距离;
  2. 如果等待处于回退段(undo)头部块,可以通过增加回滚段(rollback segment)来解决缓冲区的问题;
  3. 如果等待处于回退段(undo)非头部块上,就需要降低驱动一致读取的表中的数据密度,或者增大DB_CACHE_SIZE;
  4. 如果等待处于数据块,可以将数据移到另一数据块以避开这个”热”数据块,增加表中的自由列表或使用LMT表空间;
  5. 如果等待处于索引块,应该重建索引,分割索引或使用反向键索引;
6. 等待事件的参数:
  1. File#:等待访问数据块所在的文件id号;
  2. Blocks:等待访问的数据块号;
db file scattered read:
1. 这是一个用户操作引起的等待事件,当用户发出每次I/O需要读取多个数据块这样的SQL操作时,会产生这个等待事件,最常见的两种情况是:
  1. 全表扫描(FTS: Full Table Scan);
  2. 索引快速扫描(IFFS: index fast full scan);
2. 这个名称中的scattered(离散),可能会导致很多人认为它是以scattered的方式来读取数据块的,其实恰恰相反,当发生这种等待事件时,SQL的操作都是顺序地读取数据块的,比如FTS或者IFFS方式(如果忽略需要读取的数据块已经存在内存中的情况);
3. 这里的scattered指的是读取的数据块在内存中的存放方式,它们被读取到内存中后,是以分散的方式存在在内存中,而不是连续的;
4. 等待事件的参数:
  1. File#: 要读取的数据块所在数据文件的文件号;
  2. Block#: 要读取的起始数据块号;
  3. Blocks:需要读取的数据块数目;
db file sequential read:
1. 当Oracle需要每次I/O只读取单个数据块这样的操作时,会产生这个等待事件,最常见的情况:
  1. 索引的访问(除IFFS外的方式);
  2. 回滚操作;
  3. 以ROWID的方式访问表中的数据;
  4. 重建控制文件;
  5. 对文件头做DUMP等;
2. 这里的sequential也并非指的是Oracle按顺序的方式来访问数据,和db file scattered read一样,它指的是读取的数据块在内存中是以连续的方式存放的;
3. 等待事件的参数:
  1. File#:要读取的数据块锁在数据文件的文件号;
  2. Block#:要读取的起始数据块号;
  3. Blocks:要读取的数据块数目(这里应该等于1);
4. 查找热点快的方法:SELECT owner, segment_name, segment_type FROM dba_extents WHERE file_id = &file_id AND &block_id BETWEEN block_id AND block_id + &blocks – 1;
buffer latch:
1. 内存中数据块的存放位置是记录在一个hash列表(cache buffer chains)当中的;当一个会话需要访问某个数据块时,它首先要搜索这个hash列表,从列表中获得数据块的地址,然后通过这个地址去访问需要的数据块,这个列表Oracle会使用一个latch来保护它的完整性;当一个会话需要访问这个列表时,需要获取一个Latch,只有这样,才能保证这个列表在这个会话的浏览当中不会发生变化;
2. 产生buffer latch的等待事件的主要原因是:
  1. Buffer chains太长,导致会话搜索这个列表花费的时间太长,使其他的会话处于等待状态;
  2. 同样的数据块被频繁访问,就是我们通常说的热快问题;
3. 解决办法:产生buffer chains太长,我们可以使用多个buffer pool的方式来创建更多的buffer chains,或者使用参数DB_BLOCK_LRU_LATCHES来增加latch的数量,以便于更多的会话可以获得latch,这两种方法可以同时使用;
4. 等待事件的参数:
  1. Latch addr:会话申请的latch在SGA中的虚拟地址,通过以下的SQL语句可以根据这个地址找到它对应的Latch名称(SELECT * FROM v$latch a, v$latchname b WHERE a.addr = <latch addr> AND a.latch# = b.latch#;);
  2. chain#:buffer chains hash列表中的索引值,当这个参数的值等于0xfffffff时,说明当前的会话正在等待一个LRU latch;
control file parallel write:
1. 当数据库中有多个控制文件的拷贝时,Oracle需要保证信息同步地写到各个控制文件当中,这是一个并行的物理操作过程,因为称为控制文件并行写,当发生这样的操作时,就会产生control file parallel write等待事件;
2. 控制文件频繁写入的主要原因:
  1. 日志切换太过频繁,导致控制文件信息相应地需要频繁更新;
  2. 系统I/O出现瓶颈,导致所有I/O出现等待;
3. 解决办法:
  1. 当系统出现日志切换过于频繁的情形时,可以考虑适当地增大日志文件的大小来降低日志切换频率;
  2. 当系统出现大量的control file parallel write 等待事件时,可以通过比如降低控制文件的拷贝数量,将控制文件的拷贝存放在不同的物理磁盘上的方式来缓解I/O争用;
4. 等待事件的参数:
  1. Files:Oracle要写入的控制文件个数;
  2. Blocks:写入控制文件的数据块数目;
  3. Requests:写入控制请求的I/O次数;
control file sequential read:
1. 当数据库需要读取控制文件上的信息时,会出现这个等待事件,因为控制文件的信息是顺序写的,所以读取的时候也是顺序的,因此称为控制文件顺序读;
2. 控制文件频繁读取的主要原因:
  1. 备份控制文件;
  2. RAC环境下不同实例之间控制文件的信息共享;
  3. 读取控制文件的文件头信息;
  4. 读取控制文件其他信息;
3. 等待事件的参数:
  1. File#:要读取信息的控制文件的文件号;
  2. Block#:读取控制文件信息的起始数据块号;
  3. Blocks:需要读取的控制文件数据块数目;
db file parallel read:
1. 这是一个很容易引起误导的等待事件,实际上这个等待事件和并行操作(比如并行查询,并行DML)没有关系;这个事件发生在数据库恢复的时候,当有一些数据块需要恢复的时候,Oracle会以并行的方式把他们从数据文件中读入到内存中进行恢复操作;
2. 等待事件的参数:
  1. Files:操作需要读取的文件个数;
  2. Blocks:操作需要读取的数据块个数;
  3. Requests:操作需要执行的I/O次数;
db file parallel write:
1. 这是一个后台等待事件,它同样和用户的并行操作没有关系,它是由后台进程DBWR产生的,当后台进程DBWR想磁盘上写入脏数据时,会发生这个等待;
2. DBWR会批量地将脏数据并行地写入到磁盘上相应的数据文件中,在这个批次作业完成之前,DBWR将出现这个等待事件;如果仅仅是这一个等待事件,对用户的操作并没有太大的影响,当伴随着出现free buffer waits等待事件时,说明此时内存中可用的空间不足,这时候会影响到用户的操作,比如影响到用户将脏数据块读入到内存中;
3. 当出现db file parallel write等待事件时,可以通过启用操作系统的异步I/O的方式来缓解这个等待;当使用异步I/O时,DBWR不在需要一直等到所有数据块全部写入到磁盘上,它只需要等到这个数据写入到一个百分比之后,就可以继续进行后续的操作;
4. 等待事件的参数:
  1. Requests:操作需要执行的I/O次数;
  2. Timeouts:等待的超时时间;
Db file single write:
1. 这个等待事件通常只发生在一种情况下,就是Oracle更新数据文件头信息时(比如发生Checkpoint);
2. 当这个等待事件很明显时,需要考虑是不是数据库中的数据文件数量太大,导致Oracle需要花较长的时间来做所有文件头的更新操作(checkpoint);
3. 等待事件的参数:
  1. File#:需要更新的数据块所在的数据文件的文件号;
  2. Block#:需要更新的数据块号;
  3. Blocks:需要更新的数据块数目(通常来说应该等于1);
direct path read:
1. 这个等待事件发生在会话将数据块直接读取到PGA当中而不是SGA中的情况,这些被读取的数据通常是这个会话私有的数据,所以不需要放到SGA作为共享数据,因为这样做没有意义;这些数据通常是来自与临时段上的数据,比如一个会话中SQL的排序数据,并行执行过程中间产生的数据,以及Hash Join,merge join产生的排序数据,因为这些数据只对当前的会话的SQL操作有意义,所以不需要放到SGA当中;
2. 当发生direct path read等待事件时,意味着磁盘上有大量的临时数据产生,比如排序,并行执行等操作;或者意味着PGA中空闲空间不足;
3. 等待事件的参数:
  1. Descriptor address:一个指针,指向当前会话正在等待的一个direct read I/O;
  2. First dba:descriptor address中最旧的一个I/O数据块地址;
  3. Block cnt:descriptor address上下文中涉及的有效的buffer数量;
direct path write:
1. 这个等待事件和direct path read正好相反,是会话将一些数据从PGA中直接写入到磁盘文件上,而不经过SGA;
  1. 使用临时表空间排序(内存不足);
  2. 数据的直接加载(使用append方式加载数据);
  3. 并行DML操作;
2. 等待事件的参数:
  1. Descriptor address:一个指针,指向当前会话正在等待的一个direct read I/O;
  2. First dba:descriptor address中最旧的一个I/O数据块地址;
  3. Block cnt:descriptor address上下文中涉及的有效的buffer数量;
enqueue:
1. Enqueue这个词其实是lock的另一种描述语;
2. 当我们在AWR报告中发现长时间的enqueue等待事件时,说明数据库中出现了阻塞和等待,可以关联AWR报告中的enqueue activity部分来确定是哪一种锁定出现了长时间等待;
3. 等待事件的参数:
  1. Name:enqueue的名称和类型;
  2. Mode:enqueue的模式;
4. 查看当前会话等待的enqueue名称和类型:SELECT chr(to_char(bitand(p1, -16777216)) / 16777215) || chr(to_char(bitand(p1, 16711680)) / 65535) “Lock”, to_char(bitand(p1, 65535)) “Mode” FROM v$session_wait WHERE event = ‘enqueue’;
5. 模式代码及解释:
  1. 1-Null mode
  2. 2-Sub-Share
  3. 3-Sub-Exclusive
  4. 4-Share
  5. 5-Share/Sub-Exclusive
  6. 6-Exclusive
6. Enqueue的缩写及解释;
free buffer waits:
1. 当一个会话将数据块从磁盘读到内存中时,它需要到内存中找到空闲的内存空间来存放这些数据块,当内存中没有空闲的空间时,就会产生这个等待;除此之外,还有一种情况就是会话在做一致性读时,需要构造数据块在某个时刻的前映像(image),此时需要申请内存来存放这些新构造的数据块,如果内存中无法找到这样的内存块,也会发生这个等待事件;
2. 当数据库中出现比较严重的free buffer waits等待事件时,可能的原因是:
  1. Data buffer太小,导致内存空间不够;
  2. 内存中的脏数据太多,DBWR无法及时将这些脏数据写到磁盘中以释放空间
3. 解决办法:
  1. 加大db_buffer_cache大小;
  2. 增加dbwr进程数量;
  3. 增加检查点或者物理磁盘的数量;
4. 等待事件的参数:
  1. File#:需要读取的数据块所在的数据文件的文件号;
  2. Block#:需要读取的数据块块号;
latch free:
1. 在10g之前的版本里,latch free等待事件代表了所有的latch等待,在10g以后,一些常用的latch事件已经被独立了出来:所以latch free等待事件在10g以后的版本中并不常见,而是以具体的Latch等待事件出现;
2. latch是一种低级排队机制(它们被准确地称为相互排斥机制),用于保护系统全局区域(SGA)中共享内存结构;latch就像是一种快速地被获取和释放的内存锁;latch用于防止共享内存结构被多个用户同时访问;如果latch不可用,就会记录latch释放失败;大多数latch 问题都与以下操作相关:
  1. 不能使用邦定变量(库缓存latch);
  2. 重复生成问题(重复分配latch);
  3. 缓冲存储器竞争问题(缓冲器存储LRU 链),以及缓冲存储器中的”热”块(缓冲存储器链);
  4. 也有一些latch等待与bug(程序错误)有关;
3. 查看latch相关的等待事件:SELECT NAME FROM v$event_name WHERE NAME LIKE ‘latch%’;
4. 查找事件热点对象的sql语句;
5. latch问题的解决办法:
  1. Library Cache and Shared Pool(未绑定变量—绑定变量,调整shared_pool_size):每当执行SQL或PL/SQL存储过程,包,函数和触发器时,这个Latch即被用到.Parse操作中此Latch也会被频繁使用;
  2. Redo Copy(增大_LOG_SIMULTANEOUS_COPIES参数):重做拷贝Latch用来从PGA向重做日志缓冲区拷贝重做记录;
  3. Redo Allocation(最小化REDO生成,避免不必要提交):此Latch用来分配重做日志缓冲区中的空间,可以用NOLOGGING来减缓竞争;
  4. Row Cache Objects(增大共享池):数据字典竞争,过度parsing;
  5. Cache Buffers Chains(_DB_BLOCK_HASH_BUCKETS应增大或设为质数):”过热”数据块造成了内存缓冲链Latch竞争;
  6. Cache Buffers Lru Chain(调整SQL,设置DB_BLOCK_LRU_LATCHES,或使用多个缓冲区池):扫描全部内存缓冲区块的LRU(最近最少使用)链时要用到内存缓冲区LRU链Latch;太小内存缓冲区,过大的内存缓冲区吞吐量,过多的内存中进行的排序操作,DBWR速度跟不上工作负载等会引起此Latch竞争;
6. 等待事件的参数:
  1. Address:会话等待的latch地址;
  2. Number:latch号,通过这个号,可以从v$latchname视图中找到这个latch的相关的信息(SELECT * FROM v$latchname WHERE latch# = NUMBER;);
  3. Tries:会话尝试获取Latch的次数;
library cache lock:
1. 这个等待时间发生在不同用户在共享中由于并发操作同一个数据库对象导致的资源争用的时候,比如当一个用户正在对一个表做DDL操作时,其他的用户如果要访问这张表,就会发生library cache lock等待事件,它要一直等到DDL操作完成后,才能继续操作;
2. 该事件通常是由于执行多个DDL操作导致的,即在library cache object上添加一个排它锁后,又从另一个会话给它添加一个排它锁,这样在第二个会话就会生成等待;可通过到基表x$kgllk中查找其对应的对象;
3. 查询引起该等待事件的阻塞者的sid,会话用户,锁住的对象的脚本;
4. 等待事件的参数:
  1. Handle address:被加载的对象的地址;
  2. Lock address:锁的地址;
  3. Mode:被加载对象的数据片段;
  4. Namespace:被加载对象在v$db_object_cache视图中namespace名称;
Library cache pin
1. 这个等待事件和library cache lock一样是发生在共享池中并发操作引起的事件;通常来讲,如果Oracle要对一些PL/SQL或者视图这样的对象做重新编译,需要将这些对象pin到共享池中;如果此时这个对象被其他的用户特有,就会产生一个library cache pin的等待;
2. P1,P2可与x$kglpn和x$kglob表相关:
  1. X$KGLOB (Kernel Generic Library Cache Manager Object);
  2. X$KGLPN (Kernel Generic Library Cache Manager Object Pins);
3. 相关锁的查询sql;
4. 等待事件的参数:
  1. Handle address:被加载的对象的地址;
  2. Lock address:锁的地址;
  3. Mode:被加载对象的数据片段;
  4. Namespace:被加载对象在v$db_object_cache视图中namespace名称;
log file parallel write:
1. 后台进程LGWR负责将log buffer当中的数据写到REDO文件中,以重用log buffer的数据;如果每个REDO LOG组里面有2个以上的成员,那么LGWR进程会并行地将REDO信息写入这些文件中;
2. 如果数据库中出现这个等待事件的瓶颈,主要的原因可能是磁盘I/O性能不够或者REDO文件的分布导致了I/O争用,比如同一个组的REDO成员文件放在相同的磁盘上;
3. 等待事件的参数:
  1. Files:操作需要写入的文件个数;
  2. Blocks:操作需要写入的数据块个数;
  3. Requests:操作需要执行的I/O次数;
log buffer space:
1. 当log buffer中没有可用空间来存放新产生的redo log数据时,就会发生log buffer space等待事件;如果数据库中新产生的redo log的数量大于LGWR写入到磁盘中的redo log数量,必须等待LGWR完成写入磁盘的操作,LGWR必须确保redo log写到磁盘成功之后,才能在redo buffer当中重用这部分信息;
2. 如果数据库中出现大量的log buffer space等待事件,可以考虑如下方法:
  1. 增加redo buffer的大小;
  2. 提升磁盘的I/O性能;
log file sequential read:
1. 这个等待事件通常发生在对redo log信息进行读取时,比如在线redo的归档操作,ARCH进程需要读取redo log的信息,由于redo log的信息是顺序写入的,所以在读取时也是按照顺序的方式来读取的;
2. 等待事件的参数:
  1. Log#:发生等待时读取的redo log的sequence号;
  2. Block#:读取的数据块号;
  3. Blocks:读取的数据块个数;
log file single write:
1. 这个等待事件发生在更新redo log文件的文件头时,当为日志组增加新的日志成员时或者redo log的sequence号改变时,LGWR都会更新redo log文件头信息;
2. 等待事件的参数:
  1. Log#:发生等待时读取的redo log的sequence号;
  2. Block#:读取的数据块号;
  3. Blocks:读取的数据块个数;
log file switch(archiving needed):
1. 在归档模式下,这个等待事件发生在在线日志切换(log file switch)时,需要切换的在线日志还没有被归档进程(ARCH)归档完毕的时候;当在线日志文件切换到下一个日志时,需要确保下一个日志文件已经被归档进程归档完毕,否则不允许覆盖那个在线日志信息(否则会导致归档日志信息不完整);
2. 出现这样的等待事件通常是由于某种原因导致ARCH进程死掉,比如ARCH进程尝试向目的地写入一个归档文件,但是没有成功(介质失效或者其他原因),这时ARCH进程就会死掉;如果发生这种情况,在数据库的alert log文件中可以找到相关的错误信息;
log file switch(checkpoint incomplete):
1. 当一个在线日志切换到下一个在线日志时,必须保证要切换到的在线日志上的记录的信息(比如一些脏数据块产生的redo log)被写到磁盘上(checkpoint),这样做的原因是,如果一个在线日志文件的信息被覆盖,而依赖这些redo信息做恢复的数据块尚未被写到磁盘上(checkpoint),此时系统down掉的话,Oracle将没有办法进行实例恢复;
2. 在v$log视图里记录了在线日志的状态,在线日志有三种状态:
  1. Active:这个日志上面保护的信息还没有完成checkpoint;
  2. Inactive:这个日志上面保护的信息已完成checkpoint;
  3. Current:当前的日志;
3. Oracle在做实例恢复时,会使用状态为current和Active的日志进行实例恢复;
4. 如果系统中出现大量的log file switch(checkpoint incomplete)等待事件,原因可能是日志文件太小或者日志组太少,所以解决的方法是,增加日志文件的大小或者增加日志组的数量;
log file sync:
1. 这是一个用户会话行为导致的等待事件,当一个会话发出一个commit命令时,LGWR进程会将这个事务产生的redo log从log buffer里面写到磁盘上,以确保用户提交的信息被安全地记录到数据库中;会话发出的commit指令后,需要等待LGWR将这个事务产生的redo成功写入到磁盘之后,才可以继续进行后续的操作,这个等待事件就叫作log file sync;
2. 当系统中出现大量的log file sync等待事件时,应该检查数据库中是否有用户在做频繁的提交操作;
3. 这种等待事件通常发生在OLTP系统上,OLTP系统中存在很多小的事务,如果这些事务频繁被提交,可能引起大量的log file sync的等待事件;
4. 等待事件的参数:
  1. Buffer#:redo buffer中需要被写入到磁盘中的buffer;
SQL*Net相关的等待事件:
1. SQL*Net break/reset to client:当出现这个等待事件时,说明服务器端在给客户端发送一个断开连接或者重置连接的请求,正在等待客户的响应,通常的原因是服务器到客户端的网络不稳定导致的;
2. SQL*Net break/reset to dblink:这个等待事件和SQL*Net break/reset to client相同;不过它表示的是数据库通过dblink访问另一台数据库时,他们之间建立起一个会话,这个等待事件发生在这个会话之间的通信过程中,同样如果出现这个等待事件,需要检查两台数据库之间的通信问题;
3. SQL*Net message from client:这个等待事件基本上是最常见的一个等待事件;当一个会话建立成功后,客户端会向服务器端发送请求,服务器端处理完客户端请求后,将结果返回给客户端,并继续等待客户端的请求,这时候会产生SQL*Net message from client 等待事件;很显然,这是一个空闲等待,如果客户端不再向服务器端发送请求,服务器端将一直处于这个等待事件状态;
4. SQL*Net message from dblink:这个等待事件和SQL*Net message from client相同,不过它表示的是数据库通过dblink 访问另一个数据库时,他们之间会建立一个会话,这个等待事件发生在这个会话之间的通信过程中;这个等待事件也是一个空闲等待事件;
5. SQL*Net message to client:这个等待事件发生在服务器端向客户端发送消息的时候; 当服务器端向客户端发送消息产生等待时,可能的原因是用户端太繁忙,无法及时接收服务器端送来的消息,也可能是网络问题导致消息无法从服务器端发送到客户端;
6. SQL*Net message to dblink:这个等待事件和SQL*Net message to client相同,不过是发生在数据库服务器和服务器之间的等待事件,产生这个等待的原因可能是远程服务器繁忙,而无法及时接收发送过来的消息,也可能是服务器之间网络问题导致消息无法发送过来;
7. SQL*Net more data from client:服务器端等待用户发出更多的数据以便完成操作,比如一个大的SQL文本,导致一个SQL*Net 数据包无法完成传输,这样服务器端会等待客户端把整个SQL 文本发过来在做处理,这时候就会产生一个SQL*Net more data from client等待事件;
8. SQL*Net more data from dblink:在一个分布式事务中,SQL 分布在不同的数据库中执行,远程数据库执行完毕后将结果通过dblink返给发出SQL的数据库,在等待数据从其他数据库中通过dblink传回的过程中,如果数据在远程数据库上处理时间很久,或者有大量的结果集需要返回,或者网络性能问题都会产生SQL*Net more data from dblink 等待事件,它的意思是本地数据库需要等到所有的数据从远程处理完毕通过dblink传回后,才可以在本机继续执行操作;
9. SQL*Net more data to client:当服务器端有太多的数据需要发给客户端时,可能会产生SQL*Net more data to client等待事件,也可能由于网络问题导致服务器无法及时地将信息或者处理结果发送给客户端,同样会产生这个等待;
10. SQL*Net more data to dblink:这个等待事件和SQL*Net more data to client 等待时间基本相同,只不过等待发生在分布式事务中,即本地数据库需要将更多的数据通过dblink发送给远程数据库;由于发送的数据太多或者网络性能问题,就会出现SQL*Net more data to dblink等待事件;
11. 它们的等待事件参数一致:
  1. Driver id:服务器端和客户端连接使用的协议信息;
  2. #bytes:服务器端通过dblink发送给另一个服务器消息的字节数;

———————- latch free:查找事件热点对象的sql语句 ———————-

&2值是v$session_wait中的P1RAW,x$bh中的字段Hladdr表示该block buffer在哪个cache buffer chain latch上,可以通过v$latch_children定位哪些segment是热点块;

SELECT a.hladdr, a.file#, a.dbablk, a.tch, a.obj, b.object_name
FROM x$bh a, dba_objects b
WHERE (a.obj = b.object_id OR a.obj = b.data_object_id) AND
a.hladdr = &2
UNION
SELECT hladdr, file#, dbablk, tch, obj, NULL
FROM x$bh
WHERE obj IN (SELECT obj
FROM x$bh
WHERE hladdr = &2
MINUS
SELECT object_id
FROM dba_objects
MINUS
SELECT data_object_id FROM dba_objects) AND
hladdr = &2
ORDER BY 4;

———————- latch free:查找事件热点对象的sql语句 ———————-

———————- 查询引起library cache lock等待事件的阻塞者的sid,会话用户,锁住的对象的脚本 ———————-

SELECT b.sid, a.user_name, a.kglnaobj
FROM x$kgllk a, v$session b
WHERE a.kgllkhdl IN (SELECT p1raw
FROM v$session_wait
WHERE wait_time = 0 AND
event = ‘library cache lock’) AND
a.kgllkmod <> 0 AND
b.saddr = a.kgllkuse;

———————- 查询引起library cache lock等待事件的阻塞者的sid,会话用户,锁住的对象的脚本 ———————-

———————- library cache lock等待事件相关锁的查询sql ———————-

— 查询X$KGLOB,可找到相关的object,其SQL语句如下(即把V$SESSION_WAIT中的P1raw与X$KGLOB中的KGLHDADR相关连);
SELECT kglnaown, kglnaobj
FROM x$kglob
WHERE kglhdadr = (SELECT p1raw FROM v$session_wait WHERE event = ‘library cache pin’);
— 查出引起该等待事件的阻塞者的sid;
SELECT sid
FROM x$kglpn, v$session
WHERE kglpnhdl IN (SELECT p1raw
FROM v$session_wait
WHERE wait_time = 0 AND
event LIKE ‘library cache pin%’) AND
kglpnmod <> 0 AND
v$session.saddr = x$kglpn.kglpnuse;
— 查出阻塞者正执行的SQL语句
SELECT sid, sql_text
FROM v$session, v$sqlarea
WHERE v$session.sql_address = v$sqlarea.address AND
sid = < 阻塞者的sid >;

———————- library cache lock等待事件相关锁的查询sql ———————-

———————- Enqueue缩写及解释 ———————-
BL:Buffer Cache management
BR:Backup/Restore
CF:Controlfile transaction
CI:Cross-instance Call Invocation
CU:Bind Enqueue
DF:Datafile
DL:Direct Loader Index Creation
DM:Database Mount
DR:Distributed Recovery Process
DX:Dirstributed Transaction
FP:File Object
FS:File Set
HW:High-water Lock
IN:Instance Number
IR:Instance Recovery
IS:Instance State
IV:Library Cache Invalidation
JI:Enqueue used during AJV snapshot refresh
JQ:Job Queue
KK:Redo Log “Kick”
KO:Multiple Object Checkpoint
L[A-p]:Library Cache Lock
LS:Log start or switch
MM:Mount Definition
MR:Media recovery
N[A-Z]:Library Cache bin
PE:Alter system set parameter =value
PF:Password file
PI:Parallel slaves
PR:Process startup
PS:Parallel slave synchronization
Q[A-Z]:Row Cache
RO:Object Reuse
RT:Redo Thread
RW:Row Wait
SC:System Commit Number
SM:SMON
SN:Sequence Number
SQ:Sequence Number Enqueue
SR:Synchronized replication
SS:Sort segment
ST:Space management transaction
SV:Sequence number Value
TA:Transaction recovery
TC:Thread Checkpoint
TE:Extend Table
TM:DML enqueue
TO:Temporary Table Object Enqueue
TS:Temporary Segement(also TableSpace)
TT:Temporary Table
TX:Transaction
UL:User-defined Locks
UN:User name
US:Undo segment, Serialization
WL:Being Written Redo Log
XA:Instance Attribute Log
XI:Instance Registration Lock

———————- Enqueue缩写及解释 ———————-

ORACLE中工具的使用09–COPY

Posted on 2014-04-11 by royalwzy

COPY工具的使用:

1. COPY是sqlplus中的命令;
2. 在sqlplus中通过help copy查看帮助;
3. 一个表中只能包含一个long型字段,在数据字典中大量使用了long型字段;但是包含long类型的表不能使用CTAS语法创建新表;此时可以使用copy命令;
4. 比如dba_tab_cols视图是基于cols$表的,包含了一个LONG类型,如果直接创建:CREATE TABLE tbcols AS SELECT * FROM dba_tab_cols;
5. 使用copy命令创建:copy from system/ORACLE@orcl to system/ORACLE@orcl CREATE TBCOLS USING SELECT * FROM dba_tab_cols;

——————————- COPY的帮助文档 ——————————-
SQL> help copy

COPY
—-

Copies data from a query to a table in the same or another
database. COPY supports CHAR, DATE, LONG, NUMBER and VARCHAR2.

COPY {FROM database | TO database | FROM database TO database}
{APPEND|CREATE|INSERT|REPLACE} destination_table
[(column, column, column, …)] USING query

where database has the following syntax:
username[/password]@connect_identifier
——————————- COPY的帮助文档 ——————————-

ORACLE中工具的使用08–OERR

Posted on 2014-03-11 by royalwzy

查看Oracle错误号的命令:oerr ora err_num;

ORACLE中工具的使用07–BBED

Posted on 2014-02-11 by royalwzy

BBED工具的使用

BBED工具介绍:
1. Oracle BBED(Oracle Block Browser and Editor)工具是Oracle内部提供的数据块级别查看和修改的工具;通过这个工具,我们可以方便的查看Oracle块级别的存储信息,从而更好的了解Oracle Internal结构技术细节;
2. Oracle不推荐使用此工具,它只用来给内部进行恢复处理使用,对外是不提供资料和相关文档的;所以当遇到故障时,优先采用备份恢复,最后再考虑使用此工具;
3. 只有Linux/Unix平台下提供BBED工具,在Windows平台没有对应的版本;所以使用BBED的环境通常是命令行方式,而且BBED在Oracle内部是没有编译的,需要手工编译;
Oracle10g下编译BBED(适合10g以前版本):
1. BBED对应对象文件通常在$ORACLE_HOME/rdbms/lib目录下,所以先进入此目录:cd $ORACLE_HOME/rdbms/lib;
2. 然后使用linux系统的make进行编译和连接,生成bbed可执行文件:make -f ins_rdbms.mk $ORACLE_HOME/rdbms/lib/bbed;
3. 为了使用方便,添加一个硬链接:link $ORACLE_HOME/rdbms/lib/bbed $ORACLE_HOME/bin/bbed;
4. 查看此工具:which bbed;
Oracle11g下编译BBED:
1. 11g中直接编译后报错,缺少$ORACLE_HOME/rdbms/lib/ssbbded.o,$ORACLE_HOME/rdbms/lib/sbbdpt.o,$ORACLE_HOME/rdbms/mesg/bbedus.msb和$ORACLE_HOME/rdbms/mesg/bbedus.msg等文件;
2. 因为缺少必要的库文件,所以需要从10g环境中拷贝相应的文件到对应的目录; 从10g中拷贝文件到11g对应的目录中:scp oracle@singleton10g:/u01/app/oracle/product/10.2.0/db_1/rdbms/lib/ssbbded.o $ORACLE_HOME/rdbms/lib;scp oracle@singleton10g:/u01/app/oracle/product/10.2.0/db_1/rdbms/lib/sbbdpt.o $ORACLE_HOME/rdbms/lib;scp oracle@singleton10g:/u01/app/oracle/product/10.2.0/db_1/rdbms/mesg/bbedus.msb $ORACLE_HOME/rdbms/mesg;scp oracle@singleton10g:/u01/app/oracle/product/10.2.0/db_1/rdbms/mesg/bbedus.msg $ORACLE_HOME/rdbms/mesg;
3. 然后进入$ORACLE_HOME/rdbms/lib目录进行编译:cd $ORACLE_HOME/rdbms/lib;make -f ins_rdbms.mk $ORACLE_HOME/rdbms/lib/bbed;
4. 创建链接文件并查看:link $ORACLE_HOME/rdbms/lib/bbed $ORACLE_HOME/bin/bbed;which bbed;
使用bbed工具:
1. 工具默认的密码是blockedit;
2. 查看bbed工具参数:bbed help=yes;
3. 查看bbed帮助:help all;
4. 指定数据库文件列表bbed.lst,通过SELECT file# || chr(9) || NAME || chr(9) || bytes FROM v$datafile;语句查看数据库文件信息;
5. 编写bbed参数文件bbed.conf;
6. 使用bbed:bbed parfile=bbed.conf;
7. tip:修改数据块之后,Oracle会认为它是坏块,需要重新计算checksum值,然后可以使用;
BBED工具使用示例:
1. 手动把bootstrap$表中line#=-1的记录从8.0.0.0.0修改为9.0.0.0.0导致系统无法正常启动;
2. 设置数据文件列表和参数文件,打开bbed工具;
3. 我们知道,11g中bootstrap$位于file 1 block 520,所以使用find命令从这里开始搜索(find /c 9.0.0.0.0),最终搜索到的位置为file 1 block 521 offset 8179;
4. 设置当前位置,并导出内容:set file 1 block 521 offset 8179;dump;
5. 将此处的9修改为8:modify /c “8” offset 8179;
6. 修改之后,Oracle会认为该块已经损坏:verify;
7. 重新计算和应用校验位后,数据块可以恢复一致:sum apply;
8. 之后数据库可以正常启动;

———————————– bbed工具参数 ———————————–

PASSWORD – Required parameter
FILENAME – Database file name
BLOCKSIZE – Database block size
LISTFILE – List file name
MODE – [browse/edit]
SPOOL – Spool to logfile [no/yes]
CMDFILE – BBED command file name
LOGFILE – BBED log file name
PARFILE – Parameter file name
BIFILE – BBED before-image file name
REVERT – Rollback changes from BIFILE [no/yes]
SILENT – Hide banner [no/yes]
HELP – Show all valid parameters [no/yes]

———————————– bbed工具参数 ———————————–

———————————– bbed的帮助文档 ———————————–

———————————– bbed的帮助文档 ———————————–

———————————– bbed参数文件 ———————————–

BLOCKSIZE=8192
LISTFILE=bbed.lst
MODE=EDIT
PASSWORD=blockedit
LOGFILE=bbed.log

———————————– bbed参数文件 ———————————–

SQL调优01–SQL优化介绍

Posted on 2012-01-14 by royalwzy

Introduction to SQL Tuning

SQL效率太低的原因:
1. Stale or missing optimizer statistics:缺失优化统计信息或者信息太旧;
2. Missing access structures:缺少索引,考虑索引的效率;
3. Suboptimal execution plan selection:不是最好的执行计划;
4. Poorly constructed SQL:SQL语句写的不好;
5. 最重要的是表的数据量太大,归档历史数据.小的数据量可以解决一切问题;
6. 解决办法:
  1. 尽量不要用子查询,可以通过关联查询解决;
  2. 不要再表列上面使用函数,导致索引无效;
  3. 如果发生隐式转换也不走索引,因为oracle内部总是转换表的列;
  4. 尽量使用UNION ALL而不用UNION;
  5. 排序,去重复,分组现在默认使用hash去除重复,对CPU消耗很大;
性能监控的解决方案;
Oracle中监控和调优的工具;
调优的工具:
1. Automatic Database Diagnostic Monitor (ADDM);
2. SQL Tuning Advisor;
3. SQL Tuning Sets;
4. SQL Access Advisor;
5. SQL Performance Analyzer;
6. SQL Monitoring;
7. SQL Plan Management:在11g中的工具,可以控制某个sql的执行计划;
SQL调优的任务:
1. 查找高负载的SQL语句;
2. 收集统计信息;
3. 收集系统统计信息;
4. 重建已存在的索引;
5. 维护执行计划;
6. 创建新的索引;
CPU和Wait Time的调优
1. db_time=cpu_time+wait_time;
2. 如果db_time增加,cpu_time和wait_time等比例增加,说明这是一个可扩展的系统,只需增加硬件即可;
3. 如果db_time增加,cpu_time远大于wait_time的增加,说明SQL效率不高,需要SQL的优化;
4. 如果db_time增加,cpu_time远小于wait_time的增加,说明内部有争用或者IO效率太低;
客户系统的常见问题:
1. Bad connection management:可以使用连接池解决;
2. Bad use of cursors and the shared pool:适当调大SGA和PGA,并指定动态管理;
3. Excess of resources consuming SQL statements:sql要反复执行;
4. Use of nonstandard initialization parameters:使用了隐含参数或者参数使用不当;
5. Poor database disk configuration:IO问题;
6. Redo log setup problems:至少使用三组在线日志组,每组设置足够大,保证20分钟切换一次;
7. Excessive serialization:串行化扫描,添加索引,尽量使用单列索引,可控性比较强;
8. Inappropriate full table scans:全表扫描,主要是加索引解决;
9. Large number of space-management or parse-related generated SQL statements:如果使用本地管理表空间的的话一般不会出现递归SQL;
10. Deployment and migration errors:部署时出错,这个是人为原因;
应用的设计:
1. 简化设计;
2. 数据模型:
  1. 主要还是要与业务逻辑相结合;
  2. 可以使用建模工具如Oracle Designer,但是最好是使用详细的文档;
  3. 考虑是OLTP系统还是DW系统;
3. 表设计:
  1. 考虑使用默认值,约束,物化视图,分区表等特性;
  2. 分区列一定要在where条件上,而且最好不要更新;
  3. 不建议使用触发器;,触发器的目的是做check,而不是做DML;
  4. 不建议使用外键,可以使用程序保证数据的完整性;
4. 索引设计:
  1. 索引的列一定要经常出现在WHERE后面;
  2. 在DW中建议使用外键,在OLTP中考虑到性能可以不用外键,加外键的话就一定要加索引;
5. 视图:
  1. 可以使用视图,但是最好不要嵌套视图;
  2. 嵌套视图影响执行计划;
Share Cursors
1. 尽量使用存储过程和函数;
2. cursor_sharing初始化参数尽量不要修改;

SQL调优04–阅读执行计划

Posted on 2012-01-14 by royalwzy

Interpreting Execution Plans

执行计划的解释:
1. SQL语句的执行计划是由语句中行源的执行计划组成;
2. 执行计划是使用父子关系来描述的,像一个树的结构;
如何查看执行计划:
1. PLAN_TABLE:是由EXPLAIN PLAN命令或者SQL/PLUS的autotrace产生的执行计划,是理论上的执行计划;
2. v$sql_plan:在Shared Pool中的Library Cache中保存的实际使用的执行计划;
3. v$sql_plan_monitor:11g中的执行计划监控;
4. dba_hist_sql_plan:由AWR报告产生的执行计划;
5. stats$sql_plan:是由Statspack生成的执行计划;
6. SQL Management Base:是由SQL Plan Management Baselines产生的执行计划;
7. SQL tuning set;
8. DBMS_MONITOR产生的trace文件:相当于10046事件;
9. 由10053事件产生的trace文件;
10. 10gR2之后的dump跟踪文件;
查看执行计划的视图:
1. 如果直接查看基表的话,根本无法直接看到执行计划间的关系,自己编写SQL语句查看很麻烦,可以使用DBMS_XPLAN包下面的函数来完成;
2. DBMS_XPLAN.DISPLAY():用来显示plan_table中的执行计划;
3. DBMS_XPLAN.DISPLAY_CURSOR():用来显示v$sql_plan中的执行计划;
4. DBMS_XPLAN.DISPLAY_AWR():用来显示AWR中的执行计划;
5. DBMS_XPLAN.DISPLAY_SQLSET():用来显示SQL tuning set中的执行计划;
6. DBMS_XPLAN.DISPLAY_SQL_PLAN_BASELINE():用来显示SQL Plan Management Baselines中的执行计划;
EXPLAIN TABLE命令:
1. 生成一个最优的执行计划,把它存在PLAN_TABLE中,但是并不实际执行SQL语句;
2. 语法:EXPLAIN PLAN [SET STATEMENT_ID = ‘text’] [INTO plan_table] FOR statement;默认插入到PLAN_TABLE表中;
3. PLAN_TABLE:
  1. 当执行EXPLAN_PLAN命令时自动创建PLAN_TABLE,它是一个同义词,指向sys.plan_table$的临时表;SELECT * FROM dba_synonyms WHERE synonym_name = ‘PLAN_TABLE’;SELECT table_name, TEMPORARY, duration FROM dba_tables WHERE table_name = ‘PLAN_TABLE$’;
  2. 可以根据$ORACLE_HOME/rdbms/admin/utlxplan.sql脚本创建自己的表,因为默认是临时表,只能在当前session查看,导入到自己的表中就可以永久保存;
  3. 优点是SQL语句么有真正执行;缺点是可能不是真正的执行计划,只有使用绑定变量时执行计划不准,其它情况都准确;
  4. 表中的内容是层级结构,可以通过ID和PAREANT_ID列来关联;
4. DBMS_XPLAN.DISPLAY函数语法:DBMS_XPLAN.DISPLAY(table_name, statement_id, format, filter_preds):
  1. table_name:默认是PLAN_TABLE表;
  2. statement_id:默认是空,可以根据这个参数获得指定的语句的执行计划;
  3. format:默认是TYPICAL类型,其他类型查帮助文档,显示的信息多少;
  4. 默认只查看上一条语句的执行计划;
  5. 查看指定statement_id的执行计划;
  6. 查看更多的执行计划的信息;
AUTOTRACE:
1. AUTOTRACE是sql*plus的功能,在oracle7.3版本后出现,也是把记录存放在PLAN_TABLE表中;
2. 需要PLUSTRACE角色从v$视图中检索统计信息,使用$ORACLE_HOME/sqlplus/admin/plustrce.sql脚本创建;
3. 默认情况下,在执行完查询语句后会生成执行计划和统计信息;
4. 相当于执行了一次EXPLAIN PLAN命令然后执行了一次语句,如果使用绑定变量的话可能不是真实的计划;
5. 语法:SET AUTOT[RACE] {OFF | ON | TRACE[ONLY]} [EXP[LAIN]] [STAT[ISTICS]];
  1. ON:要显示结果和trace信息;
  2. TRACEONLY:不显示结果;
6. 查看当前的设置:show autotrace;
阅读统计信息:
1. recursive calls:递归的调用,读取数据字典,权限,列的信息.第一次执行会很大,以后执行会变小;如果使用存储过的话,这个值一般会很大,属于正常;可以通过清除shared_pool测试:alter system flush shared_pool;
2. db block gets:修改当前状态的数据块的block的块数.只有当DML语句会引起db block gets增加,因为当前块会被更新,SELECT语句的话不会增加,因为可以读取REDO或者构造的CR块;
3. consistent gets:逻辑读的数量(不是BLOCK),表示返回记录的批次数,跟当前的arraysize有关;
  1. arraysize:表示一次返回的记录数,通过show arraysize命令查看;
  2. 粗略是算法是:consistent gets=rows processed/arraysize,记录越多越接近;
  3. 优化时应该关心在相同的arraysize下减小此值,即减小逻辑读;
4. physical reads:物理读,即从硬盘读取的BLOCK的数量,BUFFER CACHE越大这个值越小,可以通过清除BUFFER CACHE测试:alter system flush buffer_cache;
5. redo size:产生的日志的数量,一般DML语句才会产生;
6. bytes sent via SQL*Net to client:服务器发送到客户端的字节数;
7. bytes received via SQL*Net from client:服务器接收到客户端的字节数;
8. SQL*Net roundtrips to/from client:SQL的网络流量的次数,也跟arraysize参数有关;
9. sorts (memory):内存中的排序数量,主要是PGA;
10. sorts (disk):在硬盘的排序,应该避免这个值;
11. rows processed:处理的记录数;
v$sql_plan:
1. v$sql_plan:查看library cahce中真正使用的执行计划;PLAN_TABLE只是理论上的执行计划;
2. 可以通过sql_id列与v$sql表关联,也可以使用address和hash_value的值;
3. 主要的列:
  1. HASH_VALUE:父语句在library cache中的哈希值;
  2. ADDRESS:访问SQL语句的句柄,即内存地址;
  3. CHILD_NUMBER:使用此执行计划的子CURSOR数量;
  4. POSITION:具有相同PARENT_ID的操作的执行顺序;
  5. PARENT_ID:跳出过程的下一个执行的过程ID,这个很抽象,看到执行计划,很容易理解这一点;
  6. ID:每一个步骤的编号;
  7. PLAN_HASH_VALUE:执行计划的哈希值;
4. 查看实际的执行计划:SELECT * FROM table(DBMS_XPLAN.DISPLAY_CURSOR(‘sql_id’));
5. v$sql_plan_statistics:提供实际执行时的统计信息
  1. 当STATISTICS_LEVEL设置为ALL时才会收集;
  2. 或者语句中指定了GATHER_PLAN_STATISTICS的hint;
  3. v$sql_plan_statistics_all:获得所有的实际执行的统计信息;
6. v$sql_workarea:提供了SQL CURSOR使用的工作区的信息;
AWR:
1. AWR是为了检测和自调整为目的的收集,处理,维护性能统计信息;
2. 统计信息包括:
  1. 对象统计信息;
  2. 时间模型统计信息;
  3. 一些系统和session的统计信息;
  4. ASH(Active Session History)统计信息;
3. 自动生成性能数据的快照;
4. 重要的AWR视图:
  1. V$ACTIVE_SESSION_HISTORY;
  2. V$metric views;
  3. DBA_HIST views:
    1. DBA_HIST_ACTIVE_SESS_HISTORY;
    2. DBA_HIST_BASELINE;
    3. DBA_HIST_DATABASE_INSTANCE;
    4. DBA_HIST_SNAPSHOT;
    5. DBA_HIST_SQL_PLAN;
    6. DBA_HIST_WR_CONTROL;
5. 指定sql_id查看AWR中的sql的执行计划: SELECT plan_table_output FROM TABLE(DBMS_XPLAN.DISPLAY_AWR(‘g22czkqq3pxmb’));
6. 从AWR数据生成一个SQL报告:@$ORACLE_HOME/rdbms/admin/awrsqrpt;
SQL Monitoring:11g;
阅读执行计划:
1. 读执行计划的顺序:
  1. 从上往下看,第一个没有儿子节点的节点最先执行;
  2. 执行执行其兄弟节点;
  3. 最后执行父节点;
2. 就是二叉树中的后序遍历的方式:
  1. 前序遍历:对任一子树,先访问根,然后遍历其左子树,最后遍历其右子树;
  2. 中序遍历:对任一子树,先遍历其左子树,然后访问根,最后遍历其右子树;
  3. 后序遍历:对任一子树,先遍历其左子树,然后遍历其右子树,最后访问根;
3. 例子:
  1. 执行的顺序为:356421;
  2. 执行的顺序为:43652871;
  3. 执行顺序为:325410;
4. 查看执行计划的建议:
  1. 要使驱动表保持最好的过滤条件,即驱动表有最小的记录;
  2. 每一步返回的数据尽量最小;
  3. 正确使用视图,只是用一层,尽量不要嵌套;
  4. 避免使用笛卡尔积;
仅仅靠一个执行计划不能说明它是否是最好的,可以借助SQL Tuning Advisor工具;

SQL调优03–执行计划的访问路径

Posted on 2012-01-14 by royalwzy

Optimizer operators

行源操作
1. Unary Operations:一元运算,即单表的查询;
2. Binary Operations:二元运算,两表的连接;
3. N-ary Operations:多元运算;
主要的结构和访问路径:
1. 表:
  1. Full Table Scan;
  2. Rowid Scan:很少使用,多用在内部的某一个步骤;
  3. Sample Table Scan:很少使用;
2. 索引:
  1. Index Scan(Unique);
  2. Index Scan(Range);
  3. Index Scan(Full);
  4. Index Scan(Fast Full);
  5. Index Scan(Skip);
  6. Index Scan(Index Join);
  7. Using Bitmap Indexes;
  8. Combining Bitmap Indexes;
索引的基本概念:
1. B-Tree Indexes:平衡树索引,最常见的索引;
  1. 正常索引;
  2. 基于函数的索引:
    1. 创建函数索引相当于在表上添加一个伪列;
    2. 查看定义;
  3. IOT(Index-Organized Table):将表结构整体放入索引中,而且按照主键进行排序,一定要有主键,非主键的列一定要落在索引条目里;
  4. Bitmap Indexes;
    1. 可以索引空值;
    2. 适当发生转换:TO ROWIDS/FROM ROWIDS/COUNT;
    3. 可以进行的操作:MERGE/AND/OR/MINUS/KEY ITERATION,位运算的速度很快;
    4. 位图索引可以进行SINGLE VALUE/ RANGE SCAN/ FULL SCAN扫描;
    5. 缺点是位图索引不能经常更新,效率很差;
  5. Cluster Indexes;
    1. 如果要做两个表的关联查询则最少查询两个块;
    2. CLUSTER把两个表按照关联的字段把记录存放在同一个块上;这样只用查一个块即可;查找时效率提高一倍;
    3. 用在总是关联查询两个表的情况,一般是不用的;ORACLE内部大量使用;
    4. cluster上的索引不能指定列,必须使用所有的列;
    5. 基于cluster的表没有segment;
2. 索引的属性:
  1. 键压缩;
  2. 反转键值(考点):可以防止索引块争用(buffer busy wait),只支持等式连接,不支持范围扫描;
  3. 顺序/倒序;
3. 索引和NULL值:
  1. NULL值与索引的关系:
    1. 基于单列的唯一索引,可以多次插入NULL值(NULL <> NULL),因为索引并不存储NULL值;
    2. 基于多列的符合索引,尽管全为NULL的值可以多次插入([NULL, NULL] <> [NULL, NULL]),索引也不会存储,但不全为NULL的重复行则不能重复插入,;
  2. NULL值与执行计划:
    1. 如果列的属性允许为NULL,条件为IS NULL的话,肯定走全表扫描,因为索引不保存NULL值;
    2. 如果列的属性允许为NULL,条件为IS NOT NULL的话,会走全索引扫描;
    3. 如果列的属性为NOT NULL,条件为IS [NOT] NULL的话,走索引扫描;
    4. 组合索引的话,如果条件中只出现一列的话跟单列索引一样;
    5. 组合索引的话,如果条件中出现两列,会优先选择走索引;
  3. IS NULL使用索引的办法:
    1. 在NULL的列上创建函数索引:nvl(column_name, -1),查询的时候条件指定函数索引: where nvl(column_name, -1) = -1;
    2. 为NULL的列添加默认值;
4. 索引的管理:
  1. 插入数据后再创建索引,对于DW来言;
  2. 在适当的表和列上加索引;
  3. 注意组合索引的顺序;
  4. 控制索引的数量:每添加一个索引,DML的效率下降3倍,官方推荐最多加7个索引;
  5. 删除不使用的索引;
  6. 为索引指定单独的表空间;
  7. 创建索引时使用并行,NOLOGGING参数;
  8. COALESCING是合并相邻叶子节点,rebuild则可以减少索引树的高度;
5. 检测索引是否被使用了:
  1. 添加对某个索引的监控:ALTER INDEX EMP_EMP_ID_PK MONITORING USAGE;
  2. 查看监视的对象使用情况:SELECT * FROM v$object_usage;默认是没有任何的监视的;
  3. 使用此索引后再查看;
  4. 取消索引监控:ALTER INDEX EMP_EMP_ID_PK NOMONITORING USAGE;
  5. 缺点:每次只能添加一个索引,而且不记录索引使用的次数;
  6. 不使用索引的原因:
    1. 被检索的列上用了函数;
    2. 数据类型不匹配;发生隐士转换是转化左边的列,而不是右边的列;
    3. 统计信息是否最新;
    4. 列是否是空值;
    5. 索引效率太低;
各种访问路径的原理及使用场景:
1. Full Table Scan:
  1. 会执行Multiblock Reads,参考初始化参数:db_file_multiblock_read_count;
  2. 会读取HWM(High-Water Mark)以下所有被格式化的块;
  3. 过程中可能会过滤某些记录;
  4. 用在要获得大量记录的时候,比索引扫描更快;
  5. 使用的场景:
    1. 没有合适的索引;
    2. 过滤条件不好,甚至是没有过滤条件;
    3. 表太小,记录数很少;
    4. 需要并行扫描,并行扫描一定不走索引,如果确定是全表的话可以考虑并行:SELECT /*+ PARALLEL(d 4) */ * FROM departments d;
    5. 加全表扫描的hint时:SELECT /*+ FULL (d)*/ * FROM departments d WHERE department_id = 10;
    6. IS NULL的操作;
2. ROWID Scan:
  1. 根据记录的rowid查询,最快的访问方式,但不经常使用,可能会出现在执行计划的某个步骤中;
  2. 使用的方法:
3. Sample Table Sacns:基本不用,SELECT * FROM departments SAMPLE BLOCK (10) SEED (1);
4. Index Unique Scan:条件中指定了主键列或者唯一键的列就走唯一键扫描;
5. Index Range Sacn:
  1. 过滤的条件上不是主键/唯一索引,就会走索引范围扫描;
  2. 如果对有索引的列排倒序就会有索引倒序扫描;(因为索引本身是排序的,所以执行计划中不会有排序的步骤,按照索引列排序效率会高;)
  3. 走函数索引的例子,也是索引范围扫描的一种;
6. Index Full Sacn vs Index Fast Full Sacn:
  1. 出现的条件:
    1. SELECT与WHERE子句出现的所有的列必须存在索引,而且为非空列,因为索引不存放NULL值;
    2. 返回的数据总行占据索引的10%以上的比例;
  2. Index Full Sacn:
    1. 完全按照索引存储的顺序依次访问整个索引树,当访问到叶子节点时,按照双向链表方式读取相连的节点值;
    2. 使用Single Read,会产生db file sequential reads事件;
    3. 对于索引列上的排序,总是会使用Index Full Scan;
    4. 索引列上is not null的操作,会走全索引扫描;
  3. Index Fast Full Sacn:
    1. 对于索引的分支结构只是简单的获取,然后扫描所有的叶节点,导致索引结构没有访问,获得的数据没有根据索引键的顺序排序,读取效率高.但是如果SQL语句中有排序操作的话,还要额外多做一次排序;
    2. 在使用Index Fast Full Sacn时,使用Multiblock Read,会产生db file scattered reads,db_file_multiblock_read_count参数的设置很重要;
    3. 统计行数,如count(*)的操作总是会使用Index [Fast] Full Scan的;
    4. 会使用大量的内存和CPU资源;
  4. Index [Fast] Full Scan的例子;
7. Index Skip Scan:
  1. 创建了复合索引,但是条件中只有复合索引中的第二列,而且当第一列的distinct值不多时,会发生跳跃扫描;
  2. 创建一个测试表,和一个联合索引,当第一列可选值少而条件中只查找第二列时,发生跳越扫描;
  3. 如果第一列的可选值很多,条件中查找第二列的话,发生全表扫描;
8. Index Join Scan:查询的列都不为空,而且都有索引才会出现联合扫描;
9. AND-EQUAL操作:两列都有索引,分别扫描两列获得记录的rowid,然后再取rowid的交集;
10. Bitmap Index:
  1. Bitmap的单值扫描;
  2. Bitmap的范围扫描;
  3. Bitmap的迭代操作操作;
  4. Bitmap的AND操作;
排序操作:
1. Sort Operator:
  1. AGGREGATE:在group操作用会用到,统计结果;
  2. UNIQUE:评估是否重复;
  3. JOIN:做合并操作;
  4. GROUP BY,ORDER BY:在group by和order by的时候使用;
2. Hash Operator:
  1. GROUP BY:在group by操作时使用;
  2. UNIQUE:跟SORT UNIQUE一样;
3. 10g之后结果默认不排序,如果想要排序后的结果,应该总是使用ORDER BY字句;
Buffer Sort:
1. BUFFER SORT不是一种排序,而是一种临时表的创建方式;
2. BUFFER表示在内存中存放了一张临时表;
3. SORT来修饰BUFFER表示具体再内存的什么地方:在PGA的SQL工作区的排序区;
4. BUFFER SORT的例子:
INLIST ITERATOR:
1. 是由于IN操作引起的,要关注迭代的次数,一次迭代就要有一次访问,如果没有索引可能性能问题会很严重;
2. 可以使用UNION ALL操作代替;
3. INLIST ITERATOR的例子;
视图的操作:
1. Merge View:是将View的定义和外部查询合并,高效的方式;
2. No Merge View:先将View的数据取出来再做外部条件的过滤,效率低;
执行计划中的Count和Count Stopkey:oracle数据库的优化关于rownum操作;
1. 在查询中有时使用到伪列rownum,对使用伪列rownum的查询,优化器要么使用count操作,要么使用count stopkey操作来对rownum计数器进行增量(注意:这里的count操作和count stopkey操作与count函数没有任何关系).如果对rownum伪列应用一个限定条件,如:where rownum<10,则使用count stopkey操作;如果不为Rownum伪列指定限定条件,则是使用count操作;
2. 不在Rownum伪列上使用限定条件:SELECT employee_id, ROWNUM FROM employees;(employee_id是主键)为了完成这个查询,优化器执行一个全索引扫描(主键索引),后跟一个count操作生成每个行的rownum值,count操作不需要等待得到整个记录集,随着从employee表中返回记录,rownum计数器进行增量,从而确定每个记录的rownum;
3. 在rownum伪列上使用一个限定:SELECT employee_id, ROWNUM FROM employees WHERE ROWNUM < 10;为了实施限定条件,优化器用count stopkey操作代替count操作,它将rownum伪列的增量值与限定条件中指定的值进行比较,如果rownum伪列的值大于限定条件中指定的值,则查询不再返回更多的行;
4. 在where子句中不能使用rownum>10这样的操作,只能使用rownum<10这样的操作;
Min/Max and First Row操作:当使用MAX/MIN函数时发生;
连接的方式:
1. 一个连接定义了两个行源的关系,也是合并两个行源间数据的方法;
2. 主要由连接的谓词所控制,定义了对象间的关系;
3. 连接的方法:
  1. Nested Loops:
    1. 对于被连接的数据子集较小的情况,嵌套循环是个较好的选择;
    2. 返回第一条记录最快的方式;
    3. 这种情况下,内表被外表驱动,外表返回的每一行都要在内表中检索找到它匹配的行,因此整个查询返回的结果集不能太大(eg:<1w);
    4. 要把返回子集较小的表作为驱动表,而且内标的连接字段上一定要有索引;
    5. 使用USE_NL(table_name1 table_name2)可是强制CBO执行嵌套循环连接;
  2. Sort-Merge Join:
    1. 通常情况下散列连接的效果都比排序合并连接要好,然而如果行源已经被排过序,在执行排序合并连接时不需要再排序了,这时排序合并连接的性能会优于散列连接;
    2. 可以使用USE_MERGE(table_name1 table_name2)来强制使用排序合并连接;
    3. Sort Merge join使用的情况:
      1. 用在没有索引;
      2. 数据已经排序的情况;
      3. 不等价关联;
      4. HASH_JOIN_ENABLED=FALSE;
  3. Hash Join:
    1. 散列连接是CBO做大数据集连接时常用的方式,优化器使用两个表中较小的表(行源)利用连接键在内存中建立散列表,然后扫描较大的表并探测散列表,找出与散列表匹配的行;
    2. 这种方式适用于较小的表完全可以放于内存中的情况,这样总成本就是访问两个表的成本之和,但是在表很大的情况下并不能完全放入内存,这时优化器会将它分割成若干不同的分区,不能放入内存的部分就把该分区写入磁盘的临时段,此时要有较大的临时段从而尽量提高I/O的性能;
    3. 也可以用USE_HASH(table_name1 table_name2)提示来强制使用散列连接,如果使用散列连接HASH_AREA_SIZE初始化参数必须足够的大,如果是10g以后,Oracle建议使用SQL工作区自动管理,设置WORKAREA_SIZE_POLICY 为AUTO,然后调整PGA_AGGREGATE_TARGET即可;
4. 连接方式的比较:
  1. Hash join的工作方式是将一个表(通常是小一点的那个表)做hash运算,将列数据存储到hash列表中,从另一个表中抽取记录,做hash运算,到hash列表中找到相应的值,做匹配;
  2. Nested loops工作方式是从一张表中读取数据,访问另一张表(通常是索引)来做匹配,nested loops适用的场合是当一个关联表比较小的时候,效率会更高;
  3. Merge Join 是先将关联表的关联列各自做排序,然后从各自的排序表中抽取数据,到另一个排序表中做匹配,因为merge join需要做更多的排序,所以消耗的资源更多,通常来讲,能够使用merge join的地方,hash join都可以发挥更好的性能,Merge Join太消耗PGA;
5. 连接的类型:
  1. [不]等值连接和自然连接;
  2. 外连接:全连接,左外连接,右外连接;(外连接:+号放那边,哪边记录少;)
  3. 半连接:EXISTS子句;
  4. 反连接:NOT IN字句;
多行源的操作
1. FILTER;
2. CONCATENATION;
3. UNION [ALL]
4. INTERSECT;
5. MINUS;

— Full Table Scan;

SELECT * FROM departments WHERE manager_id = 100;

SELECT /*+ PARALLEL(d 4) */ * FROM departments d;

SELECT * FROM departments d WHERE department_id = 10;
SELECT /*+ FULL (d)*/ * FROM departments d WHERE department_id = 10;

— ROWID Sacn;

SELECT * FROM departments WHERE ROWID = ‘AAAMiZAAFAAAAA4AAI’;
SELECT * FROM departments WHERE ROWID = (
SELECT rowid FROM departments WHERE manager_id = 100);

— 函数索引的例子;

CREATE INDEX idx_employees_fun_firstname ON employees (upper(first_name));
SELECT * FROM user_tab_cols WHERE table_name = ‘EMPLOYEES’;
SELECT * FROM user_ind_expressions WHERE index_name = ‘IDX_EMPLOYEES_FUN_FIRSTNAME’;

— Index Skip Scan的例子;
CREATE TABLE skip_test AS
SELECT object_id, object_name, decode(object_type, ‘VIEW’, ‘VIEW’, ‘TABLE’) AS object_flag, object_type
FROM dba_objects WHERE ROWNUM <= 3000;
CREATE INDEX idx_skip_test ON skip_test(object_flag, object_id);
EXEC dbms_stats.gather_table_stats(USER, ‘skip_test’, CASCADE => TRUE);
SELECT * FROM skip_test WHERE object_id = 100;
— 如果联合索引第一列的候选值太多,则发生全表扫描;
DROP INDEX idx_skip_test;
CREATE INDEX idx_skip_test ON skip_test(object_type, object_id);
EXEC dbms_stats.gather_table_stats(USER, ‘skip_test’, CASCADE => TRUE);
SELECT * FROM skip_test WHERE object_id=100;

— 位图索引的例子;

CREATE TABLE bitmap_test AS
SELECT ROWNUM rn, MOD(ROWNUM, 4) bit,
CASE MOD(ROWNUM, 2) WHEN 0 THEN ‘M’ ELSE ‘F’ END gender
FROM dual CONNECT BY ROWNUM < 1000;
CREATE BITMAP INDEX bmp_bitmap_bit on bitmap_test (bit);
CREATE BITMAP INDEX bmp_bitmap_gender on bitmap_test (gender);
EXEC dbms_stats.gather_table_stats(USER, ‘bitmap_test’, CASCADE => TRUE);
ALTER SESSION optimizer_mode = ‘FIRST_ROWS_1000’;
SELECT * FROM bitmap_test WHERE bit = 3;
SELECT * FROM bitmap_test WHERE bit > 2;
SELECT * FROM bitmap_test WHERE bit IN (2, 3);
SELECT * FROM bitmap_test WHERE bit IN (2, 3) AND gender = ‘M’;

SQL调优02–CBO优化器的原理

Posted on 2012-01-14 by royalwzy

Intorduction to the CBO Optimizer

介绍CBO优化器的书:Jonathan Lewis写的<<Cost-Based Oracle Fundamentals>>;
结构化查询语言的类型:
1. DML(Data Manipulation Language):INSERT, UPDATE, DELETE, MERGE, SELECT;
2. DDL(Data Definition Language):CREATE, DROP, ALTER, RENAME, TRUNCATE, GRANT, REVOKE, AUDIT, NOAUDIT, COMMENT;
3. ESS(Environmental Sustainability Statement):DECLARE, CONNECT, OPEN, CLOSE, DESCRIBLE, WHENEVER, PREPARE, EXECUTE, FETCH;
4. TCS(Transactoin Control Statement):COMMIT, ROLLBACK, SAVEPOINT, SET TRANSACTION;
5. SystemCS(System Control Statement):ALTER SYSTEM;
6. SessionCS(Session Control Statement):ALTER SESSSION, SET ROLE;
SQL语句的实现过程:相同的SQL语句可以使用相同的执行计划;
Cursor
1. PL/SQL中的cursor:记录行的rowid,用来表示结果集;
2. sql解析过程中的cursor:是SHARED POOL中的内存块;
SQL语句的处理过程:
1. Create a cursor:
  1. Cursor是private SQL area的句柄或者名称;
  2. 其中包含了语句执行的信息;
  3. Cursor的结构与它包含SQL语句是互相独立的;
2. Parse the statement:
  1. SQL语句通过用户进程发送到Oracle实例;
  2. 在PGA中检查语法和语义,然后检查权限,分配private SQL area,然后检查是否已经在Library Cache中存在,如果没有的话,会把sql放入到Shared SQL area中,产生硬解析;
  3. 如果SQL的执行计划已经存在的话可以被重用;
3. Describe query results:
  1. 提供了SELECT后面的要查找的列的信息,与动态执行SQL有关;
  2. 9i时使用DBMS_SQL包,之后使用EXECUTE IMMEDIATE来动态执行SQL;
4. Define query output:定义要查找的列的位置,大小,数据类型信息;
5. Bind variables:
  1. 开启内存地址来保存数据的值;
  2. 允许共享sql;
6. Parallelize the statement:
  1. 可以并行的语句:SELECT, INSERT, UPDATE, MERGE, DELETE, CREATE, ALTER;
  2. 11g中自动判断是否需要并行;
7. Execute the statement:执行SQL语句,产生想要的结果;
8. Fetch rows of a query:以表格的形式返回数据;
9. Close the cursor:关闭游标,PGA中指向cursor的指针关闭,但是内存区域还是被占用,之后可以被覆盖;
10. 使用DBMS_SQL包可以看到完整的SQL执行的过程;
SQL语句解析的过程;
需要优化器的理由:它可以选择一种资源消耗最小的方式;
硬解析的操作步骤:
Transformer
1. 优化器首先会把语句分成一个一个的查询块,然后进行转换;
2. 虽然进行了转换操作以提高效率,但是在内存中保存的还是原来的SQL语句;
3. OR转换为UNION ALL操作;
4. IN转换为内连接操作(11g);
5. IN改写为exists;
6. NOT IN改写为外连接+IS NULL,11g中自动转换,10g中需要修改;
7. IN改写为外连接+IS NOT NULL;
8. 视图合并:查询的时候直接查询视图中的基表,非常适合于视图的记录数很大,查询视图的记录数小的情况;
9. 视图不合并:查询时把制图当成基表,这样效率比较低.CBO会自动合并第一层的视图,所以不要使用嵌套视图;
10. Predicate Pushing:把条件推到最查询的最低端;
11. 条件的传递性:employees的department_id列没有索引,department表department_id列是主键,转换过之后就会先走主键扫描;
Cost-Based Optimizer
1. 由Estimator和Plan Generator组成;
2. Estimator决定执行计划的成本消耗的建议;
  1. 它是基于概率论的,理论依据是数据是均匀分布的;
  2. 它的基础数据是定期收集并存放在数据字典的统计信息;
3. Plan Generator:
  1. 产生各种不同的执行计划;
  2. 使用Estimator计算各个执行计划的成本;
  3. 基于成本选择最好的优化建议;
  4. 生成最优的执行计划;
4. OPTIMIZER_MODE的两个参数:ALL_ROWS, FIRST_ROWS_n:
  1. FIRST_ROWS_n:
    1. CBO优先考虑将结果集中的前N条记录以最快的速度返回,而其它的结果集并不需要同时返回;
    2. 可以使用在BBS的分页上:SELECT /*+ first_rows(10) */ FROM tbname;
    3. 这种执行计划对于SQL整体的执行时间不是最快的,但是在返回前N条记录的处理上绝对是最快的;
    4. 使用的排序字段必须有索引,否则CBO会忽略FIRST_ROWS(n),而使用ALL_ROWS;
  2. ALL_ROWS:
    1. CBO考虑最快的速度返回所有的结果集,和FIRST_ROWS_n相反;
    2. 在OLAP系统中使用较多,总体效率高;
Estimator
1. Selectivity:选择度;
  1. Selectivity is the estimated proportion of a row set retrieved by a particular predicate or combination of predicates;选择度是由一个特定的谓词或者组合谓词检索行集的估计比例;
  2. 计算公式:Selectivity=满足条件的记录数/总记录数;
  3. 它的取值在0.0-1.0之间:
    1. High Selectivity:得到大比例的记录数;
    2. Low Selectivity:得到小比例的记录数;
  4. 如何获得Selectivity:
    1. 如果没有统计信息则采用动态采样(Dynamic Sampling);
    2. 如果没有直方图信息则采用行分布;
  5. 存放统计信息的视图:
    1. dba_tables;
    2. dba_tab_statistics(NUM_ROWS, BLOCKS, AVG_ROW_LEN);
    3. dba_tab_col_statistics(NUM_DISTINCT, DENSITY, HIGH/LOW_VALUE);
2. Cardinality:基数;
  1. 通过执行计划期望能检索出来的记录数;
  2. 计算公式:Cardinality=Selectivity*总记录数;
  3. 对于join, filters和sort的成本是重要的指标;
3. 举例:SELECT * FROM hr.employees WHERE job_id = ‘SH_CLERK’;
  1. employees表的job_id列的取值个数为:19;
  2. employees表中的记录数:107;
  3. Selectivity=1/19=0.0526315789473684,即DENSITY的值;
  4. Cardinality=(1/19)*107=5.63,向上取整为6;
4. Cost:
  1. Cost是执行特定的语句所花费的标准I/Os数量的最优评估;
  2. Cost的单位是一个标准块的随机读取:1 cost unit = 1 SRds(Standardized Random Reads);
  3. 执行计划中Cost(%CPU):一次IO读取一个IO块需要的时间;
  4. Cost的值由三部分组成;
控制优化器的初始化参数:
1. CURSOR_SHARING:SIMILAR|EXACT(default)|FORCE,控制可以共享Cursor的SQL语句类型;
2. DB_FILE_MULTIBLOCK_READ_COUNT:它是一个可以在表扫描时最小化IO的参数,指定了在顺序扫描时一次IO操作可以读取的最大的块数;(在OLTP系统中一般指定4-16,在DW系统中可以尽量设置的大一点);
3. PGA_AGGREGATE_TARGET:PGA自动管理时指定server processes可以使用的PGA内存的总和;
4. STAR_TRANSFORMATION_ENABLED:参数设置为TRUE时使用CBO可以使用位图索引的特性,不过貌似现在这个参数不重要;
5. RESULT_CACHE_MODE:MANUAL,FORCE,11g
6. RESULT_CACHE_MAX_SIZE:11g;
7. RESULT_CACHE_MAX_RESULT:11g;
8. RESULT_CACHE_REMOTE_EXPIRATION:11g;
9. OPTIMIZER_INDEX_CACHING:在Buffer Cache中缓存索引的比例,默认为0;
10. OPTIMIZER_INDEX_COST_ADJ:索引扫描/全表扫描的成本,默认为100%,即索引扫描成本等于全表扫描成本;优先会选择全表扫描;比较悲观的配置;
11. OPTIMIZER_FEATURES_ENABLE:希望启用哪个版本的CBO;
12. OPTIMIZER_MODE:ALL_ROWS|FIRST_ROWS|FIRST_ROWS_n
  1. 默认是all_rows:资源消耗比较小;
  2. first_rows_n:n的取值为1|10|100|1000,速度优先,但是消耗很大的资源;
13. OPTIMIZER_CAPTURE_SQL_PLAN_BASELINES;
14. OPTIMIZER_USE_SQL_PLAN_BASELINES;
15. OPTIMIZER_DYNAMIC_SAMPLING:动态采样的特性,10g后默认为2;
16. OPTIMIZER_USE_INVISIBLE_INDEXES;
17. OPTIMIZER_USE_PENDING_STATISTICS;
OPTIMIZER_INDEX_COST_ADJ参数设置的例子:
1. 首先创建表,索引,并收集统计信息;
2. 打开执行计划,执行查询语句,默认的值为100%,即索引扫描成本等于全表扫描成本,则执行计划走全表扫描;
3. 修改参数值为50,即索引扫描成本是全表扫描成本的1/2,查看执行计划;
Selectivity值的例子:
1. 因为CBO是基于数据均匀的概率分布的,所以它估计的Selectivity是一个理论值;
2. 创建一个1200条记录的表,里面的值分布是1-12,代表1-12月出生的人;
3. 如果要查找某个月份出生的人,那么在不明白任何情况下,每个月份出生的人的概率都是1/12,即有100个人,CBO也是这么思考问题的;
4. 实际值往往跟理论值不相符,但是数据量越大,越接近;
10053事件测试:
1. 开启10053事件,并执行一条sql语句;
2. 查看当前的session_id和process_id来确定生成的内容是放在哪个udump文件中;
3. 查看udump文件,里面包含了一些缩写的含义和当前生效的优化参数的值;
4. 关闭10053事件;

— Estimator例子的脚本;

SELECT * FROM hr.employees WHERE job_id = ‘SH_CLERK’;

SELECT COUNT(DISTINCT job_id) FROM hr.employees;

SELECT owner, table_name, column_name, num_distinct, density
FROM dba_tab_col_statistics
WHERE owner = ‘HR’ AND table_name = ‘EMPLOYEES’ AND column_name = ‘JOB_ID’;

SELECT owner, table_name, num_rows, blocks, avg_row_len
FROM dba_tab_statistics
WHERE owner = ‘HR’ AND table_name = ‘EMPLOYEES’;

— OPTIMIZER_INDEX_COST_ADJ参数的例子;

CREATE TABLE t1 AS
SELECT MOD(ROWNUM, 200) n1, MOD(ROWNUM, 200) n2
FROM dba_objects WHERE ROWNUM <= 3000;
CREATE INDEX t_i1 ON t1(n1);
EXEC dbms_stats.gather_table_stats(USER, ‘t1’, CASCADE=>TRUE);
SET autotrace traceonly exp;
SELECT * FROM t1 WHERE n1 = 50;
ALTER SESSION SET optimizer_index_cost_adj = 50;
SELECT * FROM t1 WHERE n1 = 50;

— Selectivity的例子;

CREATE TABLE t2(ID, month_id) AS
SELECT ROWNUM, trunc(dbms_random.value(1, 13))
FROM dba_objects WHERE ROWNUM <= 1200;
EXEC dbms_stats.gather_table_stats(USER, ‘t2’, CASCADE => TRUE);
SET autotrace traceonly exp;
SELECT * FROM t2 WHERE month_id = 5;
SELECT COUNT(*) FROM t2 WHERE month_id = 5;

— 10053时间测试例子;

ALTER SYSTEM/SESSION SET EVENTS ‘10053 trace name context forever, level 8’;
SELECT * FROM employees WHERE employee_id = 100;
ALTER SYSTEM/SESSION SET EVENTS ‘10053 trace name context off’;
SELECT s.sid, p.spid FROM v$session s
INNER JOIN v$process p ON s.paddr = p.addr AND
s.sid = (SELECT sid FROM v$mystat WHERE ROWNUM = 1);

ORACLE中工具的使用06–ORADEBUG

Posted on 2012-01-14 by royalwzy

oradebug工具的使用:

oradebug主要是给oracle支持人员使用的,从8i开始,它是个sql*plus命令行工具,有sysdba的权限就可以使用,无需特别设置,主要用途为:
1. 追踪进程,自己的或者是外部的;
2. 确定进程写入哪个trc文件;
3. 转储:数据文件头,内部oracle结构等;
4. 暂时挂起进程;
5. 确定实例使用了哪些共享内存块和信号量;
6. 找出RAC实例使用了哪些互联地址和协议;
7. 修改SGA中的数据结构;
oradebug使用步骤:
1. 启动sql*plus并以sysdba身份登入;
2. 连接到一个进程;
3. 设置一个事件或者进行诊断转储;
4. 查看trc文件名;
5. 与连接到的进程断开;
oradebug的语法;
连接到一个进程的方法:
1. oradebug setmypid:连接到当前的进程:
2. oradebug setorapid pid:根据pid,连接到其它进程(v$process.pid);
3. oradebug setospid spid:根据spid,连接到其它进程(v$process.spid);
查看共享信息内存方法:ipcs [-m|-s|-q],默认会列出共享内存,信号量,队列信息;
1. 清除命令是ipcrm [-m|-s|-q] id;
2. 参数:
  1. -m:列出共享内存信息;
  2. -s:列出共享信号量信息;
  3. -q:列出共享队列信息;
3. 例子;
如果一个程序挂起,那么程序调用栈就可以显示它在调用路径中的哪一步挂起的:oradebug short_stack;
文件转储:
1. 可以转储的类型:oradebug dmplist;
2. 转储控制文件:oradebug dump controlf 10;
3. 实现10046事件,例子;
4. oradebug dump events的级别和范围:
  1. level 1,会话级别,对应alter session命令;
  2. level 2,进程级别,对应oradebug event命令;
  3. level 4,实例级别,对应alter system命令;
oradebug对于解决问题和诊断性能是必不可少的工具;

——————————– oradebug语法 ——————————–

sqlplus / as sysdba

SQL> oradebug help
HELP           [command]                 Describe one or all commands
SETMYPID                                 Debug current process
SETOSPID       <ospid>                   Set OS pid of process to debug
SETORAPID      <orapid> [‘force’]        Set Oracle pid of process to debug
SETORAPNAME    <orapname>                Set Oracle process name to debug
SHORT_STACK                              Get abridged OS stack
CURRENT_SQL                              Get current SQL
DUMP           <dump_name> <lvl> [addr] Invoke named dump
DUMPSGA        [bytes]                   Dump fixed SGA
DUMPLIST                                 Print a list of available dumps
EVENT          <text>                    Set trace event in process
SESSION_EVENT <text>                    Set trace event in session
DUMPVAR        <p|s|uga> <name> [level] Print/dump a fixed PGA/SGA/UGA variable
DUMPTYPE       <address> <type> <count> Print/dump an address with type info
SETVAR         <p|s|uga> <name> <value> Modify a fixed PGA/SGA/UGA variable
PEEK           <addr> <len> [level]      Print/Dump memory
POKE           <addr> <len> <value>      Modify memory
WAKEUP         <orapid>                  Wake up Oracle process
SUSPEND                                  Suspend execution
RESUME                                   Resume execution
FLUSH                                    Flush pending writes to trace file
CLOSE_TRACE                              Close trace file
TRACEFILE_NAME                           Get name of trace file
LKDEBUG                                  Invoke global enqueue service debugger
NSDBX                                    Invoke CGS name-service debugger
-G             <Inst-List | def | all>   Parallel oradebug command prefix
-R             <Inst-List | def | all>   Parallel oradebug prefix (return output
SETINST        <instance# .. | all>      Set instance list in double quotes
SGATOFILE      <SGA dump dir>         Dump SGA to file; dirname in double quotes
DMPCOWSGA      <SGA dump dir> Dump & map SGA as COW; dirname in double quotes
MAPCOWSGA      <SGA dump dir>         Map SGA as COW; dirname in double quotes
HANGANALYZE    [level] [syslevel]        Analyze system hang
FFBEGIN                                  Flash Freeze the Instance
FFDEREGISTER                             FF deregister instance from cluster
FFTERMINST                               Call exit and terminate instance
FFRESUMEINST                             Resume the flash frozen instance
FFSTATUS                                 Flash freeze status of instance
SKDSTTPCS      <ifname> <ofname>        Helps translate PCs to names
WATCH          <address> <len> <self|exist|all|target> Watch a region of memory
DELETE         <local|global|target> watchpoint <id>    Delete a watchpoint
SHOW           <local|global|target> watchpoints        Show watchpoints
DIRECT_ACCESS <set/enable/disable command | select query> Fixed table access
CORE                                     Dump core without crashing process
IPC                                      Dump ipc information
UNLIMIT                                  Unlimit the size of the trace file
PROCSTAT                                 Dump process statistics
CALL           [-t count] <func> [arg1]…[argn] Invoke function with arguments

——————————– oradebug语法 ——————————–

——————————– 查看共享信息内存的例子 ——————————–

— 1.生成信息到trace文件;

1.操作系统层面查看信息:host ipcs -m | grep ora
2.设置进程为当前进程:oradebug setmypid
3.导出信息到trace文件:oradebug ipc
4.查看trace文件的路径:oradebug tracefile_name

— 2.查看相应的trace文件;

Processing Oradebug command ‘ipc’
Dump of unix-generic skgm context
areaflags            000000f7
realmflags           0000001f
mapsize              00000800
protectsize          00001000
lcmsize              00001000
seglen               00400000
largestsize 00000000ffffffff
smallestsize 0000000000400000
stacklimit         0xbdc6af20
stackdir                   -1
mode                      640
magic                acc01ade
Handle:              0xf66058 `/u01/app/oracle/product/11.2.0/db_1ORCL’
Dump of unix-generic realm handle `/u01/app/oracle/product/11.2.0/db_1ORCL’, flags = 00
000000
Area #0 `Fixed Size’ containing Subareas 0-0
Total size 0000000000149294 Minimum Subarea size 00000000
Area Subarea    Shmid      Stable Addr      Actual Addr
0        0   196608 0x00000020000000 0x00000020000000
Subarea size     Segment size
000000000014a000 0000000000800000
Area #1 `Variable Size’ containing Subareas 4-4
Total size 0000000032400000 Minimum Subarea size 00400000
Area Subarea    Shmid      Stable Addr      Actual Addr
1        4   229377 0x00000020800000 0x00000020800000
Subarea size     Segment size
0000000032400000 0000000032400000
Area #2 `Redo Buffers’ containing Subareas 1-1
Total size 00000000004e3000 Minimum Subarea size 00000000
Area Subarea    Shmid      Stable Addr      Actual Addr
2        1   196608 0x0000002014a000 0x0000002014a000
Subarea size     Segment size
00000000004e3000 0000000000800000
Area #3 `Base Allocator Control’ containing Subareas 3-3
Total size 0000000000002000 Minimum Subarea size 00000000
Area Subarea    Shmid      Stable Addr      Actual Addr
3        3   196608 0x000000207fe000 0x000000207fe000
Subarea size     Segment size
0000000000002000 0000000000800000
Area #4 `Slab Allocator Control’ containing Subareas 2-2
Total size 00000000001d1000 Minimum Subarea size 00000000
Area Subarea    Shmid      Stable Addr      Actual Addr
4        2   196608 0x0000002062d000 0x0000002062d000
Subarea size     Segment size
00000000001d1000 0000000000800000
Area #5 `skgm overhead’ containing Subareas 5-5
Total size 0000000000002000 Minimum Subarea size 00000000
Area Subarea    Shmid      Stable Addr      Actual Addr
5        5   262146 0x00000052c00000 0x00000052c00000
Subarea size     Segment size
0000000000002000 0000000000400000
Dump of Linux-specific skgm context
sharedmmu 00000001
shareddec        0
used region        0: start 0000000012000000 length 0000000000400000
used region        1: start 0000000020000000 length 0000000033000000
used region        2: start 00000000af800000 length 0000000010800000
Maximum processes:               = 1000
Number of semaphores per set:    = 125
Semaphores key overhead per set: = 4
User Semaphores per set:         = 121
Number of semaphore sets:        = 9
Semaphore identifiers:           = 9
Semaphore List=
491520
524289
557058
589827
622596
655365
688134
720903
753672
————– system semaphore information ————-
—— Shared Memory Segments ——–
key        shmid      owner      perms      bytes      nattch     status
0x00000000 196608     oracle    640        4096       0
0x00000000 229377     oracle    640        4096       0
0x671360a4 262146     oracle    640        4096       0
—— Semaphore Arrays ——–
key        semid      owner      perms      nsems
0x4c1391ac 491520     oracle    640        125
0x4c1391ad 524289     oracle    640        125
0x4c1391ae 557058     oracle    640        125
0x4c1391af 589827     oracle    640        125
0x4c1391b0 622596     oracle    640        125
0x4c1391b1 655365     oracle    640        125
0x4c1391b2 688134     oracle    640        125
0x4c1391b3 720903     oracle    640        125
0x4c1391b4 753672     oracle    640        125
—— Message Queues ——–
key        msqid      owner      perms      used-bytes   messages

——————————– 查看共享信息内存的例子 ——————————–

——————————– oradebug实现10046事件 ——————————–

— 1.设置某个进程;

session 1:

sqlplus / as sysdba

conn hr/hr

SELECT pid, spid FROM v$process WHERE addr = (SELECT paddr FROM v$session WHERE sid = (SELECT sid FROM v$mystat WHERE rownum = 1));

— 29 22505;

session 2:

sqlplus / as sysdba

oradebug setorapid 29;

— 2.设置trace文件的大小:oradebug unlimit;

— 3.打开10046事件:oradebug event 10046 trace name context forever, level 12;

— 4.执行查询:SELECT COUNT(*) FROM hr.employees;(在session 1中)

— 5.查看trace文件的位置:oradebug tracefile_name;

— 6.关闭10046事件:oradebug event 10046 trace name context off;

— 6.查看trace文件,使用tkprof工具格式化;

——————————– oradebug实现10046事件 ——————————–

ORACLE中工具的使用05–TKPROF

Posted on 2012-01-14 by royalwzy

tkprof工具的使用

tkprof工具位于$ORACLE_HOME/bin目录下(查看命令which trcsess),用于格式化trace文件(也可以使用第三方的工具,格式化出来的更加美观和全面),从而可以非常方便的跟踪和诊断sql语句的执行效率;
tkprof的语法;
1. table:手动生成explain plan时,存储中间信息的临时表,默认为PROF$PLAN_TABLE;
2. explain:手动生成explain时,连接数据库的用户名和密码;
3. print:仅仅处理前integer数量的sql语句,如果我们需要生成脚本,该参数对脚本中包含的sql数量是不影响的;
4. insert:生成脚本,该脚本会创建表,并把相关统计信息插入表,从而可以在数据库中查看;
5. record:生成不包含递归sql的脚本文件;
6. sys:是否包含sys用户执行的sql,大多数是递归sql;
7. aggregate=no:如果设置为yes的话,会合并相同的sql语句,一般设置为no,分别查看每次的执行;
8. waits:是否记录等待事件;
9. sort:对sql语句排序的规则;
10. 常用的语法:tkprof tracefiles outputfile sys=no aggregate=no;
SQL Trace文件的内容:
1. Parse, execute, and fetch counts:解析,执行,获取三个动作的执行次数;
2. CPU and elapsed times:消耗的cpu时间和总时间,单位是秒;
3. Physical reads and logical reads:物理读和逻辑读的次数;
4. Number of rows processed:处理的记录数;
5. Misses on the library cache:没有命中缓存的次数;
6. Username under which each parse occurred:执行sql语句的用户;
7. Each commit and rollback:每次的提交和回滚操作(tkprof不会处理这些信息);
8. Wait event and bind data for each SQL statement:针对每条sql语句的等待事件和绑定变量信息;
9. Row operations showing the actual execution plan of each SQL statement:sql语句的实际执行计划;
10. Number of consistent reads, physical reads, physical writes, and time elapsed for each operation on a row;
Sql Trace与执行计划:
1. 在sql trace期间,如果sql语句的游标已经关闭,则在sql trace中会包含相应的执行计划,Example 1;
2. 在sql trace期间,如果sql语句的游标没有关闭,则在sql trace中不会包含相应的执行计划;
3. 如果之前sql语句已经执行过,则会包含执行计划;
4. 如果在trace文件中不存在执行计划的相关信息,可以通过tkprof的explain参数来登陆数据库,并执行explain plan命令,把执行计划写入到trace文件中;
指定aggregate=yes,tkprof会汇总相同的sql语句信息,并在文件的最后汇总所有语句的相关信息;
使用insert和records参数的例子,Example 2;
注意一些陷阱:
1. Avoiding the Argument Trap:如果在运行时不注意绑定变量的问题,很可能会陷入参数陷阱,EXPLAIN PLAN命令不会检查SQL语句中绑定变量的类型,总是认为是VARCHAR类型;所以,如果绑定变量如果实际为number或者date类型的话,tkprof会进行一个隐式转换,导致生成错误的执行计划;为了避免这种情况,需要自己执行转换;
2. Avoiding the Read Consistency Trap:如果要查询的数据被更新了,而且没有提交,那么很可能就会进入一致性读的陷阱,因为如果有很多相同的查询的操作的话,会一直构建CR块;
3. Avoiding the Schema Trap:当看到一个只有少量数据返回却发现扫描了非常多的块的统计是,有可能是一下原因:
  1. 表被经常的更新/删除,造成了水位线很高;
  2. 可能tkprof分析的trace文件记录的是之前没有在表上创建索引情况,而之后加上了索引;
4. Avoiding the Time Trap:当执行一个简单的sql,但是看到elapsed time时间特别长时,可能是再等待其它的锁;

————————————— tkprof的语法 —————————————

[oracle@singleton11g ~]$ tkprof
Usage: tkprof tracefile outputfile [explain= ] [table= ]
[print= ] [insert= ] [sys= ] [sort= ]
table=schema.tablename   Use ‘schema.tablename’ with ‘explain=’ option.
explain=user/password    Connect to ORACLE and issue EXPLAIN PLAN.
print=integer    List only the first ‘integer’ SQL statements.
aggregate=yes|no
insert=filename List SQL statements and data inside INSERT statements.
sys=no           TKPROF does not list SQL statements run as user SYS.
record=filename Record non-recursive statements found in the trace file.
waits=yes|no     Record summary for any wait events found in the trace file.
sort=option      Set of zero or more of the following sort options:
prscnt number of times parse was called
prscpu cpu time parsing
prsela elapsed time parsing
prsdsk number of disk reads during parse
prsqry number of buffers for consistent read during parse
prscu   number of buffers for current read during parse
prsmis number of misses in library cache during parse
execnt number of execute was called
execpu cpu time spent executing
exeela elapsed time executing
exedsk number of disk reads during execute
exeqry number of buffers for consistent read during execute
execu   number of buffers for current read during execute
exerow number of rows processed during execute
exemis number of library cache misses during execute
fchcnt number of times fetch was called
fchcpu cpu time spent fetching
fchela elapsed time fetching
fchdsk number of disk reads during fetch
fchqry number of buffers for consistent read during fetch
fchcu   number of buffers for current read during fetch
fchrow number of rows fetched
userid userid of user that parsed the cursor

————————————— tkprof的语法 —————————————

————————————— Example 1 —————————————

— 1.使用hr用户登录,并查看sql语句的执行计划;

sqlplus / as sysdba

conn hr/hr

EXPLAIN PLAN FOR SELECT employee_id, email, salary FROM HR.EMPLOYEES WHERE employee_id = 100;

SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY());

— 2.打开sql trace功能,然后设置标识符为E1,并执行sql语句;

ALTER SESSION SET SQL_TRACE=TRUE;

ALTER SESSION SET TRACEFILE_IDENTIFIER=’E1′;

SELECT employee_id, email, salary FROM HR.EMPLOYEES WHERE employee_id = 100;

— 3.格式化trace文件,然后查看执行计划:tkprof *_E1.trc e1.out sys=no aggregate=no;

————————————— Example 1 —————————————

————————————— Example 2 —————————————

— 1.使用hr用户登录,打开sql trace功能,然后设置标识符为E2,并执行sql语句;

sqlplus / as sysdba

conn hr/hr

ALTER SESSION SET SQL_TRACE=TRUE;

ALTER SESSION SET TRACEFILE_IDENTIFIER=’E2′;

SELECT USER FROM DUAL;

SELECT employee_id, email, salary FROM HR.EMPLOYEES WHERE employee_id = 200;

SELECT COUNT(*) FROM HR.DEPARTMENTS;

— 2.格式化trace文件,然后查看执行计划:tkprof *_E2.trc e2.out sys=no insert=insert.sql record=record.sql;

— 3.查看record.sql文件;

[oracle@singleton11g trace]$ less record.sql
SELECT USER FROM DUAL ;
SELECT employee_id, email, salary FROM HR.EMPLOYEES WHERE employee_id = 200 ;
SELECT COUNT(*) FROM HR.DEPARTMENTS ;

— 4.查看insert.sql文件;

REM Edit and/or remove the following CREATE TABLE
REM statement as your needs dictate.
CREATE TABLE tkprof_table
(
date_of_insert                       DATE
,cursor_num                           NUMBER
,depth                                NUMBER
,user_id                              NUMBER
,parse_cnt                            NUMBER
,parse_cpu                            NUMBER
,parse_elap                           NUMBER
,parse_disk                           NUMBER
,parse_query                          NUMBER
,parse_current                        NUMBER
,parse_miss                           NUMBER
,exe_count                            NUMBER
,exe_cpu                              NUMBER
,exe_elap                             NUMBER
,exe_disk                             NUMBER
,exe_query                            NUMBER
,exe_current                          NUMBER
,exe_miss                             NUMBER
,exe_rows                             NUMBER
,fetch_count                          NUMBER
,fetch_cpu                            NUMBER
,fetch_elap                           NUMBER
,fetch_disk                           NUMBER
,fetch_query                          NUMBER
,fetch_current                        NUMBER
,fetch_rows                           NUMBER
,ticks                                NUMBER
,sql_statement                        LONG
);
set sqlterminator off
INSERT INTO tkprof_table VALUES
(
SYSDATE, 2, 0, 84, 1, 2000, 2136, 0, 0, 0, 1
, 1, 0, 46, 0, 0, 0, 0, 0
, 2, 0, 26, 0, 0, 0, 1, 12753692
, ‘SELECT USER FROM DUAL
‘)
/
INSERT INTO tkprof_table VALUES
(
SYSDATE, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0
, 10, 0, 356, 0, 0, 0, 0, 0
, 10, 0, 448, 0, 40, 0, 10, 50095736
, ‘select obj#,type#,ctime,mtime,stime, status, dataobj#, flags, oid$, spare1, spa
re2 from obj$ where owner#=:1 and name=:2 and namespace=:3 and remoteowner is null
and linkname is null and subname is null
‘)
/
INSERT INTO tkprof_table VALUES
(
SYSDATE, 4, 1, 0, 0, 0, 0, 0, 0, 0, 0
, 2, 0, 80, 0, 0, 0, 0, 0
, 2, 0, 267, 0, 8, 0, 2, 1674
, ‘select t.ts#,t.file#,t.block#,nvl(t.bobj#,0),nvl(t.tab#,0),t.intcols,nvl(t.cluc
ols,0),t.audit$,t.flags,t.pctfree$,t.pctused$,t.initrans,t.maxtrans,t.rowcnt,t.blk
cnt,t.empcnt,t.avgspc,t.chncnt,t.avgrln,t.analyzetime,t.samplesize,t.cols,t.proper
ty,nvl(t.degree,1),nvl(t.instances,1),t.avgspc_flb,t.flbcnt,t.kernelcols,nvl(t.tri
gflag, 0),nvl(t.spare1,0),nvl(t.spare2,0),t.spare4,t.spare6,ts.cachedblk,ts.cacheh
it,ts.logicalread from tab$ t, tab_stats$ ts where t.obj#= :1 and t.obj# = ts.obj#
(+)
‘)
/
INSERT INTO tkprof_table VALUES
(
SYSDATE, 5, 1, 0, 0, 0, 0, 0, 0, 0, 0
, 2, 0, 118, 0, 0, 0, 0, 0
, 10, 2000, 2037, 0, 16, 0, 8, 3642
, ‘select i.obj#,i.ts#,i.file#,i.block#,i.intcols,i.type#,i.flags,i.property,i.pct
free$,i.initrans,i.maxtrans,i.blevel,i.leafcnt,i.distkey,i.lblkkey,i.dblkkey,i.clu
fac,i.cols,i.analyzetime,i.samplesize,i.dataobj#,nvl(i.degree,1),nvl(i.instances,1
),i.rowcnt,mod(i.pctthres$,256),i.indmethod#,i.trunccnt,nvl(c.unicols,0),nvl(c.def
errable#+c.valid#,0),nvl(i.spare1,i.intcols),i.spare4,i.spare2,i.spare6,decode(i.p
ctthres$,null,null,mod(trunc(i.pctthres$/256),256)),ist.cachedblk,ist.cachehit,ist
.logicalread from ind$ i, ind_stats$ ist, (select enabled, min(cols) unicols,min(t
o_number(bitand(defer,1))) deferrable#,min(to_number(bitand(defer,4))) valid# from
cdef$ where obj#=:1 and enabled > 1 group by enabled) c where i.obj#=c.enabled(+)
and i.obj# = ist.obj#(+) and i.bo#=:1 order by i.obj#
‘)
/
INSERT INTO tkprof_table VALUES
(
SYSDATE, 6, 1, 0, 0, 0, 0, 0, 0, 0, 0
, 8, 1000, 301, 0, 0, 0, 0, 0
, 17, 0, 410, 0, 34, 0, 9, 2435
, ‘select pos#,intcol#,col#,spare1,bo#,spare2,spare3 from icol$ where obj#=:1
‘)
/
INSERT INTO tkprof_table VALUES
(
SYSDATE, 7, 1, 0, 0, 0, 0, 0, 0, 0, 0
, 2, 0, 200, 0, 0, 0, 0, 0
, 17, 1000, 402, 0, 6, 0, 15, 1796
, ‘select name,intcol#,segcol#,type#,length,nvl(precision#,0),decode(type#,2,nvl(s
cale,-127/*MAXSB1MINAL*/),178,scale,179,scale,180,scale,181,scale,182,scale,183,sc
ale,231,scale,0),null$,fixedstorage,nvl(deflength,0),default$,rowid,col#,property,
nvl(charsetid,0),nvl(charsetform,0),spare1,spare2,nvl(spare3,0) from col$ where o
bj#=:1 order by intcol#
‘)
/
INSERT INTO tkprof_table VALUES
(
SYSDATE, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0
, 10, 999, 293, 0, 0, 0, 0, 0
, 10, 0, 459, 0, 30, 0, 10, 3519
, ‘select type#,blocks,extents,minexts,maxexts,extsize,extpct,user#,iniexts,NVL(li
sts,65535),NVL(groups,65535),cachehint,hwmincr, NVL(spare1,0),NVL(scanhint,0),NVL(
bitmapranges,0) from seg$ where ts#=:1 and file#=:2 and block#=:3
‘)
/
INSERT INTO tkprof_table VALUES
(
SYSDATE, 9, 1, 0, 0, 0, 0, 0, 0, 0, 0
, 8, 0, 199, 0, 0, 0, 0, 0
, 8, 0, 330, 0, 24, 0, 8, 2328
, ‘select o.owner#,o.name,o.namespace,o.remoteowner,o.linkname,o.subname from obj$
o where o.obj#=:1
‘)
/
INSERT INTO tkprof_table VALUES
(
SYSDATE, 10, 1, 0, 0, 0, 0, 0, 0, 0, 0
, 2, 1000, 149, 0, 0, 0, 0, 0
, 2, 0, 119, 0, 4, 0, 0, 1135
, ‘select col#, grantee#, privilege#,max(mod(nvl(option$,0),2)) from objauth$ wher
e obj#=:1 and col# is not null group by privilege#, col#, grantee# order by col#,
grantee#
‘)
/
INSERT INTO tkprof_table VALUES
(
SYSDATE, 11, 1, 0, 0, 0, 0, 0, 0, 0, 0
, 2, 0, 65, 0, 0, 0, 0, 0
, 5, 0, 179, 0, 6, 0, 3, 762
, ‘select grantee#,privilege#,nvl(col#,0),max(mod(nvl(option$,0),2))from objauth$
where obj#=:1 group by grantee#,privilege#,nvl(col#,0) order by grantee#
‘)
/
INSERT INTO tkprof_table VALUES
(
SYSDATE, 12, 1, 0, 0, 0, 0, 0, 0, 0, 0
, 2, 0, 51, 0, 0, 0, 0, 0
, 9, 1000, 269, 0, 18, 0, 7, 1321
, ‘select con#,obj#,rcon#,enabled,nvl(defer,0),spare2,spare3 from cdef$ where robj
#=:1
‘)
/
INSERT INTO tkprof_table VALUES
(
SYSDATE, 13, 1, 0, 0, 0, 0, 0, 0, 0, 0
, 2, 0, 80, 0, 0, 0, 0, 0
, 16, 0, 290, 0, 32, 0, 14, 2173
, ‘select con#,type#,condlength,intcols,robj#,rcon#,match#,refact,nvl(enabled,0),r
owid,cols,nvl(defer,0),mtime,nvl(spare1,0),spare2,spare3 from cdef$ where obj#=:1
‘)
/
INSERT INTO tkprof_table VALUES
(
SYSDATE, 14, 1, 0, 0, 0, 0, 0, 0, 0, 0
, 14, 0, 336, 0, 0, 0, 0, 0
, 28, 0, 499, 0, 56, 0, 14, 4305
, ‘select intcol#,nvl(pos#,0),col#,nvl(spare1,0) from ccol$ where con#=:1
‘)
/
INSERT INTO tkprof_table VALUES
(
SYSDATE, 15, 1, 0, 1, 1999, 1376, 0, 0, 0, 1
, 1, 2000, 2335, 0, 0, 0, 1, 0
, 1, 0, 26, 0, 2, 0, 1, 4365
, ‘select condition from cdef$ where rowid=:1
‘)
/
INSERT INTO tkprof_table VALUES
(
SYSDATE, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0
, 3, 0, 71, 0, 0, 0, 0, 0
, 3, 0, 102, 0, 9, 0, 3, 905
, ‘select /*+ rule */ bucket_cnt, row_cnt, cache_cnt, null_cnt, timestamp#, sample
_size, minimum, maximum, distcnt, lowval, hival, density, col#, spare1, spare2, av
gcln from hist_head$ where obj#=:1 and intcol#=:2
‘)
/
INSERT INTO tkprof_table VALUES
(
SYSDATE, 2, 0, 84, 1, 17997, 16136, 0, 0, 0, 1
, 1, 0, 23, 0, 0, 0, 0, 0
, 2, 0, 78, 0, 2, 0, 1, 1010
, ‘SELECT employee_id, email, salary FROM HR.EMPLOYEES WHERE employee_id = 200
‘)
/
INSERT INTO tkprof_table VALUES
(
SYSDATE, 15, 0, 84, 1, 8999, 9177, 0, 0, 0, 1
, 1, 1000, 113, 0, 0, 0, 0, 0
, 2, 0, 254, 0, 1, 0, 1, 2161
, ‘SELECT COUNT(*) FROM HR.DEPARTMENTS
‘)
/

COMMIT;
set sqlterminator on

————————————— Example 2 —————————————

ORACLE中工具的使用04–TRCSESS

Posted on 2012-01-14 by royalwzy

trcsess工具的使用

trcsess工具位于$ORACLE_HOME/bin目录下(查看命令which trcsess),它可以把USER_DUMP_DEST目录下多个trc文件根据一定规则合并成一个trc文件,然后使用tkprof工具进行格式化;
语法:trcsess [output=<output file name >] [session=<session ID>] [clientid=<clientid>] [service=<service name>] [action=<action name>] [module=<module name>] <trace file names>;
可以根据session,clientid,service,action,module和trace file的文件名(支持通配符)等不同的维度来合并USER_DUMP_DEST目录下的trc文件;相关的信息都可以从v$session视图中查看的到:SELECT sid, client_identifier, service_name, module, action, sql_trace FROM v$session;同样的可以从trace文件中查看的到;(其中sid是[sid.serial#]格式)
trace文件的命名规则是<ORACLE_SID>_ora_<spid>_<TRACEFILE_IDENTIFIER>.trc,默认的TRACEFILE_IDENTIFIER是空,可以通过ALTER SESSION SET TRACEFILE_IDENTIFIER='<TRACEFILE_IDENTIFIER>’命令来修改trace文件的标示符;
可以通过DBMS_SESSION.SET_IDENTIFIER(‘<TRACEFILE_IDENTIFIER>’)过程来设置client id;
该工具主要应用于共享服务器模式或者采用连接池模式,我们很难针对某用户进行跟踪的情况下;
用例:根据tracefile_identifier,service/module来合并trace文件;

———————————- 根据tracefile_identifier来合并trace文件 ———————————-

— 1.清空user_dump_dest目录下的trace文件(仅仅为了测试);

— 2.打开session 1做如下操作;

sqlplus / as sysdba
ALTER SESSION SET TRACEFILE_IDENTIFIER=’ti1′;
ALTER SESSION SET SQL_TRACE=TRUE;
SELECT ‘SESSION 1’ FROM DUAL;

— 3.打开session 2做如下操作;

sqlplus / as sysdba
ALTER SESSION SET TRACEFILE_IDENTIFIER=’ti1′;
ALTER SESSION SET SQL_TRACE=TRUE;
SELECT ‘SESSION 2’ FROM DUAL;

— 4.查看生成的trace文件;

— 5.合并trace文件;

根据service_name合并:trcsess output=ti1_service.out service=’SYS$USERS’ *_ti1.trc

根据module_name合并:trcsess output=ti1_module.out module=’sqlplus@singleton11g.snda.com (TNS V1-V3)’ *_ti1.trc

———————————- 根据tracefile_identifier来合并trace文件 ———————————-

ORACLE中工具的使用03–LogMiner

Posted on 2012-01-14 by royalwzy

LogMiner工具的使用:

用来分析Oracle数据库运行过程中产生的redo logfile和archived logfile来获取对数据库操作的DML语句;
以SYS用户安装LogMiner工具:
1. 安装DMBS_LOGMNR包:@?/rdbms/admin/dbmslm.sql;
2. 安装DMBS_LOGMNR_D包:@?/rdbms/admin/dbmslmd.sql;
LogMiner包的介绍:
1. DMBS_LOGMNR包:包含了初始化LogMiner工具,打开和关闭LogMiner会话的子程序;
  1. DMBS_LOGMNR.ADD_LOGFILE(LogFileName, options):开启一个LogMiner的会话,并添加redo logfile文件到这个队列里面;
    1. LogFileName:指定要分析的redo logfile;
    2. options:打开一个新的LogMiner会话并添加一个redo logfile(DMBS_LOGMNR.NEW);添加一个redo logfile到现存的LogMiner会话(DBMS_LOGMNR.ADDFILE);
  2. DMBS_LOGMNR.REMOVE_LOGFILE(LogFileName):通过指定名称,从被分析的redo logfile队列中移除一个redo logfile;
  3. DMBS_LOGMNR.START_LOGMNR(startScn, endScn, startTime, endTime, DictFileName, options):加载LogMiner数据字典并启动LogMiner来分析redo logfiles,最后填充动态视图;
    1. startScn:LogMiner返回大于此SCN的redo记录(分析后可以查询select filename, low_scn, next_scn from v$logmnr_logs来查询每个redo logfile包含的SCN范围);
    2. endScn:LogMinfer返回小于此SCN的redo记录;
    3. startTime:默认为1988-01-01,如果指定了startScn,则忽略此参数;
    4. endTime:默认为2110-12-31,如果指定了endScn,则忽略此参数;
    5. DictFileName:,默认为空,指定包含LogMiner字典的文本文件.用来生成v$logmnr_contents视图.必须指定DBMS_LOGMNR_D.BUILD过程中的全路径;
    6. options:分析日志时的操作选项,查看帮助文档;
  4. DMBS_LOGMNR.END_LOGMNR:结束LogMiner的会话,当退出Database Session的时候会自动调用此过程;
2. DMBS_LOGMNR_D包:用来创建LogMiner的数据字典;
  1. DMBS_LOGMNR_D.BUILD(dictionary_filename, dictionary_location, options):即导出数据库的数据字典到一个文本中,数据字典发生变化都要重新创建一次;;
    1. dictionary_filename:指定LogMiner字典的文件名;
    2. dictionary_location:指定LogMiner字典文件的路径;
    3. options:指定LogMiner字典写的位置,文本文件(STORE_IN_FLAT_FILE,默认)或者是在线日志文件(STORE_IN_REDO_LOGS);
    4. 指定文本文件,则必须设置UTL_FILE_DIR初始化参数(ALTER SYSTEM SET UTL_FILE_DIR=’\tmp’ SCOPE=spfile;然后重启数据库服务使其生效):
      1. EXECUTE dbms_logmnr_d.build(‘dictionary_filename’, ‘dictionary_location’);
      2. EXECUTE dbms_logmnr_d.build(‘dictionary_filename’, ‘dictionary_location’, options => dbms_logmnr_d.store_in_flat_file);
    5. 指定在线日志文件,不常用,影响性能:EXECUTE dbms_logmnr_d.build(options => dbms_logmnr_d.store_in_redo_logs);
  2. DBMS_LOGMNR_D.SET_TABLESPACE(new_tablespace);
    1. 默认情况下,LogMiner的表会被创建到SYSAUX表空间,使用此函数可以修改LogMiner表存放的表空间;
    2. DBMS_LOGMNR_D.SET_TABLESPACE(‘tablespace_name’);
打开数据库的附加日志:ALTER DATABASE ADD SUPPLEMENTAL LOG DATA;
创建数据字典:
1. 创建表空间:CREATE TABLESPACE LOGMINER DATAFILE ‘/u01/app/oracle/oradata/AUX/logminer01.dbf’ SIZE 100M AUTOEXTEND ON;
2. 设置LogMiner表的表空间:EXEC dbms_logmnr_d.set_tablespace(‘LOGMINER‘);
3. 设置UTL_FILE_DIR参数,然后重启数据库使之生效:alter system set utl_file_dir=’/u01/app/oracle/oradata/AUX/’ scope=spfile;
4. 生成数据字典:EXEC dbms_logmnr_d.build(‘dictionary.lm’, ‘/u01/app/oracle/oradata/AUX/’);
模拟一个人为的错误;
打开LogMiner的session并添加日志文件,只是在当前的session有效(查询归档日志的路径:select name from v$archived_log);
分析日志,指定生成的LogMiner数据字典:EXEC dbms_logmnr.start_logmnr(DictFileName=>’/u01/app/oracle/oradata/AUX/dictionary.lm’);
此时就可以查询LogMiner的视图了,可以在IDE环境下去做,可以更好的过滤想要的结果;
退出LogMiner的会话:EXEC dbms_logmnr.end_logmnr;
LogMiner的视图:
1. V$LOGMNR_CONTENTS:用来存放LogMiner分析日志后的结果;
  1. SELECT scn, TIMESTAMP, log_id, operation, sql_redo, sql_undo FROM v$logmnr_contents WHERE username = ‘HR’;
  2. 分析结果仅在运行过程dbms_logmrn.start_logmnr这个会话的生命期中存在.因为所有的LogMiner存储都在PGA内存中,所有其他的进程是看不到它的,同时随着进程的结束,分析结果也随之消失;
2. V$LOGMNR_DICTIONARY:使用的数据字典的信息;
3. V$LOGMNR_LOGS:包含所分析的日志的信息,SELECT log_id, filename, db_name, low_scn, next_scn, low_time, high_time, status FROM v$logmnr_logs;
4. V$LOGMNR_SESSION:包含LogMiner当前的Session信息;
注意事项:
1. 利用LogMiner工具来分析其它数据库实例产生的redo logfiles,使用LogMiner分析其它数据库实例时的注意事项;
2. LogMiner必须使用被分析数据库实例产生的字典文件,而不是安装LogMiner的数据库产生的字典文件,另外必须保证安装LogMiner数据库的字符集和被分析数据库的字符集相同;
3. 被分析数据库平台必须和当前LogMiner所在数据库平台一样,也就是说如果我们要分析的文件是由运行在UNIX平台上的Oracle 8i产生的,那么也必须在一个运行在UNIX平台上的Oracle实例上运行LogMiner,而不能在其它如Microsoft NT上运行LogMiner,当然两者的硬件条件不一定要求完全一样;
4. LogMiner日志分析工具仅能够分析Oracle 8以后的产品,不过它可以分析Oracle8的日志,对于8以前的产品,该工具也无能为力.另外,Oracle8i只能对DML操作进行分析,从Oracle9i开始不仅可以分析DML操作,而且也可以分析DDL操作;
Oracle11g中EM继承了LogMiner工具(需要开启附加日志):
1. LogMiner的路径:Avaliability->Manage->View and Manage Transactions;
2. 可以通过时间/SCN,查询某些表/用户下的所有的事务/DDL;
3. 结果页面;

— 模拟人为错误,并切换归档;

conn hr/hr
create table lm tablespace logminer as select * from employees;
delete from lm where employee_id < 200;
commit;
conn / as sysdba
alter system switch logfile;

— 打开LogMiner的session并添加日志文件;

EXECUTE dbms_logmnr.add_logfile(LogFileName=>’/u01/app/oracle/flash_recovery_area/AUX/archivelog/2012_09_18/o1_mf_1_3_85j72xlx_.arc’, options=>dbms_logmnr.new);

EXECUTE dbms_logmnr.add_logfile(LogFileName=>’/u01/app/oracle/flash_recovery_area/AUX/archivelog/2012_09_18/o1_mf_1_4_85j76znp_.arc’, options=>dbms_logmnr.addfile);

ORACLE中工具的使用02–DBVERIFY

Posted on 2012-01-14 by royalwzy

DBVERIFY工具的使用

DBVERIFY工具介绍:
1. DBVERIFY is an external command-line utility that performs a physical data structure integrity check. It can be used on offline or online databases, as well on backup files. You use DBVERIFY primarily when you need to ensure that a backup database (or datafile) is valid before it is restored, or as a diagnostic aid when you have encountered data corruption problems;
2. DBVERIFY checks are limited to cache-managed blocks (that is, data blocks). Because DBVERIFY is only for use with datafiles, it will not work against control files or redo logs;
3. 只支持镜像备份,不支持备份集验证;测试发现控制文件可以验证,但是在线日志不可以;
DBVERIFY的语法:dbv key=value;
1. USERID=Username/Password:指定用户名密码,如果检查的文件是ASM文件系统,需要提供验证信息;
2. FILE=file_name:要检查的datafile文件名;
3. START=start_block:要检查的文件的开始块号,默认是文件第一个块;
4. END=end_block:要检查文件的结束的块号,默认是文件最后一个块;
5. BLOCKSIZE=size:指定块的大小,默认是8k,如果使用的不是8k的块需要指定此参数;
6. LOGFILE=log_file:指定日志文件,如果不指定就显示在终端;
7. FEEDBACK=n:返回检查的进度,n个单位打一个点;
8. PARFILE=parameter_file:指定一个参数文件;
9. SEGMENT_ID:指定段的id(由三部分组成:tablespace_id.header_file.header_block),可以通过sql语句查询;
DBVERIFY的用法:
1. 对datafile文件进行检查;
2. 对segment进行检查;
3. 对备份集的检查;
4. 对控制文件的检查;
检查datafile中的block:
1. 这种模式下,会扫描一个datafile中的一个或者多个blocks,并生成一份检查结果;
2. 如果datafile是ASM系统文件的话,需要提供USERID连接到这个ASM文件;
3. 检查system表空间:dbv file=$ORACLE_BASE/oradata/PROD/system01.dbf feedback=1000;
检查segment:
1. 在这种模式下,可以用来检查一个对象(表/索引)使用的segment的可用性,指定segment的所有链表都会被检查;
2. 被检查的相应的对象会被加锁,如果是索引的话,则引用的表会被加锁;
3. 需要提供sysdba的身份验证,因为需要读取segment的数据字典;
4. 检查scott用户下emp表的segment:dbv userid=scott/tiger segment_id=4.4.2003 feedback=10;
验证控制控制文件:
1. 常规验证,发现错误,因为块大小不对,修改验证语法:dbv file=$ORACLE_BASE/oradata/PROD/control01.ctl feedback=100;
2. 验证:dbv file=$ORACLE_BASE/oradata/PROD/control01.ctl blocksize=16384 feedback=100;

— 查询某个SEGMENT的id;

SELECT a.ts# || ‘.’ || b.header_file || ‘.’ || b.header_block
FROM v$tablespace a, dba_segments b
WHERE a.NAME = b.tablespace_name AND b.segment_name = ‘segment_name’ AND owner = ‘owner’;

— 块损坏的几种检查;

————————————————————————————–
特性                      坏块侦测类型                    能否修复损坏块
————————————————————————————————
DBVERIFY                  物理                         否
ANALYZE                   逻辑                         否
DB_BLOCK_CHECKING         逻辑                         否
DB_BLOCK_CHECKSUM         物理                         否
exp                       物理                         否
FlashBack                 逻辑                         是
DBMS_REPAIR               逻辑                         是
Block media recovery      未知                         是

ORACLE中工具的使用01–DBNEWID

Posted on 2012-01-14 by royalwzy

DBNEWID工具的使用

DBNEWID工具介绍:
1. 手动创建一个数据库的拷贝时,在重建控制文件时可以指定一个新的DBNAME,但是不能修改DBID.DBID是内部唯一标示一个数据库的标示符;RMAN是使用DBID区分数据库的,所以就不能把这两个数据库注册到同一个RMAN的资源库中了;
2. DBNEWID工具可以:
  1. 只修改DBID(无法控制修改为多少);
  2. 只修改DBNAME;
  3. 同时修改DBID和DBNAME;
3. 如果修改了DBID,之前所有的备份,归档日志都会失效,而且打开数据库时需要指定RESETLOGS参数;
4. 强烈建议在修改DBID之前对数据库进行备份;
5. 使用DBNEWID工具不会影响global_name,它只能通过ALTER DATABASE语法进行修改,由DB_NAME和域组成:ALTER DATABASE RENAME GLOBAL_NAME TO db_name.db_domain;
6. DBNEWID工具也不会修改INSTANCE_NAME,但是会修改DB_NAME,DB_UNIQUE_NAME和SERVICE_NAMES;
DBNEWID的语法:nid key=value;
1. TARGET=user/pwd@tns_name:登陆目标数据库;
2. DBNAME=newname:指定要修改的新的数据库的名称,如果不指定此参数,则只修改DBID;
3. SETNAME=YES/NO:默认为NO,如果指定为YES,表示值修改数据库名称;
4. REVERT=YES/NO:默认为NO,如果为YES,表示如果失败了回退到之前的状态;
5. LOGFILE=log_file:指定日志文件;
6. APPEND=YES/NO:指定是追加日志还是覆盖日志;
7. 例子:
  1. 只修改DBID:nid target=user/pwd@tns_name logfile=nid.log;
  2. 只修改DBNAME:nid target=user/pwd@tns_name dbname=newname setname=yes logfile=nid.log;
  3. 同时修改DBID和DBNAME:nid target=user/pwd@tns_name dbname=newname logfile=nid.log;
  4. 发生错误回退到之前的状态:nid target=user/pwd@tns_name revert=yes logfile=nid.log
修改DBID和DBNAME:
1. 对数据库做一次全备;
2. 配置好监听(静态注册数据库)和网络名,如果是在本机操作则不需要此步骤;
3. 查看当前的DBID和DBNAME:SELECT dbid, name FROM v$database;
4. 正常关闭数据库,并启动到mount状态;
5. 调用nid工具,使用sysdba登陆:nid target=sys/oracle dbname=OMR,修改完成后数据库处于shutdown状态;
6. 修改spfile文件中的DB_NAME参数(如果只修改DBID的话,不用这个步骤);
7. 重置密码文件(如果只修改DBID或者没有修改ORACLE_SID的话,不用这个步骤,因为密码文件只跟ORACLE_SID有关):
8. 启动数据库到mount状态,然后以resetlogs方式打开数据库:ALTER DATABASE OPEN RESETLOGS;(如果只是修改了DB_NAME的话,不用这个步骤,之前的日志还可以使用)
9. 查看新的DBID和DB_NAME;

导入导出工具02–SQL*Loader工具与外部表

Posted on 2011-12-31 by royalwzy

SQL*Loader工具与外部表

SQL*Loader:
1. 概念:
  1. 可以在服务器端和客户端操作,数据可以存放在服务器端或者客户端;
  2. 可以导入固定格式的TXT文件的数据;
2. INSERT INTO … SELECT …的两种插入数据的方法:
  1. conventional INSERT操作:通用的插入方法,数据库会优先重新利用HWM(High Water Mark)以下的数据块,然后再使用HWM以上的数据块,使得新旧数据交叉存放,同时还要维护数据的完整性(主外键,CHECK约束等);
  2. direct-path INSERT操作:直接路径插入方法,数据库把数据直接插入到高水位之后的数据块中,数据不经过buffer cache,直接写入数据文件,忽略数据的完整性,使得性能最大的提升;
    1. 顺序插入分区/非分区表:只有一个线程把数据写到HWM之后;
    2. 并行插入分区表:每个进程可以被分配到一个或者多个分区,但是一个分区最多只有一个进程负责,推荐使用跟分区数量相同的并行度;数据同样只在每个分区的HWM之后的数据块写入;
    3. 并行插入非分区表:每个进程分配一个临时的段,然后把所有临时段合并;
  3. SQL*Loader的convention-path load方式和direct-path load方式跟这个相似;
  4. 可以通过使用/*+ APPEND */的hint,来使用直接导入数据,例子;
  5. conventional方式使用会产生redo日志,而direct-path方式始终不产生日志,与表本身是否是LOGGING模式无关,如果数据库是FORCE LOGGING模式,则无论那种方式都会记录日志,例子;
3. SQL*Loader的介绍;
  1. Input data files:要导入的数据文件;
    1. 以文本形式存在;
    2. 可以有多个数据文件;
    3. 支持三种数据格式:
      1. Fixed-Record Format:每个列有固定的长度,效率高单灵活性差,如:数据文件中每11个字节是一个字段infile ‘example.dat’ “fix 11”;
      2. Variable-Record Format:每个列长度不固定,在最前面n位来记录它的长度,如:前三个字符表示记录的长度infile ‘example.dat’ “var 3”;
      3. Stream-Record Format:流记录,以某个符号区分列,最常用的方式;
    4. 记录的种类:
      1. Physical Record:即数据文本中的一行记录;
      2. Logical Record:在数据库中表的一行记录,可以合并几行物理记录组成一个逻辑记录;
  2. Loader control file:导入数据的控制文件;
    1. 指定导入数据的目录;
    2. 数据的格式化;
    3. 配置信息:内存,拒绝记录的规则,异常终止后的处理;
    4. 如何操作数据;
    5. 注释使用[–]符号;
    6. 不能使用CONSTANT和ZONE关键字;
  3. Parameter file:可选,可以把sqlldr命令后面的参数保存起来,只需要指定参数文件即可;
  4. Discard file:可选,被抛弃的数据,不满足过滤器条件的记录;
    1. 可以控制打开或者关闭此功能;
    2. 可以在控制文件中定义记录选择的标准;
    3. 可以规定当discard file中记录超过一定数量的话就终止;
  5. Bad file:可选,被拒绝的数据;
    1. SQL*Loader拒绝的数据,比如输入数据的格式不对;
    2. Oracle数据库拒绝的数据,比如违反约束的记录;
  6. Log file:可选,日志信息,如果没有指定就会生成以.log结尾的跟数据文件同名的文件;
    1. 头信息;
    2. 全局信息;
    3. 表信息;
    4. 数据文件信息;
    5. 表加载的信息;
    6. 统计信息;
    7. 附加信息,比如花费的时间等待;
  7. 架构图;
4. Conventional和Direct-Path Load方法的对比:
  1. Conventional Load:
    1. 读取一条记录,解析,插入,提交;
    2. 总是会产生REDO日志;
    3. 强制检查所有约束;
    4. 会激活触发器;
    5. 可以插入到簇表;
    6. 其它用户可以修改表;
  2. Direct-Path Load:
    1. 把记录构造成块,直接进行块拷贝;
    2. 只有在数据库为FORCE LOGGING模式下才会产生REDO日志;
    3. 只检查主键,唯一键,NOT NULL约束;
    4. 忽略触发器;
    5. 不能对簇表加载数据;
    6. 其它用户不能修改表;
  3. 可以使用并行操作来加快速度,但是需要手动指定并行度;
5. SQL*Loader的语法:sqlldr keyword=value,命令后面是键值对的组合;
  1. userid:username/password;
  2. control:控制文件名称;
  3. log:日志文件名称;
  4. bad:bad文件名称;
  5. data:数据文件名称;
  6. discard:discard文件名称;
  7. discardmax:允许最大的discard的记录数,默认为所有记录;
  8. skip:跳过的逻辑记录数,默认为0;
  9. load:加载的逻辑记录数,默认为所有记录;
  10. errors:允许错误的记录数,默认为50;
  11. silent:不提示header/feedback/errors/discards/partitions等信息,默认为FALSE;
  12. direct:使用直接路径,默认为FALSE;
  13. multithreading:直接数据导入时使用多线程;
  14. parfile:使用的参数文件的名称;
  15. parallel:使用并行加载,默认是FALSE;
  16. skip_unusable_indexes:跳过unusable的索引,默认为FALSE;
  17. skip_index_maintenance:不维护索引,标记索引为unusable,默认为FALSE;
  18. commit_discontinued:当加载数据终止时,提交已经加载了的数据,默认为FALSE;
  19. streamsize:使用直接路径加载时的缓存区大小,默认是256000;
  20. external_table:使用外部表导入数据;
    1. NOT_USED:不使用外部表;
    2. GENERATE_ONLY:只生成外部表的创建语法,生成在log文件中;
    3. EXECUTE:使用外部表导入数据;
  21. date_cache:导入数据的cache大小;
  22. _display_exitcode:显示sqlloader退出时的退出码;
6. SQL*Loader的退出码,用在SHELL编程中:
  1. EX_SUCC(0):所有的记录加载成功;
  2. EX_WARN(2):一些记录被放到bad file/discard file/异常终止;
  3. EX_FAIL(1):语法错误,操作错误;
  4. 如果状态码大于0的话,就有问题;
7. SQL*Loader的例子:
  1. 在9i的数据库的$ORACLE_HOME/rdbms/demo/目录下ul*的11个例子(.ctl是控制文件,.sql是修改表的脚本,.dat是数据,在scott用户下完成);
  2. EXAMPLE1:加载变长的数据,数据列之间以逗号分隔,可能还以引号包围,数据和控制文件在一起;
  3. EXAMPLE2:加载固定格式的数据,数据和控制文件分开;
  4. EXAMPLE3:加载有定界符的,随意格式的文件,数据与控制文件在一起;
  5. EXAMPLE4:加载合并的物理记录,合并多个物理记录到一个逻辑记录中;
  6. EXAMPLE5:加载数据到多个表中;
  7. EXAMPLE6:使用直接路径的方式加载数据;
  8. EXAMPLE7:从一个格式化的报表中抽取数据并加载;
  9. EXAMPLE8:加载分区表;
  10. EXAMPLE9:加载CLOB列;
  11. EXAMPLE10:加载REF列和ARRAYs列;
  12. EXAMPLE11:转换字符集,使用Unicode编码加载数据;
DIRECTORY对象:
1. 只有SYS用户可以拥有DIRECTORY对象,但是它可以授权其它用户创建的权限;
2. DIRECTORY对象只是一个文件系统目录的映射/别名(如果oracle用户没有这个目录的权限怎么办?);
3. 具有DBA角色或者CREATE ANY DIRECTORY权限的用户可以创建DIRECTORY对象:CREATE DIRECTORY ext_tab_dir AS ‘/u01/datafiles’;
4. 查看系统中存在的DIRECTORY对象:SELECT * FROM dba_directories;
5. 创建者/DBA可以对其它用户/角色授权:GRANT READ, WRITE ON DIRECTORY ext_tab_dir TO hr;
6. 查看某个DIRECTORY对象的权限:SELECT * FROM dba_tab_privs WHERE table_name = ‘EXT_TAB_DIR’;
7. 创建者和DBA自动具有RW权限;
8. 删除DIRECTORY对象:DROP DIRECTORY ext_tab_dir;
外部表(External Tables):
1. 外部表的概念:
  1. 10g之前,外部表是只读的;10g之后,外部表可读可写;
  2. 外部表是对SQL*Loader功能的补充,可以像访问数据库中表一样访问数据库外的资源;
  3. 只能在服务器端操作,数据要存放在服务器端,因为需要使用DIRECTORY;
  4. 可以导入固定格式的TXT文件的数据;
  5. 在ETL中尽量多用外部表,而少用SQL*Loader;
2. 创建外部表:
  1. 使用CREATE TABLE table_name(…) ORGANIZATION EXTERNAL语法,需要指定的属性:
    1. TYPE:指定外部表使用的访问引擎;
      1. ORACLE_LOADER:默认值,只能进行数据加载操作,而且数据必须是文本文件;
      2. ORACLE_DATAPUMP:可以进行数据加载/卸载的操作,数据必须是二进制的dump文件;
    2. DEFAULT DIRECTORY:指定外部表所使用的默认目录,是一个DIRECTORY对象,而不是一个路径;
    3. ACCESS PARAMETERS:指定外部表数据对应的表中的列和某一列的格式化信息,与使用的引擎有关;
    4. LOCATION:指定外部表的位置,是目录和文件名的组合(directory:file),如果没有指定目录则使用默认的目录;
  2. 创建的步骤:
    1. 创建DIRECTORY对象;
    2. 创建外部表;
    3. 其它操作:可以再创建一个表,然后使用INSERT INTO … SELECT …语法导入数据;
3. 加载和卸载数据:
  1. 加载数据:把外部表中的数据导入到数据库的表中;
  2. 卸载数据:把数据库表中的内容导入到外部不表中,只能使用ORACLE_DATAPUMP引擎;
4. 使用外部表时的数据类型转换,LOB字段:CREATE TABLE LONG_TAB_XT (LONG_COL CLOB) ORGANIZATION EXTERNAL…SELECT TO_LOB(LONG_COL) FROM LONG_TAB;
5. 并行查询外部表:
  1. ORACLE_LOADER引擎:
    1. 如果加载文件时顺序指定了多个文件;
    2. 记录使用VAR格式化;
  2. ORACLE_DATAPUMP引擎:
    1. 加载数据时:
      1. 加载时使用了多个文件;
      2. 使用一个大的文件时也会并行,因为会记录文件读取的偏移量;
    2. 卸载数据时:
      1. LOCATION参数指定多个文件时可以发生并行;
      2. 如果并行度等于文件的个数的话,每个进程写一个文件;
      3. 如果并行度大于文件的个数的话,并行度降低为文件的个数;
      4. 如果并行度小于文件的个数的话,外部文件将不会被使用;
  3. 自己决定并行度;
6. 外部表的限制:
  1. 不支持加密列;
  2. 不支持LONG类型的列;
  3. 特殊字符需要用双引号转换;
  4. 不能是临时表;
  5. 不能添加约束;
7. SQL*Loader和外部表的不同:
  1. 在sql*loader中可以使用反斜杠来转义一个字符:FIELDS TERMINATED BY ‘,’ OPTIONALLY ENCLOSED BY ‘\”;
  2. 在外部表中使用反斜杠会报错,可以使用引号来分割字段:TERMINATED BY ‘,’ ENCLOSED BY “‘”;
8. 外部表的例子:
  1. ORACLE_LOADER引擎:使用脚本导入的例子;
  2. ORACLE_LOADER引擎:使用sql*loader生成外部表脚本的例子;
  3. ORACLE_DATADUMP引擎:导出数据的例子;
  4. ORACLE_DATADUMP引擎:导入数据的例子;

————————- Direct-Path INSERT的例子 ————————-

— 创建一个空表;
CREATE TABLE bt AS SELECT * FROM dba_objects WHERE 1 = 0;
— 正常插入数据;

INSERT INTO bt SELECT * FROM dba_objects;

— 在提交之前就可以查询到表的数量;
SELECT COUNT(*) FROM bt;
COMMIT;

— 使用直接路径的方式;
INSERT /*+ APPEND */ INTO bt SELECT * FROM dba_objects;

— 提交之前查询表报错,从一方面说明了直接路径插入;
SELECT COUNT(*) FROM bt;
SELECT COUNT(*) FROM bt
*
ERROR at line 1:
ORA-12838: cannot read/modify an object after modifying it in parallel

————————- Direct-Path INSERT的例子 ————————-

————————- Direct-Path INSERT NOLOGGING的例子 ————————-

— 一,表处于LOGGING模式,数据库不是FORCE LOGGING模式,观察几种插入方式产生的日志;

— 1.传统插入,LOGGING模式,会产生日志;

— 2.传统插入,NOLOGGING模式,同样会产生日志;

— 3.直接插入,LOGGING模式,不会产生日志;

— 4.直接插入,NOLOGGING模式,也不会产生日志;

— 二,表处于NOLOGGING模式,数据库处于非FORCE LOGGING模式:传统方式都会产生日志,直接插入方式都不产生日志;

— 三,数据库处于FORCE LOGGING模式,无论表是什么模式,无论哪种方式都会记录日志;

————————- Direct-Path INSERT NOLOGGING的例子 ————————-

————————- SQL*Loader的例子 ————————-

— EXAMPLE1:加载变长的数据,数据列之间以逗号分隔,可能还以引号包围,数据和控制文件在一起;

— 创建测试表;

DROP TABLE EMP;

DROP TABLE DEPT;

CREATE TABLE DEPT
(
DEPTNO NUMBER(2) not null,
DNAME VARCHAR2(14),
LOC    VARCHAR2(13)
);
CREATE TABLE EMP
(
EMPNO    NUMBER(4) not null,
ENAME    VARCHAR2(10),
JOB      VARCHAR2(9),
MGR      NUMBER(4),
HIREDATE DATE,
SAL      NUMBER(7,2),
COMM     NUMBER(7,2),
DEPTNO   NUMBER(2)
);

— 控制文件和数据;

LOAD DATA
INFILE *
INTO TABLE DEPT
FIELDS TERMINATED BY ‘,’ OPTIONALLY ENCLOSED BY ‘”‘
(DEPTNO, DNAME, LOC)
BEGINDATA
12,RESEARCH,”SARATOGA”
10,”ACCOUNTING”,CLEVELAND
11,”ART”,SALEM
13,FINANCE,”BOSTON”
21,”SALES”,PHILA.

— 导入数据:sqlldr scott/tiger control=/u01/sqlldrdemo/demo1.ctl;

— 验证数据;

— EXAMPLE2:加载固定格式的数据,数据和控制文件分开;

— 控制文件;

LOAD DATA
INFILE ‘/u01/sqlldrdemo/demo2.dat’
INTO TABLE EMP
( EMPNO    POSITION(01:04) INTEGER EXTERNAL,
ENAME    POSITION(06:15) CHAR,
JOB      POSITION(17:25) CHAR,
MGR      POSITION(27:30) INTEGER EXTERNAL,
SAL      POSITION(32:39) DECIMAL EXTERNAL,
COMM     POSITION(41:48) DECIMAL EXTERNAL,
DEPTNO   POSITION(50:51) INTEGER EXTERNAL)

— 数据文件;

7782 CLARK      MANAGER   7839 2572.50          10
7839 KING       PRESIDENT       5500.00          10
7934 MILLER     CLERK     7782   920.00          10
7566 JONES      MANAGER   7839 3123.75          20
7499 ALLEN      SALESMAN 7698 1600.00   300.00 30
7654 MARTIN     SALESMAN 7698 1312.50 1400.00 30
7658 CHAN       ANALYST   7566 3450.00          20

— 导入数据:sqlldr scott/tiger control=/u01/sqlldrdemo/demo2.ctl;

— 验证数据;

— EXAMPLE3:加载有定界符的,随意格式的文件,数据与控制文件在一起;

— 修改表结构:alter table emp add (projno number, loadseq number);

— 控制文件;

LOAD DATA
INFILE *
APPEND
INTO TABLE EMP
FIELDS TERMINATED BY “,” OPTIONALLY ENCLOSED BY ‘”‘
(empno, ename, job, mgr,
hiredate DATE(20) “DD-Month-YYYY”,
sal, comm,
deptno CHAR TERMINATED BY ‘:’,
projno,
loadseq SEQUENCE(MAX,1))
BEGINDATA
7782, “Clark”, “Manager”, 7839, 09-June-1981, 2572.50,, 10:101
7839, “King”, “President”, , 17-November-1981, 5500.00,, 10:102
7934, “Miller”, “Clerk”, 7782, 23-January-1982, 920.00,, 10:102
7566, “Jones”, “Manager”, 7839, 02-April-1981, 3123.75,, 20:101
7499, “Allen”, “Salesman”, 7698, 20-February-1981, 1600.00, 300.00, 30:103
7654, “Martin”, “Salesman”, 7698, 28-September-1981, 1312.50, 1400.00, 30:103
7658, “Chan”, “Analyst”, 7566, 03-May-1982, 3450,, 20:101

— 导入数据:sqlldr scott/tiger control=/u01/sqlldrdemo/demo3.ctl;

— 验证数据;

— EXAMPLE4:加载合并的物理记录,合并多个物理记录到一个逻辑记录中;

— 修改表结构;

DROP TABLE EMP;

CREATE TABLE EMP
(
EMPNO    NUMBER(4) not null,
ENAME    VARCHAR2(10),
JOB      VARCHAR2(9),
MGR      NUMBER(4),
HIREDATE DATE,
SAL      NUMBER(7,2),
COMM     NUMBER(7,2),
DEPTNO   NUMBER(2)
);

CREATE UNIQUE INDEX UNQ_EMPNO ON EMP(EMPNO);

— 控制文件;

LOAD DATA
INFILE “/u01/sqlldrdemo/demo4.dat”
DISCARDFILE “/u01/sqlldrdemo/demo4.dis”
DISCARDMAX 999
REPLACE
CONTINUEIF (1) = ‘*’
INTO TABLE EMP
( EMPNO    POSITION(01:04) INTEGER EXTERNAL,
ENAME    POSITION(06:15) CHAR,
JOB      POSITION(17:25) CHAR,
MGR      POSITION(27:30) INTEGER EXTERNAL,
SAL      POSITION(32:39) DECIMAL EXTERNAL,
COMM     POSITION(41:48) DECIMAL EXTERNAL,
DEPTNO   POSITION(50:51) INTEGER EXTERNAL,
HIREDATE POSITION(52:60) INTEGER EXTERNAL)

— 数据文件;

*7782 CLARK      MA
NAGER   7839 2572.50   -10    2512-NOV-85
*7839 KING       PR
ESIDENT       5500.00          2505-APR-83
*7934 MILLER     CL
ERK     7782   920.00          2508-MAY-80
*7566 JONES      MA
NAGER   7839 3123.75          2517-JUL-85
*7499 ALLEN      SA
LESMAN 7698 1600.00   300.00 25 3-JUN-84
*7654 MARTIN     SA
LESMAN 7698 1312.50 1400.00 2521-DEC-85
*7658 CHAN       AN
ALYST   7566 3450.00          2516-FEB-84
*     CHEN       AN
ALYST   7566 3450.00          2516-FEB-84
*7658 CHIN       AN
ALYST   7566 3450.00          2516-FEB-84

— 导入数据:sqlldr scott/tiger control=/u01/sqlldrdemo/demo4.ctl;

— 验证数据;

— 检查不满足条件的记录;

— EXAMPLE5:加载数据到多个表中;

— 创建测试表;

DROP TABLE emp;
DROP TABLE proj;
CREATE TABLE EMP
(
EMPNO    NUMBER(4) not null,
ENAME    CHAR(10),
JOB      CHAR(9),
MGR      NUMBER(4),
HIREDATE DATE,
SAL      NUMBER(7,2),
COMM     NUMBER(7,2),
DEPTNO   NUMBER(2)
);
CREATE UNIQUE INDEX unq_empno ON EMP (EMPNO);
CREATE TABLE PROJ
(
EMPNO NUMBER,
PROJNO NUMBER
);

— 控制文件;

LOAD DATA
INFILE ‘/u01/sqlldrdemo/demo5.dat’
BADFILE ‘/u01/sqlldrdemo/demo5.bad’
DISCARDFILE ‘/u01/sqlldrdemo/demo5.dis’
REPLACE
INTO TABLE EMP
(EMPNO    POSITION(1:4)   INTEGER EXTERNAL,
ENAME    POSITION(6:15) CHAR,
DEPTNO   POSITION(17:18) CHAR,
MGR      POSITION(20:23) INTEGER EXTERNAL)
INTO TABLE PROJ
— PROJ has two columns, both not null: EMPNO and PROJNO
WHEN PROJNO != ‘   ‘
(EMPNO    POSITION(1:4)   INTEGER EXTERNAL,
PROJNO   POSITION(25:27) INTEGER EXTERNAL)   — 1st proj
INTO TABLE PROJ
WHEN PROJNO != ‘   ‘
(EMPNO    POSITION(1:4)   INTEGER EXTERNAL,
PROJNO   POSITION(29:31) INTEGER EXTERNAL)   — 2nd proj
INTO TABLE PROJ
WHEN PROJNO != ‘   ‘
(EMPNO    POSITION(1:4)   INTEGER EXTERNAL,
PROJNO   POSITION(33:35) INTEGER EXTERNAL)   — 3rd proj

— 数据文件;

1234 BAKER      10 9999 101 102 103
1234 JOKER      10 9999 777 888 999
2664 YOUNG      20 2893 425 abc 102
5321 OTOOLE     10 9999 321 55 40
2134 FARMER     20 4555 236 456
2414 LITTLE     20 5634 236 456 40
6542 LEE        10 4532 102 321 14
2849 EDDS       xx 4555     294 40
4532 PERKINS    10 9999 40
1244 HUNT       11 3452 665 133 456
123 DOOLITTLE 12 9940         132
1453 MACDONALD 25 5532     200

— 导入数据:sqlldr scott/tiger control=/u01/sqlldrdemo/demo5.ctl;

— 验证数据;

— 检查不满足条件的记录;

— EXAMPLE6:使用直接路径的方式加载数据;

— 创建测试表;

DROP TABLE emp;
CREATE TABLE EMP
(
EMPNO    NUMBER(4) not null,
ENAME    CHAR(10),
JOB      CHAR(9),
MGR      NUMBER(4),
HIREDATE DATE,
SAL      NUMBER(7,2),
COMM     NUMBER(7,2),
DEPTNO   NUMBER(2)
)
CREATE UNIQUE INDEX unq_empno ON emp(empno);

— 控制文件;

LOAD DATA

INFILE ‘/u01/sqlldrdemo/demo6.dat’
REPLACE

INTO TABLE emp

SORTED INDEXES (unq_empno)
(empno position(1:4),
ename position(6:15),
job position(17:25),
mgr position(27:30) nullif mgr=blanks,
sal position(32:39) nullif sal=blanks,
comm position(41:48) nullif comm=blanks,
deptno position(50:51) nullif empno=blanks)

— 数据文件;

7566 JONES      MANAGER   7839 3123.75          20
7654 MARTIN     SALESMAN 7698 1312.50 1400.00 30
7658 CHAN       ANALYST   7566 3450.00          20
7782 CLARK      MANAGER   7839 2572.50          10
7839 KING       PRESIDENT       5500.00          10
7934 MILLER     CLERK     7782   920.00          10

— 导入数据:sqlldr scott/tiger control=/u01/sqlldrdemo/demo6.ctl direct=y;

— 验证数据;

— EXAMPLE7:从一个格式化的报表中抽取数据并加载;

— 创建测试表;

CREATE TABLE EMP
(
EMPNO    NUMBER(4) not null,
ENAME    CHAR(10),
JOB      CHAR(9),
MGR      NUMBER(4),
HIREDATE DATE,
SAL      NUMBER(7,2),
COMM     NUMBER(7,2),
DEPTNO   NUMBER(2)
);
CREATE UNIQUE INDEX UNQ_EMPNO on EMP (EMPNO);

— 添加触发器,这一步是关键;

CREATE OR REPLACE PACKAGE sqlloader AS
last_deptno NUMBER;
last_job     CHAR(9);
last_mgr     NUMBER;
END sqlloader;CREATE OR REPLACE TRIGGER sqlloader_emp_insert
BEFORE INSERT ON emp
FOR EACH ROW
BEGIN
IF :new.deptno IS NOT NULL THEN
sqlloader.last_deptno := :new.deptno;   — save value for later use
ELSE
:new.deptno := sqlloader.last_deptno;   — use last valid value
END IF;
IF :new.job IS NOT NULL THEN
sqlloader.last_job := :new.job;   — save value for later use
ELSE
:new.job := sqlloader.last_job;   — use last valid value
END IF;
IF :new.mgr IS NOT NULL THEN
sqlloader.last_mgr := :new.mgr;   — save value for later use
ELSE
:new.mgr := sqlloader.last_mgr;   — use last valid value
END IF;
END sqlloader_emp_insert;

— 控制文件;

LOAD DATA
INFILE ‘/u01/sqlldrdemo/demo7.dat’

DISCARDFILE ‘/u01/sqlldrdemo/demo7.dis’

APPEND
INTO TABLE emp
WHEN (57)=’.’
TRAILING NULLCOLS
(hiredate SYSDATE,
deptno   POSITION(1:2) INTEGER EXTERNAL(3)
NULLIF deptno=BLANKS,
job      POSITION(7:14)   CHAR TERMINATED BY WHITESPACE
NULLIF job=BLANKS “UPPER(:job)”,
mgr      POSITION(28:31) INTEGER EXTERNAL TERMINATED BY WHITESPACE
NULLIF mgr=BLANKS,
ename    POSITION (34:41) CHAR TERMINATED BY WHITESPACE
“UPPER(:ename)”,
empno    INTEGER EXTERNAL TERMINATED BY WHITESPACE,
sal      POSITION(51) CHAR TERMINATED BY WHITESPACE
“TO_NUMBER(:sal,’$99,999.99′)”,
comm     INTEGER EXTERNAL ENCLOSED BY ‘(‘ AND ‘%’
“:comm * 100”
)

— 数据文件;

Today’s Newly Hired EmployeesDept Job       Manager   MgrNo Emp Name EmpNo Salary/Commission
—- ——– ——– —– ——– —– —————–
20    Salesman Blake      7698 Shepard    8061 $1,600.00 (3%)
Falstaff   8066 $1,250.00 (5%)
Major      8064 $1,250.00 (14%)

30    Clerk     Scott      7788 Conrad     8062 $1,100.00
Ford       7369 DeSilva    8063    $800.00
Manager   King       7839 Provo      8065 $2,975.00

— 导入数据:sqlldr scott/tiger control=/u01/sqlldrdemo/demo7.ctl;

— 验证数据;

— 查看不满足的记录;

— EXAMPLE8:加载分区表;

— 创建测试表;

CREATE TABLE LINEITEM
(
L_ORDERKEY      NUMBER,
L_PARTKEY       NUMBER,
L_SUPPKEY       NUMBER,
L_LINENUMBER    NUMBER,
L_QUANTITY      NUMBER,
L_EXTENDEDPRICE NUMBER,
L_DISCOUNT      NUMBER,
L_TAX           NUMBER,
L_RETURNFLAG    CHAR(1),
L_LINESTATUS    CHAR(1),
L_SHIPDATE      DATE,
L_COMMITDATE    DATE,
L_RECEIPTDATE   DATE,
L_SHIPINSTRUCT CHAR(17),
L_SHIPMODE      CHAR(7),
L_COMMENT       CHAR(43)
)
PARTITION by RANGE (L_SHIPDATE)
(
PARTITION SHIP_Q1 VALUES LESS THAN (TO_DATE(‘1996-04-01 00:00:00’, ‘YYYY-MM-DD HH24:MI:SS’)),
PARTITION SHIP_Q2 VALUES LESS THAN (TO_DATE(‘1996-07-01 00:00:00’, ‘YYYY-MM-DD HH24:MI:SS’)),
PARTITION SHIP_Q3 VALUES LESS THAN (TO_DATE(‘1996-10-01 00:00:00’, ‘YYYY-MM-DD HH24:MI:SS’)),
PARTITION SHIP_Q4 VALUES LESS THAN (TO_DATE(‘1997-01-01 00:00:00’, ‘YYYY-MM-DD HH24:MI:SS’))
);

— 控制文件;

LOAD DATA
INFILE ‘/u01/sqlldrdemo/demo8.dat’ “fix 129”

BADFILE ‘/u01/sqlldrdemo/demo8.bad’

TRUNCATE
INTO TABLE lineitem
PARTITION (ship_q1)
(l_orderkey      position    (1:6) char,
l_partkey       position   (7:11) char,
l_suppkey       position (12:15) char,
l_linenumber    position (16:16) char,
l_quantity      position (17:18) char,
l_extendedprice position (19:26) char,
l_discount      position (27:29) char,
l_tax           position (30:32) char,
l_returnflag    position (33:33) char,
l_linestatus    position (34:34) char,
l_shipdate      position (35:43) char,
l_commitdate    position (44:52) char,
l_receiptdate   position (53:61) char,
l_shipinstruct position (62:78) char,
l_shipmode      position (79:85) char,
l_comment       position (86:128) char)

— 数据文件;

1 151978511724386.60 7.04.0NO09-SEP-6412-FEB-9622-MAR-96DELIVER IN PERSON
TRUCK iPBw4mMm7w7kQ zNPL i261OPP
1 2731 73223658958.28.09.06NO12-FEB-9628-FEB-9620-APR-96TAKE BACK RETURN
MAIL   5wM04SNyl0AnghCP2nx lAi
1 3370 3713 810210.96 .1.02NO29-MAR-9605-MAR-9631-JAN-96TAKE BACK RETURN
REG AIRSQC2C 5PNCy4mM
1 5214 46542831197.88.09.06NO21-APR-9630-MAR-9616-MAY-96NONE
AIR    Om0L65CSAwSj5k6k
1 6564 6763246897.92.07.02NO30-MAY-9607-FEB-9603-FEB-96DELIVER IN PERSON
MAIL   CB0SnyOL PQ32B70wB75k 6Aw10m0wh
1 7403 160524 31329.6 .1.04NO30-JUN-9614-MAR-9601 APR-96NONE
FOB    C2gOQj OB6RLk1BS15 igN
2 8819 82012441659.44 0.08NO05-AUG-9609-FEB-9711-MAR-97COLLECT COD
AIR    O52M70MRgRNnmm476mNm
3 9451 721230 41113.5.05.01AF05-SEP-9629-DEC-9318-FEB-94TAKE BACK RETURN
FOB    6wQnO0Llg6y
3 9717 1834440788.44.07.03RF09-NOV-9623-DEC-9315-FEB-94TAKE BACK RETURN
SHIP   LhiA7wygz0k4g4zRhMLBAM
3 9844 1955 6 8066.64.04.01RF28-DEC-9615-DEC-9314-FEB-94TAKE BACK RETURN
REG AIR6nmBmjQkgiCyzCQBkxPPOx5j4hB 0lRywgniP1297

— 导入数据:sqlldr scott/tiger control=/u01/sqlldrdemo/demo8.ctl;

— 验证数据;

— EXAMPLE9:加载CLOB列,为每个CLOB列准备一个文本文件;

— 创建测试表;

CREATE TABLE EMP
(
EMPNO    NUMBER(4) not null,
ENAME    CHAR(10),
JOB      CHAR(9),
MGR      NUMBER(4),
HIREDATE DATE,
SAL      NUMBER(7,2),
COMM     NUMBER(7,2),
DEPTNO   NUMBER(2),
RESUME   CLOB
)

— 控制文件;

LOAD DATA
INFILE *
INTO TABLE EMP
REPLACE
FIELDS TERMINATED BY ‘,’
( EMPNO    INTEGER EXTERNAL,
ENAME    CHAR,
JOB      CHAR,
MGR      INTEGER EXTERNAL,
SAL      DECIMAL EXTERNAL,
COMM     DECIMAL EXTERNAL,
DEPTNO   INTEGER EXTERNAL,
RES_FILE FILLER CHAR,
“RESUME” LOBFILE (RES_FILE) TERMINATED BY EOF NULLIF RES_FILE = ‘NONE’
)
BEGINDATA
7782,CLARK,MANAGER,7839,2572.50,,10,/u01/sqlldrdemo/demo91.dat
7839,KING,PRESIDENT,,5500.00,,10,/u01/sqlldrdemo/demo92.dat

7934,MILLER,CLERK,7782,920.00,,10,/u01/sqlldrdemo/demo93.dat

7566,JONES,MANAGER,7839,3123.75,,20,/u01/sqlldrdemo/demo94.dat

7499,ALLEN,SALESMAN,7698,1600.00,300.00,30,/u01/sqlldrdemo/demo95.dat

7654,MARTIN,SALESMAN,7698,1312.50,1400.00,30,/u01/sqlldrdemo/demo96.dat

7658,CHAN,ANALYST,7566,3450.00,,20,NONE

— 导入数据:sqlldr scott/tiger control=/u01/sqlldrdemo/demo9.ctl;

— 验证数据;

— EXAMPLE10:加载REF列和ARRAYs列;

— EXAMPLE11:转换字符集,使用Unicode编码加载数据;

————————- SQL*Loader的例子 ————————-

————————- 外部表 ORACLE_LOADER引擎的例子 ————————-
— 手动编写外部表语法;

1.创建DIRECTORY对象;

CREATE DIRECTORY ext_tab_dir AS ‘/u01/datafiles’;
SELECT * FROM dba_directories WHERE directory_name = ‘EXT_TAB_DIR’;

2.对用户授权;

GRANT READ, WRITE ON DIRECTORY ext_tab_dir TO hr;
SELECT * FROM dba_tab_privs WHERE table_name = ‘EXT_TAB_DIR’;

3.测试数据/u01/datafiles/emp.dat;

“56”, “baker”, “mary”, “f”, “01-09-2004”, “15-11-1980”
“87”, “roper”, “lisa”, “m”, “01-06-1999”, “20-12-1970”

4.创建外部表;

CREATE TABLE ext_tab_emp
(
ID            INTEGER,
first_name    VARCHAR2(20),
last_name     VARCHAR2(20),
male          CHAR(1),
birthday      DATE,
hire_date     DATE
)
ORGANIZATION EXTERNAL
(
TYPE ORACLE_LOADER
DEFAULT DIRECTORY ext_tab_dir
ACCESS PARAMETERS
(
RECORDS DELIMITED BY NEWLINE
BADFILE ‘EXT_TAB_DIR’:’emp.bad’
DISCARDFILE ‘EXT_TAB_DIR’:’emp.dis’
LOGFILE ‘EXT_TAB_DIR’:’emp.log’
FIELDS TERMINATED BY “,” OPTIONALLY ENCLOSED BY ‘”‘ LDRTRIM
REJECT ROWS WITH ALL NULL FIELDS
(
ID            CHAR(20) TERMINATED BY “,” OPTIONALLY ENCLOSED BY ‘”‘,
first_name    CHAR(20),
last_name     CHAR(20),
male          CHAR(1),
birthday      CHAR(20) date_format DATE mask “DD-MM-YYYY”,
hire_date     CHAR(20) date_format DATE mask “DD-MM-YYYY”
)
)
LOCATION (’emp.dat’, ’emp1.dat’)
) PARALLEL 2;
5.查看数据;

SELECT * FROM ext_tab_emp;

6.查看日志发现,如果使用并行的话会有多个线程同时工作,提高效率;

— 使用SQL*LOADER工具生成创建外部表的语法;

1.测试数据/u01/datafiles/car.dat;

Talbot,8/18,4,01-MAR-1923,ohv,8,295.00
Talbot,10/23,4,12-MAR-1923,ohv,8.9,375.00
Talbot,12/30,6,23-JAN-1924,ohv,13.4,550.00
Sunbeam,14/40,4,06-MAR-1924,ohv,13.9,895.00
Sunbeam,12/30,4,08-FEB-1924,ohv,11.5,570.00
Sunbeam,20/60,6,24-FEB-1924,ohv,20.9,950.00
Sunbeam,Twin Cam,6,11-MAR-1926,ohv,20.9,1125.00
Sunbeam,20,6,15-JUN-1927,ohv,20.9,750.00
Sunbeam,16,6,10-SEP-1927,ohv,16.9,550.00
Peugeot,172,4,28-SEP-1928,sv,6.4,165.00
Austin,7,4,29-JAN-1922,sv,7.2,225.00
Austin,12,4,01-JAN-1922,sv,12.8,550.00
Austin,20,4,04-JAN-1916,sv,22.4,616.00
Lanchester,40,6,08-JAN-1919,ohv,38.4,1875.00
Lanchester,21,6,16-JAN-1924,ohv,20.6,950.00
Vauxhall,30/98,4,18-JAN-1919,sv,23.8,1475.00
Vauxhall,23/60,4,27-JAN-1919,sv,22.4,1300.00

2.hr用户下的表结构;

3.控制文件/u01/datafiles/car.ctl;

LOAD DATA
INFILE ‘/u01/datafiles/car.dat’
BADFILE ‘/u01/datafiles/car.bad’
DISCARDFILE ‘/u01/datafiles/car.dsc’
APPEND
INTO TABLE car
FIELDS TERMINATED BY “,”
TRAILING NULLCOLS
(maker,
model,
no_cyl,
first_built_date,
engine,
hp,
price)

4.生成创建外部表的脚本;

sqlldr hr/hr control=/u01/datafiles/car.ctl external_table=GENERATE_ONLY;

5.适当修改即可;

conn hr/hr
CREATE TABLE car_ext
(
“MAKER” VARCHAR2(20),
“MODEL” VARCHAR2(20),
“NO_CYL” NUMBER,
“FIRST_BUILT_DATE” DATE,
“ENGINE” VARCHAR2(20),
“HP” NUMBER(10,1),
“PRICE” NUMBER(10,2)
)
ORGANIZATION external
(
TYPE oracle_loader
DEFAULT DIRECTORY EXT_TAB_DIR — 必须大写

ACCESS PARAMETERS
(
RECORDS DELIMITED BY NEWLINE CHARACTERSET US7ASCII
BADFILE ‘EXT_TAB_DIR’:’car.bad’

DISCARDFILE ‘EXT_TAB_DIR’:’car.dsc’

LOGFILE ‘EXT_TAB_DIR’:’car.log’

READSIZE 1048576
FIELDS TERMINATED BY “,” LDRTRIM
MISSING FIELD VALUES ARE NULL
REJECT ROWS WITH ALL NULL FIELDS
(
“MAKER” CHAR(255) TERMINATED BY “,”,
“MODEL” CHAR(255) TERMINATED BY “,”,
“NO_CYL” CHAR(255) TERMINATED BY “,”,
“FIRST_BUILT_DATE” CHAR(255) TERMINATED BY “,”,
“ENGINE” CHAR(255) TERMINATED BY “,”,
“HP” CHAR(255) TERMINATED BY “,”,
“PRICE” CHAR(255) TERMINATED BY “,”
)
)
location
(
‘car.dat’
)
)REJECT LIMIT UNLIMITED;

————————- 外部表 ORACLE_LOADER引擎的例子 ————————-

————————- 外部表 ORACLE_DATAPUMP引擎的例子 ————————-

— 卸载数据;

1.目标:卸载执行查询结果集的数据,并创建外部表;

conn hr/hr;

SELECT e.first_name, e.last_name, e.email, e.phone_number, d.department_name FROM EMPLOYEES e INNER JOIN DEPARTMENTS d ON e.department_id = d.department_id;

2.创建目录并授权;

CREATE DIRECTORY EXT_TAB_DIR AS ‘/u01/datafiles’;

GRANT READ, WRITE ON DIRECTORY EXT_TAB_DIR TO hr;

3.把数据导出为EMP_DEPT.dmp文件,创建外部表;

conn hr/hr;

CREATE TABLE emp_dept_ext
ORGANIZATION EXTERNAL
(
TYPE ORACLE_DATAPUMP
DEFAULT DIRECTORY EXT_TAB_DIR LOCATION (‘EMP_DEPT.dmp’)

)
AS

SELECT e.first_name, e.last_name, e.email, e.phone_number, d.department_name FROM EMPLOYEES e INNER JOIN DEPARTMENTS d ON e.department_id = d.department_id;

— 导入数据;

目标:把导出的数据导入到hr用户下t1表中;

conn hr/hr;

CREATE TABLE t1
(
FIRST_NAME VARCHAR2(20),
LAST_NAME VARCHAR2(25),
EMAIL VARCHAR2(25),
PHONE_NUMBER VARCHAR2(20),
DEPARTMENT_NAME VARCHAR2(30)
)
ORGANIZATION EXTERNAL
(
TYPE ORACLE_DATAPUMP
DEFAULT DIRECTORY EXT_TAB_DIR
LOCATION (‘EMP_DEPT.dmp’)

);

————————- 外部表 ORACLE_DATAPUMP引擎的例子 ————————-

导入导出工具01–EXP/IMP和EXPDP/IMPDP工具的使用

Posted on 2011-12-27 by royalwzy

EXP/IMP和EXPDP/IMPDP工具的使用

exp/imp:
1. 概念:
  1. 早期的oracle数据导入导出工具,效率比较低,可以用在小数据量的情况下;
  2. 可以在服务器端或者客户端操作,数据可以存放在服务器端或者客户端;
  3. 只能导出导出二进制的dump文件;
2. 使用exp/imp工具的前提:
  1. 运行catexp.sql或者catalog.sql脚本;
  2. 保证有足够的空间;
  3. 保证有足够的权限;
    1. 对于exp:必须有CREATE SESSION权限,如果要导出其它用户下的表,还需要有EXP_FULL_DATABASE角色;
    2. 对于imp:必须有CREATE SESSION权限,如果要导入其它用户创建的dump文件,还需要有IMP_FULL_DATABASE角色;
3. 调用exp/imp的方法:
  1. 命令行接口,常用;
  2. 交互模式;
  3. 使用参数文件方式,常用;
  4. 使用OEM调用;
4. EXP工具:
  1. 用途:
    1. 归档历史数据;
    2. 保存表的结构信息;
    3. 可以在不同的服务器,不同的平台上传输数据;
    4. 传输表空间时使用;
  2. 导出的四种模式:
    1. Table Mode:包括表的定义,数据,用户拥有的表和索引,表上的约束;
    2. User Mode:用户下所有的对象;
    3. Tablespace Mode:某一个表空间中所有的对象,主要用于传输表空间;
    4. Full Database Mode:不推荐的方式,可以使用rman替代;
  3. 语法:exp keyword=value1,value2,…,valuen;
    1. USERID=user/pwd:用户名和密码;
    2. BUFFER:指定数据缓冲区的大小;
    3. FILE:导出文件的名称;
    4. FILESIZE:每个导出文件的最大大小,如果导出文件很大,可以限制每个文件的大小,使用多个文件来保存数据;
    5. COMPRESS:是否使用压缩,默认为Y;
    6. GRANTS:是否导出用户的权限,默认为Y;
    7. ROWS:是否导出表的记录,默认为Y;
    8. INDEXES:是否导出索引,默认为Y;
    9. TRIGGERS:是否导出触发器,默认为Y;
    10. CONSTRAINTS:是否导出表上的约束,默认为Y;
    11. DIRECT:是否使用直接路径导出,默认为N,只能使用命令行方式,BUFFER参数无效;
    12. LOG:指定日志文件;
    13. PARFILE:指定参数文件;
    14. FULL:导出整个数据库,全库导出时使用,不常用;
    15. OWNER:列出要导出的用户,导出用户模式;
    16. TABLES:列出要导出的表的名称(schema.table:partition),支持通配符,导出表模式;
    17. TABLESPACES:列出要导出的表空间,导出表空间模式;
    18. TRANSPORT_TABLESPACE:是否导出表空间的元信息,默认为N,传输表空间时使用;
    19. FEEDBACK=n:显示导出的进度,n条记录打一个点;
    20. QUERY:使用查询语句来过滤要导出的记录,eg:exp scott/tiger TABLES=emp QUERY=\”WHERE job=\’SALESMAN\’ and sal \<1600\”;
    21. CONSISTENT:是否在导出开始时设置SET TRANSACTION READ ONLY语句来保证整个导出期间的数据一致性,默认为N,推荐为Y;
    22. OBJECT_CONSISTENT:保证导出某个对象期间,这个对象是只读的,默认为N,推荐为Y;
    23. FLASHBACK_SCN:从指定的SCN开始导出数据;
    24. FLASHBACK_TIME:从指定的时间开始导出数据,内部会转化为SCN号码,可以使用TO_TIMESTAMP函数来转化字符串格式的时间;
    25. STATISTICS:当导出的对象被导入时,是否分析对象,默认为ESTIMATE;
    26. RESUMABLE:当空间不足时是否会挂起,等待分配空间后继续导出,默认是N;
    27. RESUMABLE_NAME:指定挂起语句的标识符;
    28. RESUMABLE_TIMEOUT:等待的时间;
    29. RECORDLENGTH:记录的长度;
    30. INCTYPE:增量导出类型;
    31. RECORD:跟踪增量导出,默认为Y;
5. IMP工具:
  1. 用途:
    1. 可以执行完全导入或者累计导入;
    2. 主要用于恢复用户错误;
  2. 导入介绍:
    1. 先创建表的定义;
    2. 然后从exp的dmp文件中抽取数据;
    3. 创建索引;
    4. 导入触发器;
    5. 开启数据完整性约束检查;
    6. 创建位图索引,序列等对象;
  3. 导入的模式:
    1. 表模式;
    2. 用户模式;
    3. 表空间模式,用户可传输表空间;
    4. 全库模式,不常用;
  4. 语法:imp keyword=value1,value2,…,valuen;
    1. USERID=user/pwd:用户名和密码;
    2. BUFFER:指定数据缓冲区的大小;
    3. FILE:要导入的文件的名称;
    4. FILESIZE:每个导入文件的最大大小;
    5. SHOW:查看要导入的dmp文件中的内容,并不进行导入操作;
    6. IGNORE:是否忽略创建对象时的错误,默认为N,表示出错时输出错误日志;
    7. GRANTS:是否导入用户的权限,默认为Y;
    8. ROWS:是否导入表的记录,默认为Y;
    9. INDEXES:是否导入索引,默认为Y;
    10. TRIGGERS:是否导入触发器,默认为Y;
    11. CONSTRAINTS:是否导入表上的约束,默认为Y;
    12. LOG:指定日志文件;
    13. PARFILE:指定参数文件;
    14. FULL:导出整个数据库,全库导出时使用,不常用;
    15. FROMUSER:在用户模式下使用,指定要导入的用户;
    16. TOUSER:与FROMUSER连用,指定要转变的用户列表,如fromuser=u1 touser=u2,即把u1下的对象创建在u2下;这个用户必须预先存在,否则会报错;
    17. TABLES:列出要导入的表的名称(schema.table:partition);
    18. TABLESPACES:列出要导入的表空间,导出表空间模式;
    19. TRANSPORT_TABLESPACE:是否导入表空间的元信息,默认为N,传输表空间时使用;
    20. FEEDBACK=n:显示导入的进度,n条记录打一个点;
    21. STATISTICS:导入对象时,是否分析对象,默认为AWAYS;
    22. RESUMABLE:当空间不足时是否会挂起,等待分配空间后继续导出,默认是N;
    23. RESUMABLE_NAME:指定挂起语句的标识符;
    24. RESUMABLE_TIMEOUT:等待的时间;
    25. RECORDLENGTH:记录的长度;
    26. INCTYPE:增量导入类型;
    27. COMMIT:指定是否导入一组数据后就提交,默认为N,表示每导入一个表提交一次;
    28. DESTROY:是否覆盖表空间的数据文件,默认为N;
    29. INDEXFILE:把表和索引写入指定的文件中;
    30. SKIP_UNUSABLE_INDEXES:跳过不可用索引维护;
    31. TOID_NOVALIDATE:跳过指定类型ID的验证;
    32. COMPILE:是否马上编译导入的包,存储过程和函数,默认为Y;如果为N,表示第一次使用时编译;
    33. STREAMS_CONFIGURATION:导入stream的一般元数据,默认为Y;
    34. STREAMS_INSTANTIATION:导入stream的实例元数据,默认为N;
    35. DATAFILES:当TRANSPORT_TABLESPACE=Y时,使用此参数传输导入与数据库的数据文件;
6. 字符集转换:
  1. 数据从源数据库导出,传输到目标服务器(ftp/scp/tape),然后导入到目标数据库一共有四个环境的字符集:
    1. 源数据库的字符集和NCHAR字符集;
    2. 源数据库服务器导出时的字符集(通过NLS_LANG环境变量设置);
    3. 目标数据库服务器导入时的字符集(通过NLS_LANG环境变量设置);
    4. 目标数据库的字符集和NCHAR字符集;
    5. 源数据库和目标数据库的字符集相同,可能会发生3次字符集转换(导出,传输,导入),如果不相同,一定会发生转换或者导入错误;
  2. 查看数据库的字符集:select * from nls_database_parameters,可以看得出语言是AMERICAN,区域是AMERICA,字符集是WE8ISO8859P1,NCHAR是AL16UTF16;
  3. 设置服务器的环境变量:export NLS_LANG=NLS_LANGUAGE_NLS_TERRITORY.NLS_CHARACTERSET;
  4. 查看现有的dmp文件的字符集:首先设置当前服务器的字符集与数据库字符集一致,然后使用imp show=y命令,可以查看到导出时的字符集;
  5. 字符集换换的拓扑图;
7. 传输表空间的原理:
  1. 如果把数据导出再导出效率太低;
  2. 传输表空间的做法是:只导出表空间的元信息,应用到目标数据库,表空间的数据使用数据块拷贝的方式;
expdp/impdp:
1. 概念:
  1. 带有数据泵的oracle数据导入导出工具,比较高效;
  2. 只能在服务器端操作,因为需要使用DIRECTORY,数据只能存放在服务器;
  3. 只能导出导出二进制的dump文件;
  4. 主要是调用DBMS_DATAPUMP的包;
2. expdp:
  1. 语法:expdp user/pwd key=value;
    1. COMPRESSION:压缩数据;
      1. METADATA_ONLY:默认值,只压缩元数据;
      2. NONE:不压缩;
    2. CONTENT:指定要导出的内容;
      1. ALL:导出对象的定义和数据;
      2. DATA_ONLY:导出对象的数据;
      3. METADATA_ONLY:导出对象的定义;
    3. DIRECTORY:用于存放dump文件和日志文件的目录对象;
    4. DUMPFILE:导出到dump文件的列表,格式为:[DIRECTORY:]file_name,如果不指定目录,则使用DIRECTORY参数指定的目录对象;
    5. FILESIZE:导出文件的最大大小,如果导出对象比较大,可以分成多个文件保存;
    6. LOGFILE:指定日志文件的名称;
    7. NOLOGFILE:默认为N,禁止生成日志文件;
    8. PARFILE:指定参数文件;
    9. ENCRYPTION_PASSWORD:指定加密列的密码;
    10. ESTIMATE:指定估算被导出表所占磁盘空间的方法;
      1. BLOCKS:默认值,按照目标对象所占用的数据块个数乘以数据块尺寸估算对象占用的空间;
      2. STATISTICS:据最近统计值估算对象占用空间;
    11. ESTIMATE_ONLY:默认值为N,如果为Y,则只估算导出作业占用的磁盘空间而不会执行;
    12. INCLUDE:指定要包含的对象类型和对象,格式:object_type[:name_clause];
      1. name_clause:必须是用双引号引起来的,因为里面的每个对象需要使用单引号;
      2. 使用LIKE子句:include=TABLE:”LIKE ‘B%'”,但是不能使用NOT LIKE;
      3. 使用IN子句:include=TABLE:”IN (‘T1’, ‘T2’)”;
      4. 使用<>子句:include=TABLE:”<> (‘T1’)”,但是不能使用[=];
      5. 只导出存储过程:indlude=PROCEDURE;
    13. EXCLUDE:排除指定的对象类型或者对象,格式与INCLUDE相似;
    14. FLASHBACK_SCN:指定SCN以后的数据;
    15. FLASHBACK_TIME:指定某个时间以后的数据,内部转化为最近的SCN号;
    16. JOB_NAME:把导出的任务创建一个JOB,指定作业的名称;
    17. ATTACH:使当前会话与已存在的导出作业建立联系,然后执行交互命令,eg:expdp user/pwd ATTACH=[schema_name.]job_name;
    18. NETWORK_LINK:指定目标数据库到源数据库的Database Link,用于将远程数据对象导出到本地的情况;
      1. 因为expdp是服务器端工具,如果expdp user/pwd@net_name的话导出的文件存放在服务器端;
      2. 如果expdp user/pwd NETWORK_LINK=dblink_name的话,则数据导出到本地;
      3. 导出的日志文件不能放到ASM上,只能存放数据文件;
    19. PARALLEL:指定导出的并行度,默认为1,推荐并行度等于给定的文件个数的整数倍,而且要小于CPU个数*2;
    20. QUERY:指定过滤导出数据的条件,格式:[schmea].[table_name:]query_clause;
    21. SAMPLE:导出数据的百分比;
    22. FULL:默认为N,数据库全库导出;
    23. SCHEMAS:导出数据的schema列表,默认为当前schema;
    24. TABLES:指定要导出的表的列表,格式为:[schema_name.]table_name[:partition_name];
    25. TABLESPACES:指定要导出的表空间;
    26. TRANSPORT_FULL_CHECK:默认为Y,检查要传输的表空间是否是自包含的;
    27. TRANSPORT_TABLESPACES:指定要要导出元数据的表空间的列表,主要用于传输表空间的情况;
    28. VERSION:指定导出对象的数据库的版本;
      1. COMPATIBLE:默认值;
      2. LATEST:会根据数据库的实际版本生成对象元数据;
      3. version_string用于指定数据库版本字符串;
    29. STATUS:用于指定显示当前导出作业执行状态的间隔,eg:STATUS[=interval],默认为0;
  2. 交互式命令:
    1. ADD_FILE:添加一个导出文件;
    2. FILESIZE:指定添加文件的文件大小;
    3. HELP:帮助;
    4. PARALLEL:改变导出作业的并行度,PARALLEL=<number of workers>;
    5. 进入expdp的作业会话:expdp user/pwd attch=schema.job_name;
    6. START_JOB:开始/恢复作业的执行;
    7. STOP_JOB:暂停作业,使用STOP_JOB=IMMEDIATE表示立即停止;
    8. EXIT_CLIENT(CTRL+C):退出当前session,让作业继续运行;
    9. CONTINUE_CLIENT:切换到日志模式,作业在空闲时会重新运行;
    10. KILL_JOB:断开与作业的连接,并停止作业,同时删除dmp文件;
    11. STATUS:用于指定显示当前导出作业执行状态的间隔,eg:STATUS[=interval],默认为0;
  3. 导出的步骤:
    1. 创建目录对象:CREATE DIRECTORY ext_tab_dir as ‘/u01/datafiles/’;
    2. 授权:GRANT READ, WRITE ON DIRECTORY ext_tab_dir TO hr;
    3. 执行导出:expdp hr/hr directory=ext_tab_dir schemas=hr dumpfile=expdp_hr1.dmp,expdp_hr2.dmp logfile=expdp_hr.log parallel=2 job_name=’job_expdp_hr’;(如果不指定JOB_NAME的话,会生成一个系统的名称,推荐指定;)
  4. 导出的各种场景:
    1. 按表模式导出:expdp hr/hr directory=ext_tab_dir tables=jobs,countries dumpfile=expdp_table1.dmp,expdp_table2.dmp logfile=expdp_table.log parallel=2 job_name=’job_expdp_table’;
    2. 按查询条件导出:expdp hr/hr directory=ext_tab_dir tables=jobs query='”where rownum<11″‘ dumpfile=expdp_hr_jobs.dmp logfile=expdp_hr_jobs.log job_name=’job_expdp_hr_jobs’;
    3. 按表空间导出:expdp system/oracle directory=ext_tab_dir tablespaces=USERS dumpfile=expdp_ts_users1.dmp,expdp_ts_users2.dmp logfile=expdp_ts_users.log parallel=2 job_name=’job_expdp_ts_users’;
    4. 导出方案:expdp hr/hr directory=ext_tab_dir schemas=hr dumpfile=expdp_hr1.dmp,expdp_hr2.dmp logfile=expdp_hr.log parallel=2 job_name=’job_expdp_hr’;
    5. 导出整个数据库:expdp hr/hr directory=ext_tab_dir dumpfile=full.dmp full=y logfile=full.log job_name=’job_expdp_full’;
3. impdp:
  1. 语法:impdp user/pwd key=value;
    1. REMAP_DATAFILE:重新定义DDL语句中引用的数据文件,用于将源数据文件转变为目标数据文件名,在不同平台之间搬移表空间时使用,eg:REMAP_DATAFIEL=source_datafie:target_datafile;
    2. REUSE_DATAFILES:默认是N,指定是否覆盖已存在的数据文件;
    3. REMAP_SCHEMA:将源schema的对象转换到目标schema中,eg:REMAP_SCHEMA=source_schema:target_schema;
    4. REMAP_TABLESPACE:将源表空间的对象导入到目标表空间中,eg:REMAP_TABLESPACE=source_tablespace:target_tablespace;
    5. SKIP_UNUSABLE_INDEXES:跳过不可使用的索引,默认为N;
    6. SQLFILE:把导出的dump文件中所有对象的DDL语句写到sql脚本中,eg:SQLFILE=[directory_object:]file_name;
    7. STREAMS_CONFIGURATION:是否导入流元数据库,默认是Y;
    8. TABLE_EXISTS_ACTION:当表已经存在时,导入作业要执行的操作;
      1. SKIP:默认跳过;
      2. APPEND:追加数据;
      3. REPLACE:删除表重建,然后再插入;
      4. TRUNCATE:截断;
    9. TRANSFORM:指定是否修改建立对象的DDL语句,eg:TRANSFORM=transform_name:value[:object_type];
      1. Transform_name:用于指定转换名:
        
        SEGMENT_ATTRIBUTES用于标识段属性(物理属性,存储属性,表空间,日志等信息);
        
        STORAGE用于标识段存储属性;
        
        OID;
        
        PCTSPACE;
      2. value:用于指定是否包含段属性或段存储属性;
      3. object_type用于指定对象类型;
    10. TRANSPORT_DATAFILES:用户指定传输表空间时被导入表空间对应的数据文件;
    11. TRANSPORT_TABLESPACES:列出传输表空间的元数据的表空间的列表,只是在NETWORK_LINK模式下操作;
  2. 交互式命令:与expdp一致;
4. 导入的各种场景:
  1. 按表导入,将hr用户下俩个表导入到scott用户下:impdp hr/hr directory=ext_tab_dir tables=jobs,countries dumpfile=expdp_table1.dmp,expdp_table2.dmp remap_schema=hr:scott logfile=impdp_table.log parallel=2 job_name=’job_impdp_table’;
  2. 按用户导入(如果用户存在则直接导入,要有目录对象的权限,如果不存在使用dba导入):impdp system/oracle directory=ext_tab_dir schemas=hr dumpfile=expdp_hr1.dmp,expdp_hr2.dmp logfile=impdp_hr.log parallel=2 job_name=’job_impdp_hr’;
  3. 在客户端执行expdp命令把导出文件存放在服务器端;
  4. 在客户端执行expdp命令把导入文件存放在客户端;
  5. 源数据库的数据直接导入到目标数据库,中间不产生任何的dump文件;

——————————— 查看DIRECTORY对象的权限 ———————————

SELECT d.directory_name, d.directory_path, p.grantee, p.privilege
FROM user_tab_privs p
INNER JOIN dba_directories d ON p.table_name = d.directory_name AND
d.directory_name = ‘EXT_TAB_DIR’;

——————————— 查看DIRECTORY对象的权限 ———————————

——————————— exp的例子 ———————————

— 导出scott用户下的所有对象:exp scott/tiger owner=scott file=/u01/exp/exp_scott.dmp log=exp_scott.log feedback=1000;(导出的字符集和当前环境的字符集不同,可能发生字符集转换;)

— 导出hr用户下的jobs,countries表:exp hr/hr tables=jobs,countries file=/u01/exp/exp_hr_tables.dmp log=/u01/exp/exp_hr_tables.log feedback=100;(导出的过程中出现警告,其实是因为字符集的问题;)

— 设置字符集导出,没有提示字符集可能发送转换,也没有警告;

——————————— exp的例子 ———————————

——————————— imp的例子 ———————————

— 把某个用户下的数据导入;

— 首先删除用户下所有的对象,然后创建用户(导入时此用户必须存在):drop user scott cascade;;

— 导入数据:imp scott/tiger file=/u01/exp/exp_scott.dmp fromuser=scott touser=scott;

— 把hr用户下的exp_jobs表导入到scott用户下(必须使用dba用户才可以完成):imp system/oracle file=/u01/exp/exp_jobs.dmp fromuser=hr touser=scott tables=exp_jobs feedback=100;

——————————— imp的例子 ———————————

——————————— NETWORK_LINK参数的测试 ———————————

— 1.配置两台数据库的tnsnames.ora,其中orcl_source指向源数据库,orcl_target指向目标数据库;

— 2.在源数据库添加一个目录对象dir_source,并授权给hr用户;

CREATE DIRECTORY dir_source AS ‘/u01/dump_source’;

GRANT READ, WRITE ON DIRECTORY dir_source TO hr;

— 3.使用网络名在客户端调用expdp命令,导出的文件存放在服务器端(用户必须要有CONNECT, RESOURCE, EXP_FULL_DATABASE角色和目录对象的读写权限即可);

expdp hr/hr@orcl_source directory=dir_source schemas=hr dumpfile=expdp_hr1.dmp,expdp_hr2.dmp logfile=expdp_hr.log parallel=2 job_name=’job_expdp_hr’;

— 4.在源数据库添加一个目录对象dir_target,并授权给hr用户;

CREATE DIRECTORY dir_target AS ‘/u01/dump_target’;
GRANT READ, WRITE ON DIRECTORY dir_target TO hr;

— 6.在目标端创建服务器端的Database Link;

CREATE PUBLIC DATABASE LINK dblink_source CONNECT TO hr identified by hr USING ‘ORCL_SOURCE’;

— 5.在目标服务器使用expdp命令,把导出的数据放到目标端;

expdp hr/hr network_link=dblink_source directory=dir_target schemas=hr dumpfile=expdp_hr1.dmp,expdp_hr2.dmp logfile=expdp_hr.log parallel=2 job_name=’job_expdp_hr’;

— 直接从源数据库导入到目标数据库,中间不生成任何的dump文件;

impdp system/oracle network_link=dblink_source directory=dir_target schemas=hr logfile=exp2imp.log parallel=2 job_name=’job_exp2imp’

——————————— NETWORK_LINK参数的测试 ———————————

——————————— INCLUDE/SQLFILE参数的测试 ———————————

— 导出HR用户下所有的PROCEDURE,SEQUENCE,TABLE对象;

expdp hr/hr directory=dir_source schemas=hr include=PROCEDURE,SEQUENCE,TABLE dumpfile=expdp_hr_part_objects.dmp logfile=expdp_hr_part_objects.log job_name=’job_expdp_hr_objects’;

— 导出dump文件中包含对象的DDL语句;

impdp system/oracle directory=dir_source dumpfile=expdp_hr_part_objects.dmp sqlfile=hr_objects.sql;

— 查看DDL语句:less /u01/dump_source/hr_objects.sql;

——————————— INCLUDE/SQLFILE参数的测试 ———————————

脚本工具01–把某一个字符串按照指定的分隔符分隔,并以Table形式返回

Posted on 2011-12-26 by royalwzy

CREATE OR REPLACE TYPE t_Table IS TABLE OF VARCHAR2(4000);

CREATE OR REPLACE FUNCTION FN_SplitStringByDelimiter(p_string IN VARCHAR2, p_delimiter IN VARCHAR2)

RETURN t_Table PIPELINED AS

v_delimiter_index INTEGER;

v_start_index INTEGER := 1;

v_table VARCHAR2(4000);

v_delimiter_length INTEGER := LENGTH(p_delimiter);

功能:把某一个字符串按照指定的分隔符分隔,并以Table形式返回

BEGIN

LOOP

— 查找当前分隔符的位置

v_delimiter_index := INSTR(p_string || p_delimiter, p_delimiter, v_start_index);

— 如果在字符串找不到字串则返回,退出循环

EXIT WHEN v_delimiter_index = 0;

— 得到分隔符前的值

v_table := SUBSTR(p_string, v_start_index, v_delimiter_index – v_start_index);

IF v_table IS NOT NULL THEN

— 返回该集合的单个元素

PIPE ROW(v_table);

END IF;

— 检索位置设置为当前分隔符的下一个

v_start_index := v_delimiter_index + v_delimiter_length;

END LOOP;

— 必须以一个空的RETURN 语句结束

RETURN;

END FN_SplitStringByDelimiter;

调用方法:SELECT column_value FROM TABLE(FN_SplitStringByDelimiter (‘a.b.c.d.e’, ‘.’));

SELECT column_value FROM TABLE(FN_SplitStringByDelimiter (‘123-;456-;789-;000’, ‘-;’));

VMWare下搭建Linux/Oralce环境

Posted on 2010-12-29 by royalwzy

因为要学习Oracle,所以整理了在虚拟机上安装Linux系统,然后安装Oracle10g的截图,希望能帮助想要了解这方面知识的童鞋,也方便自己以后查阅.因为中间都是截图,这个编辑器中上传截图太麻烦,所以就编辑的word,然后上传成了资源,如果谁有这方面的需要的话可以下载一下.

步骤:

1.在VMWare下安装Linux4.8系统

2.设置虚拟机中的Linux与主机通信

3.在Linux下安装Oracle10g

中间所需要的工具有:
1.SecureCRT6.5和SecureFX6.5

2.XManager3.0
欢迎下载并附带注册码.

royalwzy的学习笔记

Category Archives: Oracle

性能调优工具01–Sql Tuning Advisor工具的使用

调优实践02–ALTER SYSTEM/SESSION SET EVENTS转储

调优实践01–Oracle常见的等待事件及解决方案

ORACLE中工具的使用09–COPY

ORACLE中工具的使用08–OERR

ORACLE中工具的使用07–BBED

SQL调优01–SQL优化介绍

SQL调优04–阅读执行计划

SQL调优03–执行计划的访问路径

SQL调优02–CBO优化器的原理

ORACLE中工具的使用06–ORADEBUG

ORACLE中工具的使用05–TKPROF

ORACLE中工具的使用04–TRCSESS

ORACLE中工具的使用03–LogMiner

ORACLE中工具的使用02–DBVERIFY

ORACLE中工具的使用01–DBNEWID

导入导出工具02–SQL*Loader工具与外部表

导入导出工具01–EXP/IMP和EXPDP/IMPDP工具的使用

脚本工具01–把某一个字符串按照指定的分隔符分隔,并以Table形式返回

VMWare下搭建Linux/Oralce环境