CREATE TABLE ACL_OBJECT_IDENTITY(ID bigint(20)  NOT NULL auto_increment,
OBJECT_ID_CLASS bigint(20) NOT NULL,
OBJECT_ID_IDENTITY bigint(20) NOT NULL,
PARENT_OBJECT bigint(20),
OWNER_SID bigint(20),
ENTRIES_INHERITING tinyint(1) NOT NULL,
CONSTRAINT UNIQUE_UK_3 unique key(OBJECT_ID_CLASS,OBJECT_ID_IDENTITY),
CONSTRAINT FOREIGN_FK_1 FOREIGN KEY(PARENT_OBJECT)REFERENCES ACL_OBJECT_IDENTITY(ID),
CONSTRAINT FOREIGN_FK_2 FOREIGN KEY(OBJECT_ID_CLASS)REFERENCES ACL_CLASS(ID),
CONSTRAINT FOREIGN_FK_3 FOREIGN KEY(OWNER_SID)REFERENCES ACL_SID(ID)
PRIMARY KEY  (`id`)
)

CREATE TABLE ACL_ENTRY(ID bigint(20)  NOT NULL auto_increment,
ACL_OBJECT_IDENTITY BIGINT(20) NOT NULL,
ACE_ORDER INT(11) NOT NULL,
SID BIGINT(20) NOT NULL,
MASK INTEGER NOT NULL,
GRANTING BOOLEAN NOT NULL,AUDIT_SUCCESS BOOLEAN NOT NULL,
AUDIT_FAILURE BOOLEAN NOT NULL,
CONSTRAINT UNIQUE_UK_4 UNIQUE(ACL_OBJECT_IDENTITY,ACE_ORDER),
CONSTRAINT FOREIGN_FK_4 FOREIGN KEY(ACL_OBJECT_IDENTITY) REFERENCES ACL_OBJECT_IDENTITY(ID),
CONSTRAINT FOREIGN_FK_5 FOREIGN KEY(SID) REFERENCES ACL_SID(ID)
PRIMARY KEY  (`id`)
)

CREATE TABLE USERS(USERNAME varchar(50) NOT NULL ,
PASSWORD varchar(50) NOT NULL,
ENABLED BOOLEAN NOT NULL
PRIMARY KEY  (USERNAME)
)
           

 CREATE TABLE AUTHORITIES(USERNAME varchar(50) NOT NULL,
 AUTHORITY varchar(50) NOT NULL,
 CONSTRAINT FK_AUTHORITIES_USERS FOREIGN KEY(USERNAME) REFERENCES USERS(USERNAME));
 
CREATE UNIQUE INDEX IX_AUTH_USERNAME ON AUTHORITIES(USERNAME,AUTHORITY
)

CREATE TABLE CONTACTS(ID BIGINT(20) NOT NULL PRIMARY KEY, CONTACT_NAME varchar(50) NOT NULL,
EMAIL varchar(50) NOT NULL)
PRIMARY KEY  (`id`)

CREATE TABLE Productions(ID BIGINT(20) NOT NULL ,
contactid BIGINT(20) NOT NULL,
production_NAME varchar(50) NOT NULL,
EMAIL varchar(50) NOT NULL
PRIMARY KEY  (`id`)
)

-- add a unique constraint
ALTER TABLE personal_info
  ADD CONSTRAINT personal_info_unique_con
  UNIQUE (social_security_id);

-- add a check constraint
ALTER TABLE personal_info
  ADD CONSTRAINT personal_info_check_con
  CHECK ( dependents_claimed > 0);

-- enable a constraint
ALTER TABLE personal_info
  ENABLE CONSTRAINT personal_info_check_con;

-- drop a constraint
ALTER TABLE personal_info
  DROP CONSTRAINT personal_info_check_con;
NVL2   NVL
ALTER TABLE my_birthdays RENAME to birthdays;
-- create an index on a single column to make queries faster on that column
CREATE INDEX emp_hiredate_idx ON employees (hire_date);

-- rename the index
ALTER INDEX emp_hiredate_idx
  RENAME TO emp_hire_date_idx;

-- drop the index
DROP INDEX emp_hire_date_idx;

-- create an index on two columns to make queries faster on the first column
-- or both columns
CREATE INDEX emp_mgr_id_ix ON employees (employee_id, manager_id);
DROP INDEX emp_mgr_id_ix;

-- a function-based index precalculates the result and speeds up queries that
-- use the function for searching or sorting, in this case UPPER(last_name)
CREATE INDEX emp_upper_last_name_ix ON employees (UPPER(last_name));
DROP INDEX emp_upper_last_name_ix;
CREATE OR REPLACE VIEW my_emp_view AS
SELECT d.department_id, d.department_name, d.manager_id,
  e.employee_id, e.first_name, e.last_name
  FROM employees e, departments d
  WHERE d.manager_id = e.employee_id;
 CURRVAL and NEXTVAL
CREATE SEQUENCE new_employees_seq START WITH 1000 INCREMENT BY 1;
DECODE(job_id, 'PU_CLERK', salary*1.05,--IF THEN  ELSE
                             salary) "Revised Salary" FROM employees;
CREATE SYNONYM emps for HR.employees;
PL/SQL:anonymous blocks, stored functions, stored procedures, and packages
DBMS_OUTPUT.PUT_LINE
DECLARE
  monthly_salary         NUMBER(6);
  number_of_days_worked  NUMBER(2);
  pay_per_day            NUMBER(6,2);

-- the following is the executable part, from BEGIN to END
BEGIN
  monthly_salary := 2290;
  number_of_days_worked := 21;
  pay_per_day := monthly_salary/number_of_days_worked;

-- the following displays output from the PL/SQL block
  DBMS_OUTPUT.PUT_LINE('The pay per day is ' || TO_CHAR(pay_per_day));

-- the following is an optional exception part that handles errors
EXCEPTION
  WHEN ZERO_DIVIDE THEN
      pay_per_day := 0;

END;
/
CONSTANT  :=
use the special qualifiers %TYPE and %ROWTYPE to declare variables that hold table columns or table rows.
IF-THEN, IF-THEN-ELSE, or IF-THEN-ELSEIF-ELSE
EXIT-WHEN
-- use WHILE LOOP to process data
  WHILE i <= 10 LOOP
    i_cubed := i**3;
    DBMS_OUTPUT.PUT_LINE('Number: ' || TO_CHAR(i)
                       || ' Cube: ' || TO_CHAR(i_cubed));
    i := i + 1;
  END LOOP;
  FOR loop_counter IN 1..10 LOOP
    DBMS_OUTPUT.PUT_LINE('Number: ' || TO_CHAR(loop_counter)
                          || ' Square: ' || TO_CHAR(loop_counter**2));
  END LOOP;
   GOTO print_now;
    END IF;
  END LOOP;
  p := ' is a prime number';
<<print_now>>

IN  OUT IN OUT

A
 ALL, ALTER, AND, ANY, ARRAY, ARROW, AS, ASC, AT
 
B
 BEGIN, BETWEEN, BY
 
C
 CASE, CHECK, CLUSTERS, CLUSTER, COLAUTH, COLUMNS, COMPRESS, CONNECT, CRASH, CREATE, CURRENT
 
D
 DECIMAL, DECLARE, DEFAULT, DELETE, DESC, DISTINCT, DROP
 
E
 ELSE, END, EXCEPTION, EXCLUSIVE, EXISTS
 
F
 FETCH, FORM, FOR, FROM
 
G
 GOTO, GRANT, GROUP
 
H
 HAVING
 
I
 IDENTIFIED, IF, IN, INDEXES, INDEX, INSERT, INTERSECT, INTO, IS
 
L
 LIKE, LOCK
 
M
 MINUS, MODE
 
N
 NOCOMPRESS, NOT, NOWAIT, NULL
 
O
 OF, ON, OPTION, OR, ORDER,OVERLAPS
 
P
 PRIOR, PROCEDURE, PUBLIC
 
R
 RANGE, RECORD, RESOURCE, REVOKE
 
S
 SELECT, SHARE, SIZE, SQL, START, SUBTYPE
 
T
 TABAUTH, TABLE, THEN, TO, TYPE
 
U
 UNION, UNIQUE, UPDATE, USE
 
V
 VALUES, VIEW, VIEWS
 
W
 WHEN, WHERE, WITH
 

A
 ACCESS, ADD*, ALL*, ALTER*, AND*, ANY*, AS*, ASC*, AUDIT
 
B
 BETWEEN*, BY*
 
C
 CHAR*, CHECK*, CLUSTER, COLUMN, COMMENT, COMPRESS, CONNECT*, CREATE*, CURRENT*
 
D
 DATE*, DECIMAL*, DEFAULT*, DELETE*, DESC*, DISTINCT*, DROP*
 
E
 ELSE*, EXCLUSIVE, EXISTS
 
F
 FILE, FLOAT*, FOR*, FROM*
 
G
 GRANT*, GROUP*
 
H
 HAVING*
 
I
 IDENTIFIED, IMMEDIATE*, IN*, INCREMENT, INDEX, INITIAL, INSERT*, INTERSECT*, INTO*, IS*
 
L
 LEVEL*, LIKE*, LOCK, LONG
 
M
 MAXEXTENTS, MINUS, MLSLABEL, MODE, MODIFY
 
N
 NOAUDIT, NOCOMPRESS, NOT*, NOWAIT, NULL*, NUMBER
 
O
 OF*, OFFLINE, ON*, ONLINE, OPTION*, OR*, ORDER*
 
P
 PCTREE, PRIOR*, PRIVLEGES*, PUBLIC*
 
R
 RAW, RENAME, RESOURCE, REVOKE*, ROW, ROWID, ROWNUM, ROWS*
 
S
 SELECT*, SESSION*, SET*, SHARE, SIZE*, SMALLINT*, START, SUCCESSFUL, SYNONYM, SYSDATE
 
T
 TABLE*, THEN*, TO*, TRIGGER
 
U
 UID, UNION*, UNIQUE*, UPDATE*, USER*
 
V
 VALIDATE, VALUES*, VARCHAR*, VARCHAR2, VIEW*
 
W
 WHENEVER*, WHERE, WITH*
 

&my_variable &&my_variable DEFINE &my_variable="aaa"

V$RESERVED_WORDS
SELECT * FROM USER_OBJECTS
DESCRIBE wordcount
GRANT/REVOKE EXECUTE ON wordcount TO/FROM scoot
SELECT table_name, grantee,privilege FROM USER_TAB_PRIVS_MADE ;
EXEC DBMS_OUTPUT.PUT_LINE(booktitle('00-908-77889-0'))

HEADER
IS
 Declaration Section
BEGIN 
 Execution Section
EXCEPTION
 Exception Section
END;

DESC SYS.STANDARD

SELECT * FROM V$RESERVED_WORDS; GET RESERVED WORDS OF ORACLE

update standarditem set 規格=replace(規格,'','')
什么是索引
　　
　　索引是建立在表的一列或多个列上的辅助对象，目的是加快访问表中的数据；
　　
　　Oracle存储索引的数据结构是B*树，位图索引也是如此，只不过是叶子节点不同B*数索引；
　　
　　索引由根节点、分支节点和叶子节点组成，上级索引块包含下级索引块的索引数据，叶节点包含索引数据和确定行实际位置的rowid。
　　
使用索引的目的
　　加快查询速度
　　减少I/O操作
　　消除磁盘排序
　　
何时使用索引
　　查询返回的记录数
　　排序表<40%
　　非排序表 <7%
　　表的碎片较多（频繁增加、删除）
　　
索引的种类
　　非唯一索引（最常用）
　　唯一索引
　　位图索引
　　局部有前缀分区索引
　　局部无前缀分区索引
　　全局有前缀分区索引
　　散列分区索引
　　基于函数的索引
　　
管理索引的准则
　　
　　在表中插入数据后创建索引
　　
　　。在用SQL*Loader或import工具插入或装载数据后，建立索引比较有效；
　　
　　索引正确的表和列
　　
　　。经常检索排序大表中40%或非排序表7%的行，建议建索引；
　　。为了改善多表关联，索引列用于联结；
　　。列中的值相对比较唯一；
　　。取值范围（大：B*树索引，小：位图索引）；
　　。Date型列一般适合基于函数的索引；
　　。列中有许多空值，不适合建立索引
　　
　　为性能而安排索引列
　　
　　。经常一起使用多个字段检索记录，组合索引比单索引更有效；
　　。把最常用的列放在最前面，例：dx_groupid_serv_id(groupid,serv_id)，在where条件中使用groupid或groupid,serv_id，查询将使用索引，若仅用到serv_id字段，则索引无效；
　　。合并/拆分不必要的索引。
　　
　　限制每个表索引的数量
　　
　　。一个表可以有几百个索引（你会这样做吗？），但是对于频繁插入和更新表，索引越多系统CPU，I/O负担就越重；
　　。建议每张表不超过5个索引。
　　
　　删除不再需要的索引
　　
　　。索引无效，集中表现在该使用基于函数的索引或位图索引，而使用了B*树索引；
　　。应用中的查询不使用索引；
　　。重建索引之前必须先删除索引，若用alter index … rebuild重建索引，则不必删除索引。
　　
　　索引数据块空间使用
　　
　　。创建索引时指定表空间，特别是在建立主键时，应明确指定表空间；
　　。合理设定pctfress，注意：不能给索引指定pctused；
　　。估计索引的大小和合理地设置存储参数，默认为表空间大小，或initial与next设置成一样大。
　　
　　考虑并行创建索引
　　
　　。对大表可以采用并行创建索引，在并行创建索引时，存储参数被每个查询服务器进程分别使用，例如：initial为1M，并行度为8，则创建索引期间至少要消耗8M空间；
　　
　　考虑用nologging创建索引
　　
　　。对大表创建索引可以使用nologging来减少重做日志；
　　。节省重做日志文件的空间；
　　。缩短创建索引的时间；
　　。改善了并行创建大索引时的性能。
　　
怎样建立最佳索引
　　
　　明确地创建索引
　　Code:
create index index_name on table_name(field_name)
 　　tablespace tablespace_name
 　　pctfree 5
 　　initrans 2
 　　maxtrans 255
 　　storage
 　　(
 　　minextents 1
 　　maxextents 16382
 　　pctincrease 0
 　　);

　　
　　创建基于函数的索引
　　
　　。常用与UPPER、LOWER、TO_CHAR(date)等函数分类上，例：
　　Code:
create index idx_func on emp (UPPER(ename)) tablespace
       tablespace_name;
　　
　　创建位图索引
　　
　　。对基数较小，且基数相对稳定的列建立索引时，首先应该考虑位图索引，例：
　　Code:
create bitmap index idx_bitm on class (classno) tablespace
      tablespace_name;

　　
　　明确地创建唯一索引
　　
　　。可以用create unique index语句来创建唯一索引，例：
　　Code:
create unique index dept_unique_idx on dept(dept_no) tablespace
       idx_1;
　　
　　创建与约束相关的索引
　　
　　。可以用using index字句，为与unique和primary key约束相关的索引，例如：
　　Code:
alter table table_name
 　　add constraint PK_primary_keyname primary key (field_name)
 　　using index tablespace tablespace_name；

　　
如何创建局部分区索引
　　
　　。基础表必须是分区表；
　　。分区数量与基础表相同；
　　。每个索引分区的子分区数量与相应的基础表分区相同；
　　。基础表的子分区中的行的索引项，被存储在该索引的相应的子分区中,例如:
　　Code:
Create Index TG_CDR04_SERV_ID_IDX On TG_CDR04(SERV_ID)
 　　Pctfree 5
 　　Tablespace TBS_AK01_IDX
 　　Storage (
 　　MaxExtents 32768
 　　PctIncrease 0
 　　FreeLists 1
 　　FreeList Groups 1
 　　)
 　　local
 　　/

　　
如何创建范围分区的全局索引
　　
　　。基础表可以是全局表和分区表。
　　create index idx_start_date on tg_cdr01(start_date)
　　global partition by range(start_date)
　　(partition p01_idx vlaues less than (‘0106’)
　　partition p01_idx vlaues less than (‘0111’)
　　…
　　partition p01_idx vlaues less than (‘0401’ ))
　　/
　　
　　重建现存的索引
　　
　　重建现存的索引的当前时刻不会影响查询；
　　
　　重建索引可以删除额外的数据块；
　　
　　提高索引查询效率；
　　alter index idx_name rebuild nologging;
　　
　　对于分区索引：
　　alter index idx_name rebuild partition partiton_name nologging;
　　
　　要删除索引的原因
　　
　　。不再需要的索引；
　　。索引没有针对其相关的表所发布的查询提供所期望的性能改善；
　　。应用没有用该索引来查询数据；
　　。该索引无效，必须在重建之前删除该索引；
　　。该索引已经变的太碎了，必须在重建之前删除该索引；
　　。语句：drop index idx_name;drop index idx_name drop partition partition_name;
　　
建立索引的代价
　　
　　基础表维护时，系统要同时维护索引，不合理的索引将严重影响系统资源，主要表现在CPU和I/O上；
　　
　　插入、更新、删除数据产生大量db file sequential read锁；
　　
SQL优化器简介
　　
　　基于规则的优化器
　　
　　。总是使用索引
　　。总是从驱动表开始（from子句最右边的表）
　　。只有在不可避免的情况下，才使用全表扫描
　　。任何索引都可以
　　
　　基于成本的优化器
　　
　　。需要表、索引的统计资料
　　Analyze table customer compute statistics;
　　Analyze table customer estimate statistics sample 5000 rows;
　　。表中设置并行度、表分区
　　
　　优化器模式
　　
　　rule模式
　　
　　。总忽略CBO和统计信息而基于规则
　　choose模式
　　
　　。Oracle根据情况选择rule or first_rows or all_rows
　　first_rows 模式
　　
　　。基于成本，以最快的速度返回记录，会造成总体查询速度的下降或消耗更多的资源，倾向索引扫描，适合OLTP系统
　　all_rows模式
　　
　　。基于成本，确保总体查询时间最短，倾向并行全表扫描
　　
　　例如：
　　Select last_name from customer order by last_name;用first_rows时，迅速返回记录，但I/O量大，用all_rows时，返回记录慢，但使用资源少。
　　
调整SQL表访问
　　
　　全表扫描
　　
　　。返回记录：未排序表>40%，排序表>7%，建议采用并行机制来提高访问速度，DDS；
　　
　　索引访问
　　
　　。最常用的方法，包括索引唯一扫描和索引范围扫描，OLTP；
　　
　　快速完全索引扫描
　　
　　。访问索引中所有数据块，结果相当于全表扫描，可以用索引扫描代替全表扫描，例如：
　　
　　Select serv_id,count(* ) from tg_cdr01 group by serv_id;
　　
　　评估全表扫描的合法性
　　
　　如何实现并行扫描
　　
　　。永久并行化（不推荐）
　　alter table customer parallel degree 8;
　　
　　。单个查询并行化
　　select /*+ full(emp) parallel(emp,8)*/ * from emp;
　　
　　分区表效果明显
　　
　　优化SQL语句排序
　　
　　排序的操作：
　　
　　。order by 子句
　　。group by 子句
　　。select distinct子句
　　。创建索引时
　　。union或minus
　　。排序合并连接
　　
　　如何避免排序
　　
　　。添加索引
　　。在索引中使用distinct子句
　　。避免排序合并连接
　　
　　使用提示进行调整
　　
　　使用提示的原则
　　
　　。语法：/*+ hint */
　　。使用表别名:select /*+ index(e dept_idx)*/ * from emp e
　　。检验提示
　　
　　常用的提示
　　
　　。rule
　　。all_rows
　　。first_rows
　　。use_nl
　　。use_hash
　　。use_merge
　　。index
　　。index_asc
　　。no_index
　　。index_desc（常用于使用max内置函数）
　　。index_combine(强制使用位图索引)
　　。index_ffs（索引快速完全扫描）
　　。use_concat(将查询中所有or条件使用union all)
　　。parallel
　　。noparallel
　　。full
　　。ordered（基于成本）
　　
　　调整表连接
　　
　　表连接的类型
　　
　　。等连接
　　where 条件中用等式连接；
　　。外部连接（左、右连接）
　　
　　在where条件子句的等式谓词放置一个(+)来实现，例如：
　　select a.ename,b.comm from emp a,bonus b where a.ename=b.ename(+);
　　
　　该语句返回所有emp表的记录；
　　。自连接
　　　Select a.value total, B.value hard, (A.value - b.value) soft ,
　　Round((b.value/a.value)*100,1) perc
　　From v$sysstat a,v$sysstat b
　　Where a.statistic# = 179
　　and B.statistic# = 180;
　　
　　反连接
　　
　　反连接常用于not in or not exists中，是指在查询中找到的任何记录都不包含在结果集中的子查询；不建议使用not in or not exists;
　　
　　。半连接
　　
　　查询中使用exists，含义：即使在子查询中返回多条重复的记录，外部查询也只返回一条记录。
　　
　　嵌套循环连接
　　
　　。被连接表中存在索引的情况下使用；
　　。使用use_nl。
　　
　　hash连接
　　
　　。Hash连接将驱动表加载在内存中，并使用hash技术连接第二个表，提高等连接速度。
　　。适合于大表和小表连接；
　　。使用use_hash。
　　
　　排序合并连接
　　
　　。排序合并连接不使用索引
　　。使用原则：
　　
　　连接表子段中不存在可用索引；
　　
　　查询返回两个表中大部分的数据快；
　　
　　CBO认为全表扫描比索引扫描执行的更快。
　　
　　。使用use_merge
　　
　　使用临时/中间表
　　
　　多个大表关联时，可以分别把满足条件的结果集存放到中间表，然后用中间表关联；
　　
　　SQL子查询的调整
　　
　　关联与非关联子查询
　　
　　。关联：子查询的内部引用的是外部表，每行执行一次；
　　。非关联：子查询只执行一次，存放在内存中。
　　
　　调整not in 和not exists语句
　　
　　。可以使用外部连接优化not in子句，例如：
　　Code:
select ename from emp where dept_no not in
 　　(select dept_no from dept where dept_name =‘Math’);
　　
　　改为：
　　Code:
select ename from emp,dept
 　　where emp.dept_no=dept.dept_no
 　　and dept.dept_name is null;
　　
　　使用索引调整SQL
　　
Oracle 为什么不使用索引
　　
　　。检查被索引的列或组合索引的首列是否出现在PL/SQL语句的WHERE子句中，这是“执行计划”能用到相关索引的必要条件。
　　
　　。看采用了哪种类型的连接方式。ORACLE的共有Sort Merge Join（SMJ）、Hash Join（HJ）和Nested Loop Join（NL）。在两张表连接，且内表的目标列上建有索引时，只有Nested Loop才能有效地利用到该索引。SMJ即使相关列上建有索引，最多只能因索引的存在，避免数据排序过程。HJ由于须做HASH运算，索引的存在对数据查询速度几乎没有影响。
　　
　　。看连接顺序是否允许使用相关索引。假设表emp的deptno列上有索引，表dept的列deptno上无索引，WHERE语句有emp.deptno=dept.deptno条件。在做NL连接时，emp做为外表，先被访问，由于连接机制原因，外表的数据访问方式是全表扫描，emp.deptno上的索引显然是用不上，最多在其上做索引全扫描或索引快速全扫描。
　　
　　。是否用到系统数据字典表或视图。由于系统数据字典表都未被分析过，可能导致极差的“执行计划”。但是不要擅自对数据字典表做分析，否则可能导致死锁，或系统性能下降。
　　
　　。索引列是否函数的参数。如是，索引在查询时用不上。
　　
　　。是否存在潜在的数据类型转换。如将字符型数据与数值型数据比较，ORACLE会自动将字符型用to_number()函数进行转换，从而导致上一种现象的发生。
　　
　　。是否为表和相关的索引搜集足够的统计数据。对数据经常有增、删、改的表最好定期对表和索引进行分析，可用SQL语句“analyze table xxxx compute statistics for all indexes;”。ORACLE掌握了充分反映实际的统计数据，才有可能做出正确的选择。
　　
　　。索引列的选择性不高。 　　我们假设典型情况，有表emp，共有一百万行数据，但其中的emp.deptno列，数据只有4种不同的值，如10、20、30、40。虽然emp数据行有很多，ORACLE缺省认定表中列的值是在所有数据行均匀分布的，也就是说每种deptno值各有25万数据行与之对应。假设SQL搜索条件DEPTNO=10，利用deptno列上的索引进行数据搜索效率，往往不比全表扫描的高。
　　
　　。索引列值是否可为空（NULL）。如果索引列值可以是空值，在SQL语句中那些要返回NULL值的操作，将不会用到索引，如COUNT（*），而是用全表扫描。这是因为索引中存储值不能为全空。
　　
　　。看是否有用到并行查询（PQO）。并行查询将不会用到索引。
　　
　　。如果从以上几个方面都查不出原因的话，我们只好用采用在语句中加hint的方式强制ORACLE使用最优的“执行计划”。 　hint采用注释的方式，有行注释和段注释两种方式。 　如我们想要用到A表的IND_COL1索引的话，可采用以下方式： 　“SELECT /*+ INDEX（A IND_COL1）*/ * FROM A WHERE COL1 = XXX;"
　　
如何屏蔽索引
　　
　　语句的执行计划中有不良索引时，可以人为地屏蔽该索引，方法：
　　
　　。数值型：在索引字段上加0，例如
　　Code:
select * from emp where emp_no+0 = v_emp_no;

　　
　　。字符型：在索引字段上加‘’，例如
　　Code:
select * from tg_cdr01 where msisdn||’’=v_msisdn;

[1] 基本的索引概念
    查询DBA_INDEXES视图可得到表中所有索引的列表，注意只能通过USER_INDEXES的方法来检索模式(schema)的索引。访问USER_IND_COLUMNS视图可得到一个给定表中被索引的特定列。

[2] 组合索引
    当某个索引包含有多个已索引的列时，称这个索引为组合（concatented）索引。在 Oracle9i引入跳跃式扫描的索引访问方法之前，查询只能在有限条件下使用该索引。比如：表emp有一个组合索引键，该索引包含了empno、ename和deptno。在Oracle9i之前除非在where之句中对第一列（empno）指定一个值，否则就不能使用这个索引键进行一次范围扫描。
    特别注意：在Oracle9i之前，只有在使用到索引的前导索引时才可以使用组合索引！

[3] ORACLE ROWID
    通过每个行的ROWID，索引Oracle提供了访问单行数据的能力。ROWID其实就是直接指向单独行的线路图。如果想检查重复值或是其他对ROWID本身的引用，可以在任何表中使用和指定rowid列。   

[4] 限制索引
    限制索引是一些没有经验的开发人员经常犯的错误之一。在SQL中有很多陷阱会使一些索引无法使用。下面讨论一些常见的问题：
   
    4.1 使用不等于操作符（<>、!=）
        下面的查询即使在cust_rating列有一个索引，查询语句仍然执行一次全表扫描。
         select cust_Id,cust_name
         from   customers
         where  cust_rating <> 'aa';
         把上面的语句改成如下的查询语句，这样，在采用基于规则的优化器而不是基于代价的优化器（更智能）时，将会使用索引。
         select cust_Id,cust_name
         from   customers
         where  cust_rating < 'aa' or cust_rating > 'aa';
     特别注意：通过把不等于操作符改成OR条件，就可以使用索引，以避免全表扫描。
    
     4.2 使用IS NULL 或IS NOT NULL
         使用IS NULL 或IS NOT NULL同样会限制索引的使用。因为NULL值并没有被定义。在SQL语句中使用NULL会有很多的麻烦。因此建议开     发人员在建表时，把需要索引的列设成NOT NULL。如果被索引的列在某些行中存在NULL值，就不会使用这个索引（除非索引是一个位图索     引，关于位图索引在稍后在详细讨论）。

     4.3 使用函数
         如果不使用基于函数的索引，那么在SQL语句的WHERE子句中对存在索引的列使用函数时，会使优化器忽略掉这些索引。
         下面的查询不会使用索引（只要它不是基于函数的索引）
          select empno,ename,deptno
          from   emp
          where  trunc(hiredate)='01-MAY-81';
          把上面的语句改成下面的语句，这样就可以通过索引进行查找。
          select empno,ename,deptno
          from   emp
          where  hiredate<(to_date('01-MAY-81')+0.9999);

     4.4 比较不匹配的数据类型
         比较不匹配的数据类型也是比较难于发现的性能问题之一。
         注意下面查询的例子，account_number是一个VARCHAR2类型，在account_number字段上有索引。下面的语句将执行全表扫描。
         select bank_name,address,city,state,zip
         from   banks
         where  account_number = 990354;
         Oracle可以自动把where子句变成to_number(account_number)=990354，这样就限制了索引的使用,改成下面的查询就可以使用索引：
         select bank_name,address,city,state,zip
         from   banks
         where  account_number ='990354';
     特别注意：不匹配的数据类型之间比较会让Oracle自动限制索引的使用，即便对这个查询执行Explain Plan也不能让您明白为什么做了一               次“全表扫描”。

[5] 选择性
    使用USER_INDEXES视图，该视图中显示了一个distinct_keys列。比较一下唯一键的数量和表中的行数，就可以判断索引的选择性。选择性越高，索引返回的数据就越少。

[6] 群集因子(Clustering Factor)
    Clustering Factor位于USER_INDEXES视图中。该列反映了数据相对于已索引的列是否显得有序。如果Clustering Factor列的值接近于索引中的树叶块(leaf block)的数目，表中的数据就越有序。如果它的值接近于表中的行数，则表中的数据就不是很有序。
   

[7] 二元高度(Binary height)
    索引的二元高度对把ROWID返回给用户进程时所要求的I/O量起到关键作用。在对一个索引进行分析后，可以通过查询DBA_INDEXES的B-level列查看它的二元高度。二元高度主要随着表的大小以及被索引的列中值的范围的狭窄程度而变化。索引上如果有大量被删除的行，它的二元高度也会增加。更新索引列也类似于删除操作，因为它增加了已删除键的数目。重建索引可能会降低二元高度。

[8] 快速全局扫描
    在Oracle7.3后就可以使用快速全局扫描(Fast Full Scan)这个选项。这个选项允许Oracle执行一个全局索引扫描操作。快速全局扫描读取B-树索引上所有树叶块。初始化文件中的DB_FILE_MULTIBLOCK_READ_COUNT参数可以控制同时被读取的块的数目。

[9] 跳跃式扫描
    从Oracle9i开始，索引跳跃式扫描特性可以允许优化器使用组合索引，即便索引的前导列没有出现在WHERE子句中。索引跳跃式扫描比全索引扫描要快的多。下面的程序清单显示出性能的差别：
    create index skip1 on emp5(job,empno);
    index created.

    select count(*)
    from emp5
    where empno=7900;

    Elapsed:00:00:03.13

    Execution Plan
    0     SELECT STATEMENT Optimizer=CHOOSE(Cost=4 Card=1 Bytes=5)
    1  0    SORT(AGGREGATE)
    2  1      INDEX(FAST FULL SCAN) OF 'SKIP1'(NON-UNIQUE)

    Statistics

    6826 consistent gets
    6819 physical   reads

    select /*+ index(emp5 skip1)*/ count(*)
    from emp5
    where empno=7900;

    Elapsed:00:00:00.56

    Execution Plan
    0     SELECT STATEMENT Optimizer=CHOOSE(Cost=6 Card=1 Bytes=5)
    1  0    SORT(AGGREGATE)
    2  1      INDEX(SKIP SCAN) OF 'SKIP1'(NON-UNIQUE)

    Statistics

    21 consistent gets
    17 physical   reads

[10] 索引的类型
     B-树索引
     位图索引
     HASH索引
     索引编排表
     反转键索引
     基于函数的索引
     分区索引
     本地和全局索引