MERCADOS FINANCIEROS

miércoles, 18 de septiembre de 2013

How to convert non-partitioned table to partition table using re-definition

SQL> set pagesize 200SQL> set long 999999
SQL> set linesize 150
SQL> select dbms_metadata.get_ddl('TABLE','OUT_CDR','CR_2') from dual;

DBMS_METADATA.GET_DDL('TABLE','OUT_CDR','CR_2')
--------------------------------------------------------------------------------

CREATE TABLE "CR_2"."OUT_CDR" ( "ID" NUMBER(32,0) NOT NULL ENABLE, "CDATE" DATE NOT NULL ENABLE,
"DDATE" DATE NOT NULL ENABLE,
"ACCTSESSIONID" VARCHAR2(100),
"CALLINGNO" VARCHAR2(100),
"CALLEDNO" VARCHAR2(100) NOT NULL ENABLE,
"AREACODE" VARCHAR2(100),
"PREFIX" VARCHAR2(100),
"SESSIONTIME" NUMBER(32,0),
"BILLABLETIME" NUMBER(32,0),
"RATE" NUMBER(32,4),
"CALL_COST" NUMBER(32,4),
"CURRENTBILL" NUMBER(32,4),
"DISCONNECTCAUSE" VARCHAR2(50),
"SOURCEIP" VARCHAR2(100),
"DESTIP" VARCHAR2(100),
"BILLABLE" NUMBER(32,0) NOT NULL ENABLE,
"LESS" NUMBER(32,0) NOT NULL ENABLE,
"ACCID" NUMBER(32,0),
"IN_DDATE" DATE,
"IN_PREFIX" VARCHAR2(100),
"IN_SESSIONTIME" NUMBER(32,0),
"IN_BILLABLETIME" NUMBER(32,0),
"IN_RATE" NUMBER(32,4),
"IN_CALL_COST" NUMBER(32,4),
"IN_MONEYLEFT" NUMBER(32,4),
"IN_DISCONNECTCAUSE" VARCHAR2(50),
"IN_BILLABLE" NUMBER(32,0),
"IN_LESS" NUMBER(32,0), "SWITCH_ID
" NUMBER(32,0) NOT NULL ENABLE,
"USER_ID" NUMBER(32,0) NOT NULL ENABLE,
"IN_USER_ID" NUMBER(32,0),
"PROCESSED" NUMBER(1,0),
CONSTRAINT "OUT_CDR_PK" PRIMARY KEY ("ID")USING INDEX PCTFREE 10 INITRANS 2 MAXTRANS 255 COMPUTE STATISTICSSTORAGE(INITIAL 168820736 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1 BUFFER_POOL DEFAULT)TABLESPACE "CDR_INDX_SPC" ENABLE, CONSTRAINT "OUT_CDR_UQ" UNIQUE ("CDATE", "CALLEDNO", "USER_ID")USING INDEX PCTFREE 10 INITRANS 2 MAXTRANS 255 COMPUTE STATISTICSSTORAGE(INITIAL 522190848 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1 BUFFER_POOL DEFAULT)TABLESPACE "CDR_INDX_SPC" ENABLE, CONSTRAINT "OUT_CDR_UQ_2" UNIQUE ("DDATE", "CALLEDNO", "USER_ID")USING INDEX PCTFREE 10 INITRANS 2 MAXTRANS 255 COMPUTE STATISTICSSTORAGE(INITIAL 521142272 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1 BUFFER_POOL DEFAULT)TABLESPACE "CDR_INDX_SPC" ENABLE ) PCTFREE 10 PCTUSED 40 INITRANS 1 MAXTRANS 255 NOCOMPRESS LOGGINGSTORAGE(INITIAL 2013265920 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1 BUFFER_POOL DEFAULT)TABLESPACE "OUT_CDR_NEW_SPC"


Step 02: Let's determine if the table OUT_CDR can be redefined online.
SQL> exec dbms_redefinition.can_redef_table('CR_2', 'OUT_CDR');
PL/SQL procedure successfully completed.

Step 03: Create a interim table which holds the same structure as the original table except constraints, indexes, triggers but add the partitioning attribute.I named the interim table as OUT_CDR_. Later we may drop it.

SQL> CREATE TABLE "CR_
2"."OUT_CDR_"2 ( "ID" NUMBER(32,0),
3 "CDATE" DATE ,
4 "DDATE" DATE ,
5 "ACCTSESSIONID" VARCHAR2(100),
6 "CALLINGNO" VARCHAR2(100),
7 "CALLEDNO" VARCHAR2(100) ,
8 "AREACODE" VARCHAR2(100),
9 "PREFIX" VARCHAR2(100),
10 "SESSIONTIME" NUMBER(32,0),
11 "BILLABLETIME" NUMBER(32,0),
12 "RATE" NUMBER(32,4),
13 "CALL_COST" NUMBER(32,4),
14 "CURRENTBILL" NUMBER(32,4),
15 "DISCONNECTCAUSE" VARCHAR2(50),
16 "SOURCEIP" VARCHAR2(100),
17 "DESTIP" VARCHAR2(100),
18 "BILLABLE" NUMBER(32,0) ,
19 "LESS" NUMBER(32,0) ,
20 "ACCID" NUMBER(32,0),
21 "IN_DDATE" DATE,
22 "IN_PREFIX" VARCHAR2(100),
23 "IN_SESSIONTIME" NUMBER(32,0),
24 "IN_BILLABLETIME" NUMBER(32,0),
25 "IN_RATE" NUMBER(32,4),
26 "IN_CALL_COST" NUMBER(32,4),
27 "IN_MONEYLEFT" NUMBER(32,4),
28 "IN_DISCONNECTCAUSE" VARCHAR2(50),
29 "IN_BILLABLE" NUMBER(32,0),
30 "IN_LESS" NUMBER(32,0),
31 "SWITCH_ID" NUMBER(32,0) ,
32 "USER_ID" NUMBER(32,0) ,
33 "IN_USER_ID" NUMBER(32,0),
34 "PROCESSED" NUMBER(1,0)
35 ) TABLESPACE "OUT_CDR_NEW_SPC"36 Partition by range(cdate)37 (38 partition P08152008 values less than (to_date('15-AUG-2008','DD-MON-YYYY')),39 partition P09012008 values less than (to_date('01-SEP-2008','DD-MON-YYYY')),40 partition P09152008 values less than (to_date('15-SEP-2008','DD-MON-YYYY')),41 partition P10012008 values less than (to_date('01-OCT-2008','DD-MON-YYYY')),42 partition P10152008 values less than (to_date('15-OCT-2008','DD-MON-YYYY')),43 partition P11012008 values less than (to_date('01-NOV-2008','DD-MON-YYYY')),44 partition P11152008 values less than (to_date('15-NOV-2008','DD-MON-YYYY')),45 partition P12012008 values less than (to_date('01-DEC-2008','DD-MON-YYYY')),46 partition P12152008 values less than (to_date('15-DEC-2008','DD-MON-YYYY')),47 partition P01012009 values less than (to_date('01-JAN-2009','DD-MON-YYYY')),48 partition P01152009 values less than (to_date('15-JAN-2009','DD-MON-YYYY')),49 partition P02012009 values less than (to_date('01-FEB-2009','DD-MON-YYYY')),50 partition PMAX values less than (maxvalue));
Table created.

Step 04: Initiates the redefinition process by calling dbms_redefinition.start_redef_table procedure.
SQL> exec dbms_redefinition.start_redef_table('CR_2', 'OUT_CDR', 'OUT_CDR_');
PL/SQL procedure successfully completed.


Step 05: Copies the dependent objects of the original table onto the interim table. The COPY_TABLE_DEPENDENTS Procedure clones the dependent objects of the table being redefined onto the interim table and registers the dependent objects. But this procedure does not clone the already registered dependent objects.In fact COPY_TABLE_DEPENDENTS Procedure is used to clone the dependent objects like grants, triggers, constraints and privileges from the table being redefined to the interim table which in facr represents the post-redefinition table.

SQL> declare
2 error_count pls_integer := 0;
3 BEGIN
4 dbms_redefinition.copy_table_dependents('CR_2', 'OUT_CDR', 'OUT_CDR_',1, true, true, true, false,error_count);
5 dbms_output.put_line('errors := ' to_char(error_count));
6 END;
7 /PL/SQL procedure successfully completed.



Step 06: Completes the redefinition process by calling FINISH_REDEF_TABLE Procedure.
SQL> exec dbms_redefinition.finish_redef_table('CR_2', 'OUT_CDR', 'OUT_CDR_');
PL/SQL procedure successfully completed.


Step 07: Check the partitioning validation by,
SQL> Select partition_name, high_value from user_tab_partitions where table_name='OUT_CDR';PARTITION_NAME HIGH_VALUE------------------------------ ---------------------------------------------------------------------------------------------------P01012009 TO_DATE(' 2009-01-01 00:00:00', 'SYYYY-MM-DD HH24:MI:SS', 'NLS_CALENDAR=GREGORIAP01152009 TO_DATE(' 2009-01-15 00:00:00', 'SYYYY-MM-DD HH24:MI:SS', 'NLS_CALENDAR=GREGORIAP02012009 TO_DATE(' 2009-02-01 00:00:00', 'SYYYY-MM-DD HH24:MI:SS', 'NLS_CALENDAR=GREGORIAP08152008 TO_DATE(' 2008-08-15 00:00:00', 'SYYYY-MM-DD HH24:MI:SS', 'NLS_CALENDAR=GREGORIAP09012008 TO_DATE(' 2008-09-01 00:00:00', 'SYYYY-MM-DD HH24:MI:SS', 'NLS_CALENDAR=GREGORIAP09152008 TO_DATE(' 2008-09-15 00:00:00', 'SYYYY-MM-DD HH24:MI:SS', 'NLS_CALENDAR=GREGORIAP10012008 TO_DATE(' 2008-10-01 00:00:00', 'SYYYY-MM-DD HH24:MI:SS', 'NLS_CALENDAR=GREGORIAP10152008 TO_DATE(' 2008-10-15 00:00:00', 'SYYYY-MM-DD HH24:MI:SS', 'NLS_CALENDAR=GREGORIAP11012008 TO_DATE(' 2008-11-01 00:00:00', 'SYYYY-MM-DD HH24:MI:SS', 'NLS_CALENDAR=GREGORIAP11152008 TO_DATE(' 2008-11-15 00:00:00', 'SYYYY-MM-DD HH24:MI:SS', 'NLS_CALENDAR=GREGORIAP12012008 TO_DATE(' 2008-12-01 00:00:00', 'SYYYY-MM-DD HH24:MI:SS', 'NLS_CALENDAR=GREGORIAP12152008 TO_DATE(' 2008-12-15 00:00:00', 'SYYYY-MM-DD HH24:MI:SS', 'NLS_CALENDAR=GREGORIAPMAX MAXVALUE13 rows selected.Check index status by,SQL> select index_name , status from user_indexes where table_name='OUT_CDR';INDEX_NAME STATUS------------------------------ --------OUT_CDR_PK VALIDOUT_CDR_UQ VALIDOUT_CDR_UQ_2 VALIDStep 08: Drop the interim table OUT_CDR_.SQL> DROP TABLE OUT_CDR_;Table dropped.

jueves, 22 de agosto de 2013

EXAMPLE BACKUP AS COPY



[oracle@localhost labs2]$ rman target /
Recovery Manager: Release 11.2.0.1.0 - Production on Thu Aug 22 17:37:16 2013
Copyright (c) 1982, 2009, Oracle and/or its affiliates.  All rights reserved.
connected to target database: ACME (DBID=2003395651)
RMAN> backup incremental level 1 for recover of copy with tag 'backup_incr' database;
Starting backup at 2013-08-22:17:38:04
using target database control file instead of recovery catalog
allocated channel: ORA_DISK_1
channel ORA_DISK_1: SID=37 device type=DISK
no parent backup or copy of datafile 1 found
no parent backup or copy of datafile 2 found
no parent backup or copy of datafile 5 found
no parent backup or copy of datafile 3 found
no parent backup or copy of datafile 4 found
channel ORA_DISK_1: starting datafile copy
input datafile file number=00001 name=/u01/app/oracle/oradata/acme/system01.dbf
output file name=/u01/app/oracle/flash_recovery_area/ACME/datafile/o1_mf_system_91f4phck_.dbf tag=BACKUP_INCR RECID=2 STAMP=824146789
channel ORA_DISK_1: datafile copy complete, elapsed time: 00:01:45
channel ORA_DISK_1: starting datafile copy
input datafile file number=00002 name=/u01/app/oracle/oradata/acme/sysaux01.dbf
output file name=/u01/app/oracle/flash_recovery_area/ACME/datafile/o1_mf_sysaux_91f4svo0_.dbf tag=BACKUP_INCR RECID=3 STAMP=824146910
channel ORA_DISK_1: datafile copy complete, elapsed time: 00:02:07
channel ORA_DISK_1: starting datafile copy
input datafile file number=00005 name=/u01/app/oracle/oradata/acme/example01.dbf
output file name=/u01/app/oracle/flash_recovery_area/ACME/datafile/o1_mf_example_91f4xrrq_.dbf tag=BACKUP_INCR RECID=4 STAMP=824146928
channel ORA_DISK_1: datafile copy complete, elapsed time: 00:00:15
channel ORA_DISK_1: starting datafile copy
input datafile file number=00003 name=/u01/app/oracle/oradata/acme/undotbs01.dbf
output file name=/u01/app/oracle/flash_recovery_area/ACME/datafile/o1_mf_undotbs1_91f4y845_.dbf tag=BACKUP_INCR RECID=5 STAMP=824146942
channel ORA_DISK_1: datafile copy complete, elapsed time: 00:00:08
channel ORA_DISK_1: starting datafile copy
input datafile file number=00004 name=/u01/app/oracle/oradata/acme/users01.dbf
output file name=/u01/app/oracle/flash_recovery_area/ACME/datafile/o1_mf_users_91f4yjjo_.dbf tag=BACKUP_INCR RECID=6 STAMP=824146945
channel ORA_DISK_1: datafile copy complete, elapsed time: 00:00:01
Finished backup at 2013-08-22:17:42:25
Starting Control File and SPFILE Autobackup at 2013-08-22:17:42:26
piece handle=/u01/app/oracle/flash_recovery_area/ACME/autobackup/2013_08_22/o1_mf_s_824146946_91f4yny0_.bkp comment=NONE
Finished Control File and SPFILE Autobackup at 2013-08-22:17:42:33
RMAN> list copy of tablespace example;
List of Datafile Copies
=======================
Key     File S Completion Time     Ckp SCN    Ckp Time          
------- ---- - ------------------- ---------- -------------------
4       5    A 2013-08-22:17:42:08 2084754    2013-08-22:17:42:00
        Name: /u01/app/oracle/flash_recovery_area/ACME/datafile/o1_mf_example_91f4xrrq_.dbf
        Tag: BACKUP_INCR

RMAN> backup incremental level 1 for recover of copy with tag 'backup_incr' database;
Starting backup at 2013-08-22:18:04:22
using channel ORA_DISK_1
channel ORA_DISK_1: starting incremental level 1 datafile backup set
channel ORA_DISK_1: specifying datafile(s) in backup set
input datafile file number=00001 name=/u01/app/oracle/oradata/acme/system01.dbf
input datafile file number=00002 name=/u01/app/oracle/oradata/acme/sysaux01.dbf
input datafile file number=00005 name=/u01/app/oracle/oradata/acme/example01.dbf
input datafile file number=00003 name=/u01/app/oracle/oradata/acme/undotbs01.dbf
input datafile file number=00004 name=/u01/app/oracle/oradata/acme/users01.dbf
channel ORA_DISK_1: starting piece 1 at 2013-08-22:18:04:23
channel ORA_DISK_1: finished piece 1 at 2013-08-22:18:05:48
piece handle=/u01/app/oracle/flash_recovery_area/ACME/backupset/2013_08_22/o1_mf_nnnd1_BACKUP_INCR_91f67v6c_.bkp tag=BACKUP_INCR comment=NONE
channel ORA_DISK_1: backup set complete, elapsed time: 00:01:25
Finished backup at 2013-08-22:18:05:48
Starting Control File and SPFILE Autobackup at 2013-08-22:18:05:48
piece handle=/u01/app/oracle/flash_recovery_area/ACME/autobackup/2013_08_22/o1_mf_s_824148348_91f6bfxw_.bkp comment=NONE
Finished Control File and SPFILE Autobackup at 2013-08-22:18:05:51
RMAN> list copy of tablespace example;
List of Datafile Copies
=======================
Key     File S Completion Time     Ckp SCN    Ckp Time          
------- ---- - ------------------- ---------- -------------------
4       5    A 2013-08-22:17:42:08 2084754    2013-08-22:17:42:00
        Name: /u01/app/oracle/flash_recovery_area/ACME/datafile/o1_mf_example_91f4xrrq_.dbf
        Tag: BACKUP_INCR

RMAN> backup incremental level 1 for recover of copy with tag 'backup_incr' database;
Starting backup at 2013-08-22:18:19:54
using channel ORA_DISK_1
channel ORA_DISK_1: starting incremental level 1 datafile backup set
channel ORA_DISK_1: specifying datafile(s) in backup set
input datafile file number=00001 name=/u01/app/oracle/oradata/acme/system01.dbf
input datafile file number=00002 name=/u01/app/oracle/oradata/acme/sysaux01.dbf
input datafile file number=00005 name=/u01/app/oracle/oradata/acme/example01.dbf
input datafile file number=00003 name=/u01/app/oracle/oradata/acme/undotbs01.dbf
input datafile file number=00004 name=/u01/app/oracle/oradata/acme/users01.dbf
channel ORA_DISK_1: starting piece 1 at 2013-08-22:18:19:55
channel ORA_DISK_1: finished piece 1 at 2013-08-22:18:21:00
piece handle=/u01/app/oracle/flash_recovery_area/ACME/backupset/2013_08_22/o1_mf_nnnd1_BACKUP_INCR_91f74vxw_.bkp tag=BACKUP_INCR comment=NONE
channel ORA_DISK_1: backup set complete, elapsed time: 00:01:05
Finished backup at 2013-08-22:18:21:01
Starting Control File and SPFILE Autobackup at 2013-08-22:18:21:01
piece handle=/u01/app/oracle/flash_recovery_area/ACME/autobackup/2013_08_22/o1_mf_s_824149261_91f76z85_.bkp comment=NONE
Finished Control File and SPFILE Autobackup at 2013-08-22:18:21:04
RMAN> list copy of tablespace example;
List of Datafile Copies
=======================
Key     File S Completion Time     Ckp SCN    Ckp Time          
------- ---- - ------------------- ---------- -------------------
4       5    A 2013-08-22:17:42:08 2084754    2013-08-22:17:42:00
        Name: /u01/app/oracle/flash_recovery_area/ACME/datafile/o1_mf_example_91f4xrrq_.dbf
        Tag: BACKUP_INCR

RMAN> recover copy of tablespace example with tag 'backup_incr';        
Starting recover at 2013-08-22:18:31:13
using channel ORA_DISK_1
allocated channel: ORA_SBT_TAPE_1
channel ORA_SBT_TAPE_1: SID=43 device type=SBT_TAPE
channel ORA_SBT_TAPE_1: WARNING: Oracle Test Disk API
channel ORA_DISK_1: starting incremental datafile backup set restore
channel ORA_DISK_1: specifying datafile copies to recover
recovering datafile copy file number=00005 name=/u01/app/oracle/flash_recovery_area/ACME/datafile/o1_mf_example_91f4xrrq_.dbf
channel ORA_DISK_1: reading from backup piece /u01/app/oracle/flash_recovery_area/ACME/backupset/2013_08_22/o1_mf_nnnd1_BACKUP_INCR_91f67v6c_.bkp
channel ORA_DISK_1: piece handle=/u01/app/oracle/flash_recovery_area/ACME/backupset/2013_08_22/o1_mf_nnnd1_BACKUP_INCR_91f67v6c_.bkp tag=BACKUP_INCR
channel ORA_DISK_1: restored backup piece 1
channel ORA_DISK_1: restore complete, elapsed time: 00:00:01
channel ORA_DISK_1: starting incremental datafile backup set restore
channel ORA_DISK_1: specifying datafile copies to recover
recovering datafile copy file number=00005 name=/u01/app/oracle/flash_recovery_area/ACME/datafile/o1_mf_example_91f4xrrq_.dbf
channel ORA_DISK_1: reading from backup piece /u01/app/oracle/flash_recovery_area/ACME/backupset/2013_08_22/o1_mf_nnnd1_BACKUP_INCR_91f74vxw_.bkp
channel ORA_DISK_1: piece handle=/u01/app/oracle/flash_recovery_area/ACME/backupset/2013_08_22/o1_mf_nnnd1_BACKUP_INCR_91f74vxw_.bkp tag=BACKUP_INCR
channel ORA_DISK_1: restored backup piece 1
channel ORA_DISK_1: restore complete, elapsed time: 00:00:01
Finished recover at 2013-08-22:18:31:19
Starting Control File and SPFILE Autobackup at 2013-08-22:18:31:19
piece handle=/u01/app/oracle/flash_recovery_area/ACME/autobackup/2013_08_22/o1_mf_s_824149879_91f7t7yj_.bkp comment=NONE
Finished Control File and SPFILE Autobackup at 2013-08-22:18:31:22
RMAN> list copy of tablespace example;
List of Datafile Copies
=======================
Key     File S Completion Time     Ckp SCN    Ckp Time          
------- ---- - ------------------- ---------- -------------------
8       5    A 2013-08-22:18:31:18 2087900    2013-08-22:18:19:55
        Name: /u01/app/oracle/flash_recovery_area/ACME/datafile/o1_mf_example_91f4xrrq_.dbf
        Tag: BACKUP_INCR

RMAN>

viernes, 16 de agosto de 2013

PASSWORD ORACLE

SYS.USER$ view, what do the CTIME, PTIME, and LTIME

Oracle y VMware: ¿amigos o enemigos?

 

Me encontré este Articulo y me pareció interesante

http://blog.avanttic.com/2010/12/01/oracle-y-vmware-%c2%bfamigos-o-enemigos/#more-2543

Oracle y VMware: ¿amigos o enemigos?

En esta entrada de blog intentaré aclarar el estado en que se encuentra la combinación de Oracle y VMware a fecha de hoy y describir lo que personalmente creo será el futuro de esta combinación de tecnologías.
VMWARE_vs_ORACLE
En el primer punto, que dividiré en “estado de soporte” de la combinación y “requerimientos de licenciado”, intentaré ser lo más simple y neutral posible, basándome únicamente en lo que ambas empresas (Oracle y VMware) han publicado al respecto.
El segundo punto será justo lo contrario, fruto de opiniones tanto personales como recogidas por la red… por lo que será totalmente discutible.
Nota: Téngase en cuenta que  toda la información aquí presentada ha sido recopilada con fecha 22-11-2010, y que en el momento de la lectura de este post se podrían haber producido cambios de política o estrategia por parte de Oracle.

Soporte Oracle de productos ejecutados sobre VMware

A la pregunta: ¿cuál es el estado del soporte del software Oracle instalado sobre la plataforma de virtualización de VMware?
La respuesta la encontramos en la nota de Oracle:
Support Position for Oracle Products Running on VMWare Virtualized Environments [ID 249212.1]
que básicamente dice lo siguiente:
  • Oracle no certifica ninguno de sus productos sobre la plataforma de virtualización VMware.
  • En caso de encontrar un problema ya tipificado como tal, se facilitaran los parches y posibles mecanismos alternativos de solución ya existentes.
  • Se investigará (y creará un parche si fuese necesario) sólo si el cliente demuestra que se reproduce la incidencia sobre máquinas físicas (entornos sin virtualizar).
  • No se dará soporte en ningún caso para instalaciones de Oracle RAC versión 11gR1 o anteriores. Para instalaciones Oracle RAC 11gR2 o superiores se siguen las mismas normas que para el resto de productos (puntos anteriores).
Por tanto, si no se cumplen las anteriores condiciones no se considerará problema de Oracle y deberá ser VMware quien dé soporte a la incidencia.
La mencionada nota fue actualizada en día 8-11-2010, provocando un gran revuelo en el mundo VMware. La causa de tal revuelo fue que apareció el soporte para Oracle RAC a partir de la versión 11gR2 (previamente no se soportaba RAC en ningún caso).
Resumiendo, si opto por integrar los productos Oracle en mi plataforma de virtualización VMware, ¿me dará Oracle soporte?
>>> Si el problema por el que se pide soporte ya ha sido reportado, Soporte Oracle nos indicará los parches y/o workarrounds disponibles. Lo que no hará será pedir a los desarrolladores que investiguen o creen un parche si no se dispone previamente de éste, a no ser que demostremos que la incidencia se reproduce en un entorno no virtualizado.
En el siguiente link tenéis la nota original de Oracle Support a fecha 08-11-2010 (es de libre distribución):
http://www.avanttic.com/pdf/Blog/Support_Position_Oracle_VMWare.pdf

Licenciamiento de Oracle sobre VMware

A la pregunta: ¿en caso de disponer de productos Oracle sobre VMWare, cómo los debo licenciar?
Podemos contestar que, si bien VMware permite asignar a una determinada maquina virtual sólo una parte de las CPU’s de la máquina física en la que se ejecuta, Oracle no reconoce ese sistema como válido para particionar a nivel de servidor.
Soft partitioning is not permitted as a means to determine or limit the number of software licenses required for any given server.
Existen sistemas de particionado de servidores que Oracle considera como hard partitions, entre ellos algunos de Sun, HP o IBM. Estos sistemas permiten crear “particiones virtuales” con un subconjunto de CPU’s, memoria y disco de una máquina física. En estos casos Oracle requiere licenciar sólo el subconjunto de CPU’s de la partición.
VMware a partir de la versión 4.1 dispone de un sistema llamado DRS Virtual Machine Host Affinity, que permite “confinar” una maquina virtual en un subconjunto de máquinas físicas del cluster. Hasta el momento Oracle no lo ha considerado un sistema de hard partition, y por tanto seguimos con las condiciones de licenciado anteriormente mencionadas.
Para más detalles de qué Oracle considera hard partitioning y qué soft partitioning, podéis consultar el documento al respecto disponible en la web de Oracle:
http://www.oracle.com/us/corporate/pricing/partitioning-070609.pdf

Y personalmente pienso que…

El software Oracle sobre entornos virtualizados simplemente irá en aumento. Cada vez son más los departamentos de informática que deciden pasar sus entornos físicos a virtuales por las ventajas que estos aportan, y los productos Oracle no pueden esquivar esta tendencia. De hecho Oracle ya dispone de su propio entorno de virtualitzación (Oracle VM) y da soporte a sus productos sobre él.
El principal problema acostumbra a ser más el licenciado que el soporte, básicamente por el sobrecoste que representa el tener que licenciar todas las CPU’s físicas. A nivel de soporte, y si se usan versiones de productos con un cierto recorrido, es baja la posibilidad de tener incidentes que no estén ya “reportados”.
Existen multitud de empresas que han pasado sus entornos productivos Oracle a VMware, y VMware está muy interesada en ello, de manera que no escatima esfuerzos para que los productos Oracle funcionen correctamente bajo su entorno de virtualización:
http://www.vmware.com/solutions/partners/alliances/oracle-database-customers.html
Para disminuir en parte el problema con el licenciado algunas empresas crean múltiples clusters VMware en lugar de uno solo. El primero con pocas maquinas físicas (2 por ejemplo) para las maquinas virtuales con productos Oracle, y el segundo con el resto de servidores físicos para el resto de maquinas virtuales.
En nuestro caso particular trabajamos con varios clientes que han optado por esta solución con resultados satisfactorios en la mayoría de los casos, tanto para entornos de desarrollo como para productivos.
Hacer notar que, de momento, no todas las opciones que nos aporta VMware son susceptibles de ser aplicadas a servidores con productos Oracle:
  • Los “snapshots en caliente” de máquinas con BBDD son motivo de controversia pues la BBDD deberá realizar una recuperación cuando arranquemos desde uno de ellos. ¿Se pueden por tanto considerar un sistema de copias valido? En mi opinión no, y deberíamos continuar realizando las copias a nivel de Oracle (con RMAN por ejemplo) y no optar por ellos como sistema de backup.
  • Existen casos reportados de problemas con VMotion y Oracle RAC por lo que, personalmente, tampoco recomiendo su uso. No obstante también podemos encontrar casos en que funciona sin problemas. En consecuencia, usarlos o no es una elección a realizar por el cliente que use Oracle RAC sobre VMware.
Por otra parte la virtualización nos aporta muchas ventajas:
  • Alta disponibilidad:  En caso de problemas en el servidor físico en que esté ubicada la maquina virtual, la podemos arrancar en otro nodo del cluster (de manera manual o automática).
  • Facilidad y seguridad ante cambios: Podemos realizar un snapshot con la maquina parada y actualizar el S.O. o el propio software Oracle con la tranquilidad de que si algo malo pasa, todo podrá volver a quedar “como antes” sin prácticamente esfuerzo.
  • Crear entornos para desarrollo o para test de nuevas aplicaciones, con gran facilidad, partiendo de copias en frio de las maquinas virtuales productivas.
  • Y, principalmente, integrar los servidores Oracle con el resto de nuestros sistemas virtualizados, evitando que sean “sistemas a parte”.
Llegados a este punto lo normal sería seguir con dudas sobre si implementar Oracle sobre VMware o no. Es una decisión a tomar por cada departamento de IT y no es fácil, pero la tendencia parece apuntar a que la virtualización seguirá ganando terreno, incluso en los entornos Oracle.

lunes, 12 de agosto de 2013

UTL_MAIL

ORA-06502 ORA-24247 calling UTL_MAIL from Oracle 11gR2

Environment: Oracle database 11.2.0.3.0, Oracle Linux 6.2
Sending e-mails from within the Oracle database using the UTL_MAIL PL/SQL package used to be quite easy in Oracle 10g. However, in Oracle 11gR2, things have changed.
Suppose that you created the following wrapper procedure in PL/SQL:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
CREATE OR REPLACE PROCEDURE UTILS.SEND_MAIL (
   p_sender       IN   VARCHAR2,
   p_recipients   IN   VARCHAR2,
   p_cc           IN   VARCHAR2 DEFAULT NULL,
   p_bcc          IN   VARCHAR2 DEFAULT NULL,
   p_subject      IN   VARCHAR2,
   p_message      IN   VARCHAR2,
   p_mime_type    IN   VARCHAR2 DEFAULT 'text/plain; charset=us-ascii'
)
IS
 BEGIN
   UTL_MAIL.SEND (sender          => p_sender,
                  recipients      => p_recipients,
                  cc              => p_cc,
                  bcc             => p_bcc,
                  subject         => p_subject,
                  message         => p_message,
                  mime_type       => p_mime_type
                 );
EXCEPTION
   WHEN OTHERS
   THEN
      RAISE;
END send_mail;
/

To get this procedure working on Oracle 11g, there are several steps you need to take.
First, you need to actually install the UTL_MAIL package. It’s not installed by default on 11g:
 
1
2
3
4
5
6
7
$ sqlplus /nolog
SQL*Plus: Release 11.2.0.3.0 Production on Fri Apr 27 14:49:33 2012
SQL> connect / as sysdba
Connected.
SQL> @?/rdbms/admin/utlmail.sql
SQL> @?/rdbms/admin/prvtmail.plb
SQL> grant execute on utl_mail to public;

Next, you need to add the address and port of the e-mail server to the “smtp_out_server” initialization parameter. If you do not do this, you will receive a “ORA-06502: PL/SQL: numeric or value error” error when you try to use the UTL_MAIL package.
Execute the following with user SYS as SYSDBA:
 
1
SQL> alter system set smtp_out_server = 'mymailserver@mydomain.com:25' scope=both;

Finally, you need to create an Access Control List (ACL) for your e-mail server and grant the necessary users access to this ACL. Without an ACL, you will receive the following error: “ORA-24247: network access denied by access control list (ACL)“.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
BEGIN
   DBMS_NETWORK_ACL_ADMIN.CREATE_ACL (
    acl          => 'mail_access.xml',
    description  => 'Permissions to access e-mail server.',
    principal    => 'PUBLIC',
    is_grant     => TRUE,
    privilege    => 'connect');
   COMMIT;
END;
 
BEGIN
   DBMS_NETWORK_ACL_ADMIN.ASSIGN_ACL (
    acl          => 'mail_access.xml',
    host         => 'mymailserver@mydomain.com',
    lower_port   => 25,
    upper_port   => 25
    );
   COMMIT;
END;
After these steps, you should be able to successfully send e-mails from within the database:

begin
utils.send_mail(
p_sender => ‘ora11gtest@mydomain.com’,
p_recipients => ‘matthiash@mydomain.com’,
p_subject => ‘This is the subject line!’,
p_message => ‘Hello World!’);
end;
*Action:
anonymous block completed
Matthias

ORA-24247 during LDAP authentication from APEX 4.1.1 on Oracle 11gR2

Environment: APEX 4.1.1, Oracle database 11.2.0.3.0, Oracle Linux 6.2
In Oracle database 11g, access to external network resources has been more restricted than in previous versions. Access to network resources is now controlled through ACL’s (Access Control Lists). This can lead to various problems when you migrate APEX applications from a server running Oracle 10g to one running 11g.For example, if you wrote your own LDAP authentication functions using the built-in DBMS_LDAP package, you will receive the following error message when you try to authenticate to LDAP:
ORA-24247: network access denied by access control list (ACL)
This is because the owner of the authentication function lacks access to the required network resources. You can easily test this with the following piece of PL/SQL code:
1
2
3
4
5
declare
l_session dbms_ldap.session;
begin
l_session := dbms_ldap.init('windowsdc.mydomain.com',389);
end;
In this case, “windowsdc.mydomain.com” is a Windows LDAP server running Microsoft’s Active Directory.
To grant access to a specific network resource in 11g, you first need to create a ACL (Access Control List). I executed this with SYS as SYSDBA:
1
2
3
4
5
6
7
8
9
BEGIN
   DBMS_NETWORK_ACL_ADMIN.CREATE_ACL (
    acl          => 'ldap_access.xml',
    description  => 'Permissions to access LDAP servers.',
    principal    => 'MATTHIASH',
    is_grant     => TRUE,
    privilege    => 'connect');
   COMMIT;
END;
In this example, “ldap_access.xml” is the name of my ACL, and “MATTHIASH” is the name of the user account which needs access to the LDAP server. This account owns my custom LDAP authentication function.
Next, you need to add the LDAP server to the ACL we just created (don’t forget to COMMIT):
1
2
3
4
5
6
7
8
9
BEGIN
   DBMS_NETWORK_ACL_ADMIN.ASSIGN_ACL (
    acl          => 'ldap_access.xml',
    host         => 'windowsdc.mydomain.com',
    lower_port   => 389,
    upper_port   => 389
    );
   COMMIT;
END;
You can check the ACL using the following queries:

SELECT * FROM DBA_NETWORK_ACLS;
SELECT * FROM DBA_NETWORK_ACL_PRIVILEGES;

jueves, 21 de marzo de 2013

Oracle 11gr2 : Problemas con ASM y Cluster Synchronization Service

Seteamos nuestro ambiente para la instancia ASM
export ORACLE_HOME=/u01/app/oracle/product/11.2.0/grid
export ORACLE_BASE=/u01/app/oracle
export ORACLE_SID=+ASM
export PATH=$PATH:/u01/app/oracle/product/11.2.0/grid/bin


Y procedemos a levantar la instancia ASM

[oracle@oracle11g ~]$ sqlplus /nolog
SQL*Plus: Release 11.2.0.1.0 Production on Fri Apr 16 05:37:25 2010
Copyright (c) 1982, 2009, Oracle. All rights reserved.
SQL> conn / as sysdba
Connected to an idle instance.
SQL> startup
ORA-01078: failure in processing system parameters
ORA-29701: unable to connect to Cluster Synchronization Service
SQL>




¿Cómo solucionamos este inconveniente?
Pues he acá la explicación


El demonio del Cluster Synchronization Service (cssd daemon) no queda online después del reboteo y como la instancia ASM , necesita ese demonio, pues por eso ASM no levanta
La forma de chequearlo


[oracle@oracle11g ~]$ crsctl check cssd
CRS-4530: Communications failure contacting Cluster Synchronization Services daemon
[oracle@oracle11g ~]$ crsctl check has
CRS-4638: Oracle High Availability Services is online
[oracle@oracle11g ~]$ ps -fea | grep d.bin
oracle 6208 1 0 Apr15 ? 00:02:37 /u01/app/oracle/product/11.2.0/grid/bin/ohasd.bin reboot



Y efectivamente vemos que el servicio está abajo ... aunque el servicio ohasd este online


¿Cuál es la causa de este inconveniente?
Pues a partir de Oracle11gr2 los demonios cssd y diskmon no son levantados vía el oratab, ahora estos demonios son levantados por el HAS (High Availability Service) y registrados en un OCR local como un recurso más.
Para analizar esto, procedemos a ir al HOME de la instalación del Grid Infraestructure, que en el fondo es el HOME que soporta el ASM
Y analizamos los recursos existentes
[oracle@oracle11g ~]$ cd $ORACLE_HOME
[oracle@oracle11g grid]$ pwd
/u01/app/oracle/product/11.2.0/grid
[oracle@oracle11g grid]$ cd bin
[oracle@oracle11g bin]$ ./crsctl status resource -t
--------------------------------------------------------------------------------
NAME TARGET STATE SERVER STATE_DETAILS
--------------------------------------------------------------------------------
Local Resources
--------------------------------------------------------------------------------
ora.DATA.dg
OFFLINE OFFLINE oracle11g
ora.asm
OFFLINE OFFLINE oracle11g
--------------------------------------------------------------------------------
Cluster Resources
--------------------------------------------------------------------------------
ora.cssd
1 ONLINE OFFLINE
ora.diskmon
1 ONLINE OFFLINE




Como vemos , ambos demonios , inscritos como recursos se encuentran OFFLINE
Para ver el origen del problema, analizamos los recursos con su configuración en detalle
Nota : Solamente vamos a mostrar los recursos que tienen problemas (CSSD y DISKMON)
[oracle@oracle11g bin]$ ./crsctl status resource -p
NAME=ora.cssd
TYPE=ora.cssd.type
ACL=owner:oracle:rwx,pgrp:oinstall:rwx,other::r--
ACTIVE_PLACEMENT=0
AGENT_FILENAME=%CRS_HOME%/bin/cssdagent%CRS_EXE_SUFFIX%
AGENT_HB_INTERVAL=0
AGENT_HB_MISCOUNT=10
AUTO_START=never
CARDINALITY=1
CHECK_INTERVAL=30
CLEAN_ARGS=abort
CSSD_PATH=%CRS_HOME%/bin/ocssd%CRS_EXE_SUFFIX%
CSS_USER=oracle
DEGREE=1
DESCRIPTION="Resource type for CSSD"
DETACHED=true
ENABLED=1
FAILOVER_DELAY=0
FAILURE_INTERVAL=3
FAILURE_THRESHOLD=5
LOAD=1
LOGGING_LEVEL=1
OFFLINE_CHECK_INTERVAL=0
OMON_INITRATE=1000
OMON_POLLRATE=500
ORA_VERSION=11.2.0.1.0
PLACEMENT=balanced
PROCD_TIMEOUT=1000
RESTART_ATTEMPTS=5
SCRIPT_TIMEOUT=600
START_DEPENDENCIES=weak(concurrent:ora.diskmon)
START_TIMEOUT=600
STOP_DEPENDENCIES=hard(shutdown:ora.diskmon)
STOP_TIMEOUT=900
UPTIME_THRESHOLD=1m
VMON_INITLIMIT=16
VMON_INITRATE=500
VMON_POLLRATE=500
NAME=ora.diskmon
TYPE=ora.diskmon.type
ACL=owner:oracle:rwx,pgrp:oinstall:rwx,other::r--
ACTIVE_PLACEMENT=0
AGENT_FILENAME=%CRS_HOME%/bin/orarootagent%CRS_EXE_SUFFIX%
AUTO_START=never
CARDINALITY=1
CHECK_INTERVAL=20
CHECK_TIMEOUT=10
DEGREE=1
DESCRIPTION="Resource type for Diskmon"
DETACHED=true
ENABLED=1
FAILOVER_DELAY=0
FAILURE_INTERVAL=3
FAILURE_THRESHOLD=5
LOAD=1
LOGGING_LEVEL=1
OFFLINE_CHECK_INTERVAL=0
ORA_VERSION=11.2.0.1.0
PLACEMENT=balanced
RESTART_ATTEMPTS=10
SCRIPT_TIMEOUT=60
START_DEPENDENCIES=weak(concurrent:ora.cssd)pullup:always(ora.cssd)
START_TIMEOUT=60
STOP_TIMEOUT=60
UPTIME_THRESHOLD=5s
USR_ORA_ENV=ORACLE_USER=oracle
VERSION=11.2.0.1.0




La propiedad AUTO_START esta seteada como NEVER o como 2 , para los demonios CDDS y DISKMON, esto implica que estos recursos no serán levantados nunca en un reincio por el HAS, y si el Cluster Synchronization Service no puede levantar, implica que la instancia ASM no puede partir.
Para solucionar el problema se debe configurar el AUTO_START para esos demonios (diskmon y cssd)
[oracle@oracle11g bin]$ ./crsctl modify resource "ora.cssd" -attr "AUTO_START=1"
[oracle@oracle11g bin]$
[oracle@oracle11g bin]$
[oracle@oracle11g bin]$ ./crsctl modify resource "ora.diskmon" -attr "AUTO_START=1"
[oracle@oracle11g bin]$




Una vez ejecutados esos comandos, procedemos a analizar nuevamente la configuración de los recursos
NAME=ora.cssd
TYPE=ora.cssd.type
AUTO_START=1
NAME=ora.diskmon
TYPE=ora.diskmon.type
AUTO_START=1



Verificamos los recursos y su estado actual
[oracle@oracle11g bin]$ ./crsctl status resource -t
--------------------------------------------------------------------------------
NAME TARGET STATE SERVER STATE_DETAILS
--------------------------------------------------------------------------------
Local Resources
--------------------------------------------------------------------------------
ora.DATA.dg
OFFLINE OFFLINE oracle11g
ora.asm
OFFLINE OFFLINE oracle11g
--------------------------------------------------------------------------------
Cluster Resources
--------------------------------------------------------------------------------
ora.cssd
1 ONLINE OFFLINE
ora.diskmon
1 ONLINE OFFLINE
[oracle@oracle11g bin]$




Como podemos apreciar, ahora se encuentran con un TARGET ONLINE, lo que implica que se reiniciarán con un reboteo..
Pero se aprecia que el STATE es OFFLINE, eso implica que no están arriba los recursos, procedemos a levantarlos
[oracle@oracle11g bin]$ ./crs_start -all
Intentando iniciar `ora.cssd` en el miembro `oracle11g`
Intentando parar `ora.diskmon` en el miembro `oracle11g`
La parada de `ora.diskmon` en el miembro `oracle11g` se ha realizado correctamente.
Intentando iniciar `ora.diskmon` en el miembro `oracle11g`
El inicio de `ora.diskmon` en el miembro `oracle11g` se ha realizado correctamente.
El inicio de `ora.cssd` en el miembro `oracle11g` se ha realizado correctamente.
Intentando iniciar `ora.asm` en el miembro `oracle11g`
El inicio de `ora.asm` en el miembro `oracle11g` se ha realizado correctamente.
Intentando iniciar `ora.DATA.dg` en el miembro `oracle11g`
El inicio de `ora.DATA.dg` en el miembro `oracle11g` se ha realizado correctamente.



Y los volvemos a verificar
[oracle@oracle11g bin]$ ./crsctl status resource -t
--------------------------------------------------------------------------------
NAME TARGET STATE SERVER STATE_DETAILS
--------------------------------------------------------------------------------
Local Resources
--------------------------------------------------------------------------------
ora.DATA.dg
ONLINE ONLINE oracle11g
ora.asm
ONLINE ONLINE oracle11g Started
--------------------------------------------------------------------------------
Cluster Resources
--------------------------------------------------------------------------------
ora.cssd
1 ONLINE ONLINE oracle11g
ora.diskmon
1 ONLINE ONLINE oracle11g




Ahora procedemos a levantar nuestra instancia ASM
Vale la pena recordar, que la instancia ASM ya no se levanta con el rol SYSDBA, existe uno nuevo llamado SYSASM , si nos conectamos con SYSDBA, aparecerá un error de privilegios
[oracle@oracle11g bin]$ sqlplus /nolog
SQL*Plus: Release 11.2.0.1.0 Production on Fri Apr 16 06:05:11 2010
Copyright (c) 1982, 2009, Oracle. All rights reserved.
SQL> conn / as sysdba
Connected.
SQL> startup
ORA-01031: insufficient privileges
SQL>


 Nos conectamos con el rol indicado y procedemos a subir la instancia ASM

SQL> conn / as sysasm
Connected.
SQL> startup
ASM instance started
Total System Global Area 284565504 bytes
Fixed Size 1336036 bytes
Variable Size 258063644 bytes
ASM Cache 25165824 bytes
ASM diskgroups mounted

miércoles, 20 de marzo de 2013

Buscar History

history grep | mkfs

Muestra la lista de historia de órdenes con números de línea, el fichero de historial por defecto esta contenido en el valor de la variable HISTFILE.
history n muestra las últimas n líneas
history -c borra la lista de historial (borrando todas las entradas).
history -d 625 Borra el comando que se encuentre en la posición 625 de la lista de historial
history -a añade las líneas de historia ‘‘nuevas’’ (las introducidas desde el inicio de la sesión de bash en curso) al fichero de historia.
history -r lee los contenidos del fichero de historia y los usa como la historia en curso.
Trabajando con el Historial de comandos
!find ejecuta la última orden que empieza por la cadena find
!?home? ejecuta la última orden que contenga la cadena home
ctrl+r busca la cadena en el history
comando ejecuta comando sin que este sea almacenado en el historial de comandos, esto será así dependiendo del valor de las variables de ambiente HISTCONTROL y HISTIGNORE (ver man bash, para mayor información)
kill -9 $$ sale del shell actual sin guardar el historial de comandos.

martes, 19 de marzo de 2013

UPTIME


Calcular Disponibilidad

select
   'Hostname : ' || host_name
   ,'Instance Name : ' || instance_name
   ,'Started At : ' || to_char(startup_time,'DD-MON-YYYY HH24:MI:SS') stime
   ,'Uptime : ' || floor(sysdate - startup_time) || ' days(s) ' ||
   trunc( 24*((sysdate-startup_time) -
   trunc(sysdate-startup_time))) || ' hour(s) ' ||
   mod(trunc(1440*((sysdate-startup_time) -
   trunc(sysdate-startup_time))), 60) ||' minute(s) ' ||
   mod(trunc(86400*((sysdate-startup_time) -
   trunc(sysdate-startup_time))), 60) ||' seconds' uptime
from
   sys.v_$instance;
If you assume that PMON startup time is the same as the database startup time, you can get the uptime here:select
   to_char(logon_time,'DD/MM/YYYY HH24:MI:SS')
from
   v$session
where
   sid=1;


miércoles, 23 de enero de 2013

Installing Oracle 10g on RedHat 6

Installing Oracle 10g (64 bit) 10.2.0.1 on RedHat 6.1 (x86_64) CentOS OLE


2011-06-29 22:12:50





Installing Oracle 10g (64 bit) 10.2.0.1 on RedHat 6.1 (x86_64) CentOS OLE
==============================================================
Date: 09-DEC-2009

File: 10201_database_linux_x86_64.cpio.gz
File: p6810189_10204_Linux-x86-64.zip (patch)


> gunzip -c 10201_database_linux_x86_64.cpio.gz > db10201.cpio
> cpio -idmv < db10201.cpio





-- # From DVD, Install additional libXp and its dependencies: 32bit only

rpm -ivh libXau-1.0.5-1.el6.i686.rpm
rpm -ivh libxcb-1.5-1.el6.i686.rpm
rpm -ivh libXext-1.1-3.el6.i686.rpm
rpm -ihv libuuid-2.17.2-12.el6.i686.rpm
rpm -ihv libICE-1.0.6-1.el6.i686.rpm
rpm -ihv libSM-1.1.0-7.1.el6.i686.rpm
rpm -ihv libXt-1.0.7-1.el6.i686.rpm
rpm -ihv libXi-1.3-3.el6.i686.rpm
rpm -ihv libXtst-1.0.99.2-3.el6.i686.rpm
rpm -ivh libXp-1.0.0-15.1.el6.i686.rpm





-- # File /etc/redhat-release has been edited to contain:

redhat-4





-- # Following lines added to: /etc/security/limits.conf
* soft nproc 2047
* hard nproc 16384
* soft nofile 1024
* hard nofile 65536




-- # Following line added to: /etc/pam.d/login
session required /lib/security/pam_limits.so




-- # cat /etc/sysctl.conf

# keos
kernel.shmmni = 4096
kernel.sem = 250 32000 100 128
fs.file-max = 65536
net.ipv4.ip_local_port_range = 1024 65000
net.core.rmem_default = 262144
net.core.rmem_max = 262144
net.core.wmem_default = 262144
net.core.wmem_max = 262144



-- # RELOAD PARAMETERS # /sbin/sysctl -p


-- # CREATE oracle USER

groupadd oinstall
groupadd dba
groupadd oper
useradd -g oinstall -G dba oracle
passwd oracle



mkdir -p /oracle
chown -R oracle.oinstall /oracle











-- # Add to .bash_profile.
ulimit -u 16384 -n 65536 into .bash_profile






# Oracle Settings, file: SAMT.env
# ----------------------------------------------------
TMP=/tmp; export TMP
TMPDIR=$TMP; export TMPDIR

ORACLE_BASE=/oracle; export ORACLE_BASE
ORACLE_HOME=$ORACLE_BASE/product/10.2.0/db_1; export ORACLE_HOME
ORACLE_SID=SAMT; export ORACLE_SID
ORACLE_TERM=xterm; export ORACLE_TERM
PATH=/usr/sbin:$PATH; export PATH
PATH=$ORACLE_HOME/bin:$PATH; export PATH

LD_LIBRARY_PATH=$ORACLE_HOME/lib:/lib:/usr/lib; export LD_LIBRARY_PATH
CLASSPATH=$ORACLE_HOME/JRE:$ORACLE_HOME/jlib:$ORACLE_HOME/rdbms/jlib; export CLASSPATH
# ----------------------------------------------------



# Source the env:

. ./SAMT.env




-- # Install Oracle 10g R2:
./runInstaller











--------------------------------------------------------------------





-- # install Oracle Patch 10204 64 bit: p6810189_10204_Linux-x86-64.zip









-- # cd Disk1

vi ./install/oraparams.ini



comment out:

# [Certified Versions]

# Linux=redhat-3,redhat-4,....









-- # ./runInstaller













jueves, 1 de noviembre de 2012

EXPLICACION INDICES


Resumen índices

Un índice es una estructura opcional, asociado con una mesa o tabla de clúster, que a veces puede acelerar el acceso de datos. Mediante la creación de un índice en una o varias columnas de una tabla, se obtiene la capacidad en algunos casos, para recuperar un pequeño conjunto de filas distribuidas al azar de la tabla. Los índices son una de las muchas formas de reducir el disco I / O.

Si una tabla de montón organizado no tiene índices, entonces la base de datos debe realizar un escaneo completo de tabla para encontrar un valor. Por ejemplo, sin un índice, una consulta de ubicación 2700 en la tabla hr.departments requiere la base de datos para buscar todas las filas de cada bloque de la tabla para este valor. Este enfoque no escala bien como datos de aumento de volúmenes.

Por analogía, supongamos que un gerente de Recursos Humanos tiene un estante de cajas de cartón. Las carpetas que contienen información de los empleados se insertan aleatoriamente en las cajas. La carpeta de empleado Whalen (ID 200) es de 10 carpetas desde el fondo de la caja 1, mientras que la carpeta para el rey (ID 100) se encuentra en la parte inferior del cuadro 3. Para localizar una carpeta, el gestor busca en cada carpeta en la casilla 1 de abajo hacia arriba, y luego se mueve de una casilla a otra hasta que se encuentra la carpeta. Para acelerar el acceso, el administrador puede crear un índice que enumera de forma secuencial todos los ID de empleado con su ubicación de la carpeta:


 
ID 100: Box 3, position 1 (bottom)

ID 101: Box 7, position 8

ID 200: Box 1, position 10

.

.

.

Del mismo modo, el administrador podría crear índices separados para los últimos nombres de los empleados, los ID de departamento, y así sucesivamente.
En general, considerar la creación de un índice en una columna en cualquiera de las siguientes situaciones:

• Las columnas indizadas se consultan con frecuencia y devuelven un pequeño porcentaje del número total de filas en la tabla.

• Existe una restricción de integridad referencial en la columna o columnas indexadas. El índice es un medio para evitar un bloqueo de tabla completa que de otro modo se requeriría si se actualiza la clave principal de la tabla principal, se funden en la tabla principal, o eliminar de la tabla primaria.

• Una restricción de clave única se coloca sobre la mesa y desea especificar manualmente el índice de todas las opciones sobre índices y.


Características de indexación


Los índices son objetos de esquema que son lógica y físicamente independiente de los datos de los objetos con los que están asociados. Por lo tanto, un índice se puede quitar o creado sin afectar físicamente a la tabla para el índice.

Nota:
Si se le cae un índice, las aplicaciones siguen funcionando. Sin embargo, el acceso de los datos previamente indexado puede ser más lento.

La ausencia o presencia de un índice no requiere un cambio en el texto de cualquier sentencia SQL. Un índice es una ruta de acceso rápido a una sola fila de datos. Sólo afecta a la velocidad de ejecución. Dado un valor de datos que se ha indexado, el índice apunta directamente a la ubicación de las filas que contienen ese valor.
La base de datos mantiene automáticamente y utiliza los índices después de su creación. La base de datos también refleja automáticamente los cambios en los datos, como agregar, actualizar y eliminar filas, en todos los índices pertinentes sin acciones adicionales requeridas por los usuarios. Rendimiento de recuperación de datos indexados permanece casi constante, incluso cuando se insertan filas. Sin embargo, la presencia de muchos índices en una tabla degrada el rendimiento DML porque la base de datos también debe actualizar los índices.

Índices tienen las siguientes propiedades:

• Facilidad de uso

Los índices son utilizables (por defecto) o inutilizable. Un índice inutilizables no se mantiene por las operaciones DML y es ignorado por el optimizador. Un índice inutilizable puede mejorar el rendimiento de las cargas a granel. En lugar de dejar un índice y luego volverlo a crear, puede hacer que el índice inservible y luego reconstruirlo. Índices inutilizables y las particiones de índice no consumen espacio. Cuando usted hace un índice utilizable no utilizable, la base de datos cae su segmento de índice.

• Visibilidad

Los índices son visibles (por defecto) o invisible. Un índice invisible se mantiene por las operaciones DML y no se utiliza de forma predeterminada por el optimizador. Cómo hacer una invisible índice es una alternativa a lo que es inutilizable o se caiga. Índices invisibles son especialmente útiles para probar la eliminación de un índice antes de dejarlo caer o mediante índices temporalmente sin afectar a la aplicación general.


Guía del administrador de aprender a manejar los índices

• Base de datos Oracle Performance Tuning Guide para aprender cómo ajustar los índices

Teclas y Columnas


Una clave es un conjunto de columnas o expresiones en las que se puede construir un índice. Aunque los términos se usan indistintamente, los índices y las claves son diferentes. Los índices son estructuras almacenados en la base de datos que los usuarios a administrar el uso de sentencias de SQL. Las claves son estrictamente un concepto lógico.
La siguiente sentencia crea un índice en la columna customer_id de la muestra oe.orders tabla:

 
CREATE INDEX ord_customer_ix ON orders (customer_id);

 

En la declaración anterior, la columna customer_id es la clave de índice. El índice en sí se llama ord_customer_ix.

Índices Compuestos

Un índice compuesto, también llamado índice concatenado, es un índice de varias columnas de una tabla. Las columnas de un índice compuesto que deben aparecer en el orden que tenga más sentido para las consultas que recuperar datos y no necesita ser adyacente en la tabla.
Los índices compuestos pueden acelerar la recuperación de datos para las instrucciones SELECT en la que el DONDE referencias cláusula totalidad o la parte principal de las columnas en el índice compuesto. Por lo tanto, el orden de las columnas utilizadas en la definición es importante. En general, las columnas de acceso más común van primero.

Por ejemplo, supongamos que una aplicación realiza consultas frecuentes al apellidos, job_id, y columnas de salario en la tabla empleados. También asumir que last_name tiene alta cardinalidad, lo que significa que el número de valores distintos que es grande en comparación con el número de filas de la tabla. Se crea un índice con el siguiente orden de las columnas:

CREATE INDEX employees_ix

   ON employees (last_name, job_id, salary);

Las consultas que acceden a las tres columnas, sólo la columna last_name, o sólo el last_name y columnas job_id utilizan este índice. En este ejemplo, las consultas que no tienen acceso a la columna last_name no utilizan el índice.

Nota:

En algunos casos, tales como cuando la columna principal tiene muy baja cardinalidad, la base de datos puede utilizar una búsqueda selectiva de este índice

Múltiples índices pueden existir para la misma mesa, siempre y cuando la permutación de columnas difiere para cada índice. Puede crear varios índices que utilizan las mismas columnas si se especifica claramente diferentes permutaciones de las columnas. Por ejemplo, las siguientes sentencias SQL especifican permutaciones válidas:

 
CREATE INDEX employee_idx1 ON employees (last_name, job_id);

CREATE INDEX employee_idx2 ON employees (job_id, last_name);

Índices únicos y no único

Los índices pueden ser único o no único. Índices únicos garantizar que no hay dos filas de una tabla tienen valores duplicados en la columna de clave o columna. Por ejemplo, dos empleados no pueden tener el mismo ID de empleado. Por lo tanto, en un índice único, existe una ROWID para cada valor de datos. Los datos de los bloques de hojas se ordenan sólo por clave.

Índices no únicas permiten valores duplicados en la columna o columnas indexadas. Por ejemplo, la columna 'nombre de la tabla de empleados puede contener varios valores Mike. Para un índice no único, el ROWID se incluye en la clave de forma ordenada, por lo que los índices no únicos se ordenan por la clave de índice y ROWID (ascendente).

Oracle Database no filas de la tabla de índice en el que todas las columnas clave son nulas, a excepción de los índices de mapa de bits o cuando el valor de la columna clave de clúster es nulo.

Tipos de índices

Base de Datos Oracle ofrece varias combinaciones de indexación, que proporcionan una funcionalidad complementaria sobre el rendimiento. Los índices se pueden clasificar de la siguiente manera:

• Los índices de árbol B

Estos índices son el tipo de índice estándar. Son excelentes para la clave principal y los índices altamente selectivos. Utilizado como índices concatenados, B-tree índices pueden recuperar los datos ordenados por las columnas de índice. Índices B-tree tienen los siguientes subtipos:

Índice de tablas organizadas o


Una tabla de índice-organizada difiere de un montón-organizado porque los datos es en sí mismo el índice.

En este tipo de índice, los bytes de la clave de índice se invierten, por ejemplo, 103 se almacena como 301. La inversión de bytes extiende inserta en el índice durante muchos bloques. Consulte "Indicadores clave inversa".

Ö Descendente índices

Este tipo de índice almacena los datos en una columna o columnas de concreto en orden descendente. Consulte "Ascendiendo y descendiendo los índices".

o índices B-tree de racimo


Este tipo de índice se utiliza para indexar una clave de clúster tabla. En lugar de apuntar a una fila, los puntos clave para el bloque que contiene filas relacionadas con la clave de clúster. Consulte "Descripción general de Clusters indexadas".

• Mapa de bits y los índices bitmap join

En un índice de mapa de bits, una entrada de índice utiliza un mapa de bits para que apunte a varias filas. En cambio, los puntos de entrada de un índice B-tree en una sola fila. Un índice de combinación de mapa de bits es un índice de mapa de bits para la unión de dos o más tablas. Consulte "Indicadores de mapa de bits".

• Los índices basados ​​en funciones

Este tipo de índice incluye columnas que, o bien se transforman por una función, tales como la función UPPER, o incluidos en una expresión. Índices B-tree o mapa de bits puede ser basado en las funciones.

Consulte "Indicadores basados ​​en funciones".

• Índices de dominio de aplicación

Este tipo de índice se crea por un usuario para los datos en un dominio específico de la aplicación. El índice física no tiene que utilizar una estructura de índice tradicional y se puede almacenar ya sea en la base de datos Oracle como tablas o externamente como un archivo. Consulte "Indicadores de dominio de aplicación".
Vea también:

Oracle Database Performance Tuning Guide para aprender sobre los diferentes tipos de índices

Índices B-Tree

Árboles B, abreviatura de árboles balanceados, son el tipo más común de índice de base de datos. Un índice B-tree es una lista ordenada de valores dividida en rangos. Mediante la asociación de una tecla con una fila o rango de filas, los árboles B proporcionan un excelente rendimiento de la recuperación para una amplia gama de consultas, incluyendo coincidencia exacta y búsquedas por rango.
La figura 3-1 ilustra la estructura de un índice B-tree. El ejemplo muestra un índice en la columna department_id, que es una columna de clave externa en la tabla empleados.

 Figure 3-1 Internal Structure of a B-tree Index

Bloqueos de rama y Bloques Leaf

Un índice B-tree tiene dos tipos de bloques: bloques de sucursales para la búsqueda y la hoja de bloques que almacenan valores. Los bloqueos de rama de nivel superior de un índice B-tree contienen datos de índice que apunta a bloques de índices de nivel inferior. En la Figura 3-1, el bloqueo de la rama raíz tiene una entrada de 0-40, lo que apunta al bloque de izquierda en el siguiente nivel de sucursales. Este bloqueo de la rama contiene entradas como 0-10 y 11-19. Cada uno de estos puntos de entradas a un bloque de la hoja que contiene los valores de clave que caen en la gama.

Un índice de árbol B está equilibrado porque todos los bloques hoja mantenerse de forma automática a la misma profundidad. Por lo tanto, la recuperación de cualquier documento desde cualquier lugar del índice toma aproximadamente la misma cantidad de tiempo. La altura del índice es el número de bloque requerido para pasar de el bloque de raíz a un bloque de la hoja. El nivel de las sucursales es la altura menos 1. En la Figura 3-1, el índice tiene una altura de 3 y un nivel de rama de la 2.
Bloqueos de rama almacenar el prefijo de clave mínimo necesario para tomar una decisión de ramificación entre dos teclas. Esta técnica permite que la base de datos para adaptarse a la mayor cantidad de información posible sobre cada bloque de rama. Los bloqueos de rama contienen un puntero al bloque de niño que contiene la clave. El número de teclas y punteros está limitado por el tamaño del bloque.

Los bloques de hojas contienen todos los valores de datos indexada y un ROWID correspondiente se utiliza para localizar la fila actual. Cada entrada está ordenada por (clave, ROWID). Dentro de un bloque de la hoja, una llave y ROWID está vinculada a sus hermanos entradas izquierda y derecha. Los propios bloques hoja también están doblemente enlazadas. En la Figura 3-1 el bloque de hoja más a la izquierda (0-10) está ligada a la segunda hoja bloque (11-19).

Nota:
Los índices en columnas con datos de tipo carácter se basan en los valores binarios de los personajes en el juego de caracteres de base de datos.

Scans Índice

En un recorrido de índice, la base de datos recupera una fila al recorrer el índice, utilizando los valores de columna indexados especificados por la norma. Si la base de datos analiza el índice de un valor, entonces se encontrará este valor en n E / S donde n es la altura del índice B-tree. Este es el principio básico detrás de los índices de base de datos Oracle.

Si una instrucción SQL sólo tiene acceso a columnas indexadas, a continuación, lee los valores de la base de datos directamente desde el índice en lugar de a partir de la tabla. Si la declaración accede columnas, además de las columnas indizadas, a continuación, la base de datos utiliza ROWIDs para encontrar las filas de la tabla. Típicamente, la base de datos recupera los datos de la tabla por alternativamente la lectura de un bloque de índice y luego un bloque de tabla.

Vea también:

Oracle Database Performance Tuning Guide para obtener información detallada sobre las exploraciones de índices

Índice Análisis Completo

En un recorrido de índice completo, la base de datos lee el índice completo en orden. Una exploración de índice completo está disponible si una columna en el índice, y en algunas circunstancias, cuando no se especifica un predicado de un predicado (cláusula WHERE) en las referencias de sentencia de SQL. Un análisis completo puede eliminar la clasificación ya que los datos aparecen ordenados por clave de índice.

Supongamos que una aplicación se ejecuta la siguiente consulta:

 

SELECT department_id, last_name, salary

FROM   employees

WHERE  salary > 5000

ORDER BY department_id, last_name;

 

También asumen que department_id, apellidos y salario son una clave compuesta en un índice. Oracle Database realiza un escaneo completo del índice, la lectura de forma ordenada (ordenado por ID de departamento y apellido) y filtrado en el atributo salario. De esta manera, la base de datos escanea un conjunto de datos más pequeñas que la tabla empleados, que contiene más columnas que las que se incluyen en la consulta, y evita la clasificación de los datos.


Por ejemplo, el análisis completo puede leer las entradas de índice de la siguiente manera:

 

50,Atkinson,2800,rowid

60,Austin,4800,rowid

70,Baer,10000,rowid

80,Abel,11000,rowid

80,Ande,6400,rowid

110,Austin,7200,rowid

.

.

.

Español

Inglés

Portugués



Fast Índice Análisis Completo

Un análisis rápido índice completo es un análisis completo índice en el que la base de datos lee los bloques de índice en ningún orden en particular. La base de datos accede a los datos en el índice de sí mismo, sin acceso a la tabla.

Exploraciones de índices completos rápidos son una alternativa a un escaneo completo de tabla cuando el índice contiene todas las columnas que son necesarios para la consulta, y al menos una columna en la clave de índice tiene la restricción NOT NULL.

Por ejemplo, una aplicación emite la siguiente consulta, que no incluye una cláusula ORDER BY:

 

SELECT last_name, salary

FROM   employees;

 

Si el apellido y el salario son una clave compuesta en un índice, a continuación, un análisis rápido índice completo puede leer las entradas de índice para obtener la información solicitada ::

 

Baida,2900,rowid

Zlotkey,10500,rowid

Austin,7200,rowid

Baer,10000,rowid

Atkinson,2800,rowid

Austin,4800,rowid

.

.

.

Índice de escaneado

Una exploración rango de índices es una exploración ordenada de un índice que tiene las siguientes características:

• Una o más columnas principales de un índice que se especifican en las condiciones. Una condición especifica una combinación de una o más expresiones y operadores lógicos (Boolean) y devuelve un valor de TRUE, FALSE o UNKNOWN.

0, 1, o más valores son posibles para una clave de índice.
La base de datos utiliza habitualmente un análisis rango de índices para acceder a datos selectivos. La selectividad es el porcentaje de filas en la tabla que la consulta selecciona. Una consulta que selecciona un pequeño porcentaje de filas tiene una buena selectividad, mientras que una consulta que selecciona un gran porcentaje de filas tiene pobre selectividad. La selectividad se ató a un predicado de consulta, por ejemplo, cuando apellidos LIKE 'A%', o una combinación de predicados.

Por ejemplo, un usuario consulta los empleados cuyos apellidos comienzan con A. Supongamos que la columna last_name está indexado, con las entradas de la siguiente manera:

Abel,rowid

Ande,rowid

Atkinson,rowid

Austin,rowid

Austin,rowid

Baer,rowid

.

.

.

La base de datos podría usar una exploración de distancia debido a la columna de la apellidos se especifica en el predicado y múltiplos ROWIDs son posibles para cada clave de índice. Por ejemplo, dos empleados son nombrados Austin, por lo que dos ROWIDs se asocian con la tecla Austin.

Una exploración intervalo de índice puede estar delimitado en ambos lados, como en una consulta para los departamentos con los ID de entre 10 y 40, o limitada en un solo lado, como en una consulta de los ID de más de 40. Para analizar el índice, la base de datos se mueve hacia atrás o hacia adelante a través de los bloques de la hoja. Por ejemplo, una exploración para los ID de entre 10 y 40 localiza el primer bloque de hoja de índice que contiene el valor de clave más bajo que es de 10 o mayor. La exploración continúa entonces horizontalmente a través de la lista enlazada de nodos de hoja hasta que se localiza un valor mayor que 40.

Index Scan Unique

En contraste con un índice de exploración de distancia, un único índice de exploración debe tener ya sea 0 o 1 rowID asociado con una clave de índice. La base de datos realiza una exploración única cuando un predicado todas las referencias de las columnas de una clave de índice UNIQUE usar un operador de igualdad. Una exploración único índice deja de procesar tan pronto como se encuentra el primer registro, ya que hay un segundo disco es posible.
A modo de ejemplo, supongamos que un usuario ejecute la consulta siguiente:

 

SELECT *

FROM   employees

WHERE  employee_id = 5;

 

Suponga que la columna employee_id es la clave principal y está indexado con las entradas de la siguiente manera:

 

1,rowid

2,rowid

4,rowid

5,rowid

6,rowid

.

.

.

En este caso, la base de datos puede utilizar un único índice de exploración para localizar el ROWID para el empleado cuyo identificador es 5.

 

Índice Skip Scan

Un índice skip análisis utiliza subíndices lógicas de un índice compuesto. La base de datos "salta" a través de un único índice como si se estuviera buscando índices separados. Escaneo Omitir es beneficioso si hay pocos valores distintos de la columna principal de un índice compuesto y muchos valores distintos en la clave nonleading del índice.

La base de datos puede elegir un índice Exploración con salto cuando la columna de dirección del índice compuesto no se ha especificado en un predicado de la consulta. Por ejemplo, suponga que ejecuta la consulta siguiente para un cliente en la tabla sh.customers:
:

 

SELECT * FROM sh.customers WHERE cust_email = 'Abbey@company.com';

 

La tabla clientes tiene un cust_gender columna cuyos valores son M o F. Supongamos que existe un índice compuesto en las columnas (cust_gender, cust_email). Ejemplo 3-1 se muestra una parte de las entradas de índice.

Ejemplo 3-1 Entradas de Índice Compuesto

F,Wolf@company.com,rowid

F,Wolsey@company.com,rowid

F,Wood@company.com,rowid

F,Woodman@company.com,rowid

F,Yang@company.com,rowid

F,Zimmerman@company.com,rowid

M,Abbassi@company.com,rowid

M,Abbey@company.com,rowid

 

La base de datos puede utilizar una búsqueda selectiva de este índice cust_gender a pesar de que no se especifica en la cláusula WHERE.

En una exploración de salto, el número de subíndices lógicas se determina por el número de valores distintos en la columna principal. En el Ejemplo 3-1, la columna principal tiene dos valores posibles. La base de datos se divide lógicamente el índice en un subíndice con la tecla F y un segundo subíndice con la tecla M.

Cuando se busca el registro para el cliente cuyo correo electrónico es Abbey@company.com, la base de datos busca en el subíndice con el valor F y luego busca en el subíndice con el valor M. Conceptualmente, la base de datos procesa la consulta de la siguiente manera:

 

SELECT * FROM sh.customers WHERE cust_gender = 'F'

  AND cust_email = 'Abbey@company.com'

UNION ALL

SELECT * FROM sh.customers WHERE cust_gender = 'M'

  AND cust_email = 'Abbey@company.com';
 

Invierta índices de clave

Un índice de clave inversa es un tipo de índice B-tree que invierte físicamente los bytes de cada clave de índice, manteniendo el orden de las columnas. Por ejemplo, si la clave de índice es 20, y si los dos bytes almacenados para esta clave en hexadecimal son C1, 15 en un índice de árbol B estándar, a continuación, un índice de clave inversa almacena los bytes como 15, C1.

La inversión de la llave soluciona el problema de la contención de los bloques de la hoja en el lado derecho de un índice B-tree. Este problema puede ser especialmente grave en un Oracle Real Application Clusters (Oracle RAC) de base de datos en la que varias instancias modificar varias veces el mismo bloque. Por ejemplo, en un ordena tablas las claves principales para las órdenes son secuenciales. Una instancia del clúster agrega fin 20, mientras que otro 21 añade, con cada instancia de escribir su clave para el mismo bloque de la hoja en el lado derecho del índice.
En un índice de clave inversa, la revocación de la orden de bytes distribuye inserta a través de todas las claves de la hoja en el índice.

Por ejemplo, las llaves, como 20 y 21, que habría sido enunciada en un índice de clave estándar están almacenados lejos en bloques separados. Por lo tanto, E / S para las inserciones de claves secuenciales se distribuye más uniformemente.

Debido a que los datos en el índice no está ordenado por clave columna cuando se almacena, la disposición de las teclas inversa elimina la capacidad de ejecutar una serie de consulta de exploración de índice en algunos casos. Por ejemplo, si un usuario emite una consulta para los ID de orden superior a 20, a continuación, la base de datos no puede comenzar con el bloque que contiene este ID y proceder horizontalmente a través de los bloques hoja.

Ascendiendo y descendiendo índices

En un índice ascendente, Oracle Database almacena los datos en orden ascendente. De forma predeterminada, los datos de caracteres se ordenan por los valores binarios contenidos en cada byte del valor, los datos numéricos de menor a mayor número, y fecha de la primera a la última de valor.

Para un ejemplo de un índice ascendente, considere la siguiente sentencia SQL:

 

CREATE INDEX emp_deptid_ix ON hr.employees(department_id);

 
Oracle tipo de base de datos de la tabla hr.employees en la columna department_id. Se carga el índice ascendente de los valores ROWID department_id y correspondientes en orden ascendente, empezando por 0. Cuando se utiliza el índice, base de datos Oracle busca en los valores department_id ordenados y utiliza los ROWIDs asociadas para localizar filas que tienen el valor department_id solicitada.

Al especificar la palabra clave DESC en la sentencia CREATE INDEX, puede crear un índice descendente. En este caso, el índice almacena los datos en una columna o columnas especificado en orden descendente. Si el índice en la figura 3-1 en la columna employees.department_id se desciende, a continuación, la hoja de bloqueo que contenía 250 sería en el lado izquierdo del árbol y el bloque con 0 a la derecha. La búsqueda por defecto a través de un índice descendente es de mayor a menor valor.

Descendente índices son útiles cuando una consulta de tipo algunas columnas que suben y otros descendente. Por ejemplo, supongamos que se crea un índice compuesto sobre el last_name y columnas department_id de la siguiente manera:

CREATE INDEX emp_name_dpt_ix ON hr.employees(last_name ASC, department_id DESC);

 

Si consultas un usuario hr.employees de apellidos en orden ascendente (A a Z) y los identificadores de departamento en orden (de mayor a menor) descendente, entonces la base de datos pueden utilizar este índice para recuperar los datos y evitar el paso adicional de clasificarlos.


compresión clave

Oracle Database puede utilizar la compresión llave para comprimir partes de los principales valores de columna de clave en un índice B-tree o una tabla organizada por índices. Clave de compresión puede reducir en gran medida el espacio consumido por el índice.
En general, las claves de índice tienen dos piezas, una pieza agrupación y una pieza única. Clave de compresión rompe la clave de índice en una entrada de prefijo, que es la pieza agrupación, y una entrada de sufijo, que es la pieza única o casi única. La base de datos alcanza la compresión mediante el intercambio de las entradas de prefijo entre las entradas de sufijos en un bloque de índice.

Nota:
Si no se define una clave para tener una pieza única, entonces la base de datos proporciona una añadiendo un ROWID a la pieza de agrupación.
De forma predeterminada, el prefijo de un índice único se compone de todas las columnas de clave excluyendo el último, mientras que el prefijo de un índice no único se compone de todas las columnas de clave. Por ejemplo, supongamos que crea un índice compuesto sobre la mesa oe.orders la siguiente manera:

CREATE INDEX orders_mod_stat_ix ON orders ( order_mode, order_status );

 

Muchos valores repetidos se producen en las columnas order_mode y ORDER_STATUS. Un bloque de índice puede tener entradas como se muestra en el Ejemplo 3-2.

Example 3-2 Index Entries in Orders Table

online,0,AAAPvCAAFAAAAFaAAa

online,0,AAAPvCAAFAAAAFaAAg

online,0,AAAPvCAAFAAAAFaAAl

online,2,AAAPvCAAFAAAAFaAAm

online,3,AAAPvCAAFAAAAFaAAq

online,3,AAAPvCAAFAAAAFaAAt

 

En el Ejemplo 3-2, el prefijo clave consistiría en una concatenación de los valores order_mode y ORDER_STATUS. Si este índice se creó con la compresión de claves predeterminado y luego duplicar prefijos clave como la línea, 0 y en línea, 2 podría ser comprimido. Conceptualmente, la base de datos alcanza la compresión como se muestra en el ejemplo siguiente:online,0

 

AAAPvCAAFAAAAFaAAa

AAAPvCAAFAAAAFaAAg

AAAPvCAAFAAAAFaAAl

online,2

AAAPvCAAFAAAAFaAAm

online,3

AAAPvCAAFAAAAFaAAq

AAAPvCAAFAAAAFaAAt

Entradas de sufijos forman la versión comprimida de filas de índice. Cada asiento se refiere a un sufijo entrada de prefijo, que se almacena en el mismo bloque de índice como la entrada sufijo.

Como alternativa, puede especificar una longitud de prefijo al crear un índice comprimido. Por ejemplo, si se especifica la longitud de prefijo 1, el prefijo sería order_mode y el sufijo sería ORDER_STATUS, ROWID. Para los valores del Ejemplo 3-2, el índice podría factorizar apariciones duplicadas de línea de la siguiente manera:

 

online

0,AAAPvCAAFAAAAFaAAa

0,AAAPvCAAFAAAAFaAAg

0,AAAPvCAAFAAAAFaAAl

2,AAAPvCAAFAAAAFaAAm

3,AAAPvCAAFAAAAFaAAq

3,AAAPvCAAFAAAAFaAAt

 

Índices de mapa de bits

En un índice de mapa de bits, la base de datos almacena un mapa de bits para cada clave de índice. En un índice B-tree convencional, una entrada de índice apunta a una sola fila. En un índice de mapa de bits, cada clave de índice almacena punteros a varias filas.

Índices de mapa de bits están diseñados principalmente para el almacenamiento de datos o entornos en los que las consultas de referencia muchas columnas en una manera ad hoc. Las situaciones que pueden requerir un índice de mapa de bits son:

Las columnas indexadas tienen baja cardinalidad, es decir, el número de valores distintos que es pequeño en comparación con el número de filas de la tabla.

• La tabla de indexado es ya sea de sólo lectura o no sujetos a modificación significativa de las sentencias DML.

Para ver un ejemplo de almacenamiento de datos, la tabla tiene una columna sh.customer cust_gender con sólo dos valores posibles: M y F. Supongamos que las consultas para el número de clientes de un género en particular, son comunes. En este caso, la columna de la customer.cust_gender sería un candidato para un índice de mapa de bits.

Cada bit del mapa de bits corresponde a una posible ROWID. Si el bit está activado, entonces la fila con el ROWID correspondiente contiene el valor clave. Una función de mapeo convierte la posición de bit a un ROWID real, por lo que el índice de mapa de bits proporciona la misma funcionalidad que un índice de árbol B pesar de que utiliza una representación interna diferente.

Si la columna indexada en una sola fila se actualiza, a continuación, la base de datos bloquea la entrada de clave de índice (por ejemplo, M o F) y no el bit individual asignada a la fila actualizada. Debido a los puntos clave a muchas filas, DML en los datos indexados normalmente bloquea todas estas filas. Por esta razón, los índices de mapa de bits no son apropiados para muchas aplicaciones OLTP.


Índices de mapa de bits en una sola tabla


Ejemplo 3-3 muestra una consulta de la tabla sh.customers. Algunas columnas de esta tabla son candidatos para un índice de mapa de bits.
Ejemplo 3-3 Consulta de la tabla clients

 

 

SQL> SELECT cust_id, cust_last_name, cust_marital_status, cust_gender

  2  FROM   sh.customers

  3  WHERE  ROWNUM < 8 ORDER BY cust_id;

 

   CUST_ID CUST_LAST_ CUST_MAR C

---------- ---------- -------- -

         1 Kessel              M

         2 Koch                F

         3 Emmerson            M

         4 Hardy               M

         5 Gowen               M

         6 Charles    single   F

         7 Ingram     single   F

 

7 rows selected.

 

El cust_marital_status y columnas cust_gender tienen baja cardinalidad, mientras cust_id y cust_last_name no. Por lo tanto, los índices de mapa de bits pueden ser apropiados en cust_marital_status y cust_gender. Un índice de mapa de bits no es probablemente útil para las otras columnas. En cambio, un índice B-tree único en estas columnas probablemente proporcionar la representación más eficiente y recuperación.

Tabla 3-1 ilustra el índice de mapa de bits de la salida de la columna cust_gender muestra en el Ejemplo 3-3. Se compone de dos mapas de bits separados, uno para cada género.

 

Table 3-1 Ejemplo de Bitmap

Value
Row 1
Row 2
Row 3
Row 4
Row 5
Row 6
Row 7
M
1
0
1
1
1
0
0
F
0
1
0
0
0
1
1

 

Una función de mapeo convierte cada bit del mapa de bits a un identificador de fila de la tabla de clientes. Cada valor de bit depende de los valores de la fila correspondiente en la tabla. Por ejemplo, el mapa de bits para el valor de M contiene un 1 como primer poco porque el sexo es M en la primera fila de la tabla de clientes. El mapa de bits cust_gender = 'M' tiene un 0 para los bits en sus filas 2, 6, y 7 debido a que estas filas no contienen M como su valor.

Nota:
Índices de mapa de bits pueden incluir claves que consisten enteramente en valores nulos, a diferencia de índices B-tree. Nulos de indexación puede ser útil para algunas sentencias SQL, como las consultas con el número de función de agregado.

Un analista de la investigación de las tendencias demográficas de los clientes puede preguntar, "¿Cuántos de nuestros clientes son mujeres solteras o divorciadas?" Esta pregunta se corresponde con la siguiente consulta SQL

 

SELECT COUNT(*)

FROM   customers 

WHERE  cust_gender = 'F'

AND    cust_marital_status IN ('single', 'divorced');

Índices de mapa de bits pueden procesar esta consulta de manera eficiente mediante el recuento del número de valores de 1 en el mapa de bits resultante, como se ilustra en la Tabla 3-2. Para identificar a los clientes que cumplan los criterios, Oracle Database puede utilizar el mapa de bits resultante para acceder a la tabla.

Tabla 3-2 Mapa de bits ejemplo

Value
Row 1
Row 2
Row 3
Row 4
Row 5
Row 6
Row 7
M
1
0
1
1
1
0
0
F
0
1
0
0
0
1
1
single
0
0
0
0
0
1
1
divorced
0
0
0
0
0
0
0
single or divorced, and F
0
0
0
0
0
1
1

 

Indexación Bitmap combina eficientemente los índices que corresponden a una serie de condiciones en una cláusula WHERE. Las filas que satisfacer algunas, pero no todas, las condiciones se filtran antes de la propia tabla se accede. Esta técnica mejora el tiempo de respuesta, a menudo de forma espectacular.

Bitmap Únete índices

Un índice de combinación de mapa de bits es un índice de mapa de bits para la unión de dos o más tablas. Para cada valor de una columna de la tabla, el índice almacena el identificador de fila de la fila correspondiente en la tabla indexada. Por el contrario, se crea un índice de mapa de bits estándar en una sola tabla.
Un índice de unirse a mapa de bits es un medio eficaz de reducir el volumen de datos que se deben unir mediante la realización de las restricciones de antemano. Para un ejemplo de cuando un bitmap unirse índice sería útil, suponen que los usuarios a menudo consultan el número de
empleados con un tipo de trabajo en particular. Una consulta típica podría ser como sigue:

 

 

SELECT COUNT(*)

FROM   employees, jobs

WHERE  employees.job_id = jobs.job_id

AND    jobs.job_title = 'Accountant';

El consulta anterior sería típicamente utilice un índice en jobs.job_title para recuperar las filas para Accountant y entonces el Identificación del Aviso del, y un índice sobre employees.job_id para encontrar los filas que coincidan con. Para recuperar los datos desde el índice en sí en lugar de a partir de una scan de las mesas, usted podría crear un mapa de bits unirse a índice de de la siguiente manera:

 

 

CREATE BITMAP INDEX employees_bm_idx

ON     employees (jobs.job_title)

FROM   employees, jobs

WHERE  employees.job_id = jobs.job_id;

 

Figure 3-2 Bitmap Join Index

Description of Figure 3-2 follows


Conceptualmente, employees_bm_idx es un índice de la columna jobs.title en la consulta SQL se muestra en el Ejemplo 3-4 (salida de muestra incluido). La clave job_title en los puntos de índice de filas en la tabla empleados. Una consulta del número de contadores puede usar el índice para evitar el acceso de los empleados y las tablas de puestos de trabajo debido a que el índice en sí contiene la información solicitada.

Ejemplo 3-4 Ingreso de los asalariados y los empleos Tablas

 

SELECT jobs.job_title AS "jobs.job_title", employees.rowid AS "employees.rowid"

FROM   employees, jobs

WHERE  employees.job_id = jobs.job_id

ORDER BY job_title;

 

jobs.job_title                      employees.rowid

----------------------------------- ------------------

Accountant                          AAAQNKAAFAAAABSAAL

Accountant                          AAAQNKAAFAAAABSAAN

Accountant                          AAAQNKAAFAAAABSAAM

Accountant                          AAAQNKAAFAAAABSAAJ

Accountant                          AAAQNKAAFAAAABSAAK

Accounting Manager                  AAAQNKAAFAAAABTAAH

Administration Assistant            AAAQNKAAFAAAABTAAC

Administration Vice President       AAAQNKAAFAAAABSAAC

Administration Vice President       AAAQNKAAFAAAABSAAB

.

.

.

En un almacén de datos, la condición de unión es una unión igualitaria (que utiliza el operador de igualdad) entre las columnas de clave principal de las tablas de dimensiones y las columnas de clave externa de la tabla de hechos. Unirse a los índices de mapa de bits son a veces mucho más eficiente en el almacenamiento de materializada unen puntos de vista, una alternativa para materializar une con antelación.

Vea también:

Oracle Database Data Warehousing Guide para obtener más información acerca de unirse a los índices de mapa de bits

Estructura de almacenamiento Bitmap

Oracle Database utiliza una estructura de índice B-tree para almacenar mapas de bits para cada clave indexada. Por ejemplo, si jobs.job_title es la columna de clave de un índice de mapa de bits, entonces los datos de índice se almacena en un B-árbol. Los mapas de bits individuales se almacenan en los bloques hoja.
Supongamos que la columna tiene valores jobs.job_title único vendedor de envío, Stock Clerk, y varios otros. Una entrada de índice de mapa de bits para este índice tiene los siguientes componentes:

El título del trabajo como la clave del índice
Un ROWID ROWID bajo y alto para una variedad de ROWIDs
Un mapa de bits para ROWIDs específicos en el rango

Conceptualmente, un bloque de la hoja de índice en este índice podría contener las entradas de la siguiente manera:

 

Shipping Clerk,AAAPzRAAFAAAABSABQ,AAAPzRAAFAAAABSABZ,0010000100

Shipping Clerk,AAAPzRAAFAAAABSABa,AAAPzRAAFAAAABSABh,010010

Stock Clerk,AAAPzRAAFAAAABSAAa,AAAPzRAAFAAAABSAAc,1001001100

Stock Clerk,AAAPzRAAFAAAABSAAd,AAAPzRAAFAAAABSAAt,0101001001

Stock Clerk,AAAPzRAAFAAAABSAAu,AAAPzRAAFAAAABSABz,100001

.

.

.

El mismo título del trabajo aparece en varias entradas debido a la gama ROWID difiere.

Supongamos que actualiza una sesión de trabajo de la identificación de un empleado del vendedor de envío de Stock Clerk. En este caso, la sesión requiere acceso exclusivo a la entrada de clave de índice para el valor antiguo (vendedor de envío) y el nuevo valor (Stock Clerk). Base de datos de Oracle bloquea las filas apuntada por estas dos entradas, pero no las filas apuntado por contador o cualquier otra tecla-hasta que la actualización comete.

Los datos para un índice de mapa de bits se almacenan en un segmento. Base de datos Oracle almacena cada mapa de bits en una o más piezas. Cada pieza ocupa parte de un único bloque de datos.

Índices basados ​​en funciones


Puede crear índices sobre las funciones y las expresiones que implican una o más columnas de la tabla está indexada. Un índice basado en funciones calcula el valor de una función o expresión que implique una o varias columnas y se almacena en el índice. Un índice basado en funciones puede ser un árbol B o un índice de mapa de bits.

La función que se utiliza para construir el índice puede ser una expresión aritmética o una expresión que contiene una función de SQL, la función PL / SQL definida por el usuario, la función del envase o C reclamo. Por ejemplo, una función podría añadir los valores en dos columnas.

Usos de los índices basados ​​en funciones

Los índices basados ​​en funciones son eficientes para evaluar las declaraciones que contienen funciones en sus cláusulas WHERE. La base de datos sólo se utiliza el índice basado en funciones cuando la función está incluida en una consulta. Cuando los procesos de base de datos INSERT y UPDATE, sin embargo, todavía debe evaluar la función de procesar el documento.

Por ejemplo, suponga que crea el siguiente índice basado en funciones:

 

 

CREATE INDEX emp_total_sal_idx

  ON employees (12 * salary * commission_pct, salary, commission_pct);

 

La base de datos se puede utilizar el índice anterior al procesar consultas como Ejemplo 3-5 (ejemplo de salida parcial incluido).

 

Ejemplo 3-5 consulta que contiene una expresión aritmética

 

SELECT   employee_id, last_name, first_name,

         12*salary*commission_pct AS "ANNUAL SAL"

FROM     employees

WHERE    (12 * salary * commission_pct) < 30000

ORDER BY "ANNUAL SAL" DESC;

 

EMPLOYEE_ID LAST_NAME                 FIRST_NAME           ANNUAL SAL

----------- ------------------------- -------------------- ----------

        159 Smith                     Lindsey                   28800

        151 Bernstein                 David                     28500

        152 Hall                      Peter                     27000

        160 Doran                     Louise                    27000

        175 Hutton                    Alyssa                    26400

        149 Zlotkey                   Eleni                     25200

        169 Bloom                     Harrison                  24000

 

Los índices basados ​​en funciones definidas en el SQL funciones UPPER (column_name) o LO WER (column_name) facilitar la búsqueda entre mayúsculas y minúsculas. Por ejemplo, supongamos que la columna 'nombre de empleados contiene caracteres en mayúsculas y minúsculas. Se crea el siguiente índice basado en las funciones de la mesa hr.employees:

CREATE INDEX emp_fname_uppercase_idx

ON employees ( UPPER(first_name) );

 

El índice emp_fname_uppercase_idx puede facilitar consultas como la siguiente ::

SELECT *

FROM   employees

WHERE  UPPER(first_name) = 'AUDREY';

 

Un índice basado en funciones también es útil para indizar sólo las filas específicas de una tabla. Por ejemplo, la columna cust_valid en la tabla sh.customers tiene ya sea I o A como un valor. Para indizar sólo las filas A, podría escribir una función que devuelve un valor nulo para las filas distintas de las filas A. Se puede crear el índice de la siguiente manera:

CREATE INDEX cust_valid_idx

ON customers ( CASE cust_valid WHEN 'A' THEN 'A' END );

 

Optimización con índices basados ​​en funciones

El optimizador puede utilizar un rango de exploración de índice en un índice basado en las funciones para las consultas con expresiones en la cláusula WHERE. La ruta de acceso de exploración de distancia es especialmente beneficioso cuando el predicado (cláusula WHERE) tiene una baja selectividad. En el Ejemplo 3-5 el optimizador puede utilizar un rango de exploración de índice, si el índice se basa en la expresión 12 * Sueldo * COMMISSION_PCT.

Una columna virtual es útil para acelerar el acceso a los datos derivados de las expresiones. Por ejemplo, se podría definir annual_sal columna virtual como 12 * Sueldo * COMMISSION_PCT y crear un índice basado en las funciones de annual_sal.

El optimizador realiza la concordancia de expresión mediante el análisis de la expresión en una sentencia SQL y luego comparar los árboles de expresión de la declaración y el índice basado en funciones. Esta comparación entre mayúsculas y minúsculas e ignora espacios en blanco.

Índices dominio de la aplicación.
Un índice dominio de aplicación es un índice personalizado específico para una aplicación. Oracle Database proporciona indización extensible para hacer lo siguiente:

• Acomodar los índices de medida, los tipos de datos complejos, tales como documentos, datos espaciales, imágenes y clips de vídeo (ver "Datos no estructurados")
• Hacer uso de las técnicas de indexación especializadas

Puede encapsular las rutinas de administración de índices específicos de la aplicación como un objeto de esquema INDEXTYPE y definir un índice de dominio en columnas de tablas o atributos de un tipo de objeto.

Indexación extensible puede procesar de manera eficiente los operadores específicos de la aplicación.

El software de aplicación, llamado el cartucho, controla la estructura y el contenido de un índice de dominio. La base de datos interactúa con la aplicación para construir, mantener y buscar en el índice de dominio. La estructura de índice en sí mismo puede ser almacenado en la base de datos como una tabla de índices-organizada o externamente como un archivo.
Índice de almacenamiento

Oracle Database almacena los datos de índice en un segmento de índice. El espacio disponible para los datos de índice de un bloque de datos es el tamaño de bloque de datos menos los gastos de bloque, sobrecarga de entrada, ROWID, y un byte de longitud para cada valor de índice.

El espacio de tablas de un segmento de índice es el espacio de tabla por omisión del propietario o de un espacio de tablas denominado específicamente en la sentencia CREATE INDEX. Para facilitar la administración puede almacenar un índice en una tabla independiente de su tabla. Por ejemplo, usted puede optar por no copia de seguridad de los espacios de tablas que contienen sólo los índices, que pueden ser reconstruidas, y así reducir el tiempo y el almacenamiento requerido para copias de seguridad.

Visión general de las tablas de índice organizadas

Una tabla de índice-organizada es una tabla almacenada en una variación de un índice de estructura de árbol-B. En una tabla de montón organizada, las filas se insertan en las que entran. En una tabla organizada por índices, las filas se almacenan en un índice definido en la clave principal de la tabla.

Cada entrada de índice en el árbol B también almacena los valores de columna no clave. Por lo tanto, el índice es la de datos, y los datos es el índice. Aplicaciones manipular tablas de índice organizadas como tablas montón organizados, mediante sentencias SQL.

Para una analogía de una tabla organizada por índices, supongamos que un gerente de recursos humanos tiene una estantería con cajas de cartón. Cada cuadro está marcado con un número 1, 2, 3, 4, y así sucesivamente, pero las cajas no se sientan en los estantes en orden secuencial. En su lugar, cada caja contiene un puntero a la ubicación de almacenamiento del siguiente cuadro en la secuencia.
Las carpetas que contienen los registros de empleados se almacenan en cada caja. Las carpetas se ordenan por número de empleado. Empleado Rey tiene ID 100, que es el identificador más bajo, por lo que su carpeta está en la parte inferior de la caja 1. La carpeta de empleado 101 está encima de 100, 102 está en la parte superior de 101, y así sucesivamente hasta que se completa el cuadro 1. La carpeta siguiente en la secuencia es en la parte inferior de la caja 2.

En esta analogía, ordenar las carpetas por ID de empleado permite buscar de manera eficiente para las carpetas sin tener que mantener un índice independiente. Supongamos que un usuario solicita los registros de los empleados 107, 120, y 122. En lugar de buscar un índice en un solo paso y la recuperación de las carpetas en una etapa distinta, el administrador puede buscar las carpetas en orden secuencial y recuperar todas las carpetas que se encuentran.

Índice de tablas organizadas proporcionan un acceso más rápido a filas de la tabla de clave principal o un prefijo válido de la tecla. La presencia de columnas sin clave de una fila en el bloque de la hoja evita un bloque de datos adicional I / O. Por ejemplo, el sueldo del empleado 100 se almacena en la fila de índice en sí. También, porque las filas se almacenan en orden, el acceso principal gama de teclas de la clave principal o prefijo implica bloque mínimo de I / Os. Otro de los beneficios es la evitación de la sobrecarga de espacio de un índice de clave principal separada.

Índice de tablas organizadas son útiles cuando las piezas relacionadas de datos deben ser almacenados juntos o los datos deben ser almacenados físicamente en un orden específico. Este tipo de tabla se utiliza a menudo para la recuperación de información, espacial (consulte el apartado "Visión general de Oracle Spatial"), y las aplicaciones OLAP (véase "OLAP").

Características de las tablas de índice organizadas


El sistema de base de datos realiza todas las operaciones en las tablas de índice organizadas por la manipulación de la estructura del índice B-tree. La Tabla 3-3 resume las diferencias entre las tablas de índice organizadas y mesas montón organizados.

Tabla 3-3 Comparación de las tablas Heap-organizada con cuadros organizada por índices


La figura 3-3 ilustra la estructura de una tabla de índice de departamentos-organizada. Los bloques de hojas contienen las filas de la tabla, ordenados de forma secuencial por clave primaria. Por ejemplo, el primer valor de la primera hoja bloque muestra un ID de departamento de 20, el nombre del departamento de Marketing, ID gerente del 201, y la localización de la identificación de 1800.

Una tabla de índice-organizada almacena todos los datos en la misma estructura y no es necesario para almacenar el ROWID. Como se muestra en la Figura 3-3, el bloque de la hoja 1 en una tabla organizada por índices puede contener, como sigue, ordenados por clave principal:

 

20,Marketing,201,1800

30,Purchasing,114,1700

 

Bloque 2 de la hoja en una tabla organizada por índices puede contener las entradas de la siguiente manera:

 

50,Shipping,121,1500

60,IT,103,1400

 

Una exploración de las filas de la tabla organizada por índices, a fin de clave principal lee los bloques en el orden siguiente:
1. Bloque 1
2. Bloque 2
Para acceso a los datos de contraste en una tabla de montón organizada en una tabla organizada por índices, supongamos que el bloque 1 de un segmento de la tabla departamentos montón organizado contiene filas de la siguiente manera:

 

50,Shipping,121,1500

20,Marketing,201,1800

 

Bloque 2 contiene las filas de la misma tabla de la siguiente manera:

 

30,Purchasing,114,1700

60,IT,103,1400

 

Un bloque de hoja de índice B-tree para esta tabla de montón organizado contiene las entradas siguientes, en donde el primer valor es la clave principal y la segunda es el ROWID:

20,AAAPeXAAFAAAAAyAAD

30,AAAPeXAAFAAAAAyAAA

50,AAAPeXAAFAAAAAyAAC

60,AAAPeXAAFAAAAAyAAB

 

Una exploración de las filas de la tabla con el fin de clave principal lee los bloques de segmentos de la tabla en la siguiente secuencia:

1. Bloque 1
2. Bloque 2
3. Bloque 1
4. Bloque 2


Por lo tanto, el número de bloque de E / S en este ejemplo es el doble del número de índice en el ejemplo-organizada.


Tablas de índice organizadas con Row Area Overflow


Cuando se crea una tabla organizada por índices, puede especificar un segmento separado como un área de desbordamiento fila. En las tablas de índice organizadas, las entradas del índice B-tree pueden ser grandes, ya que contienen una fila completa, por lo que un segmento aparte de contener las entradas es útil. Por el contrario, las entradas B-árboles son generalmente pequeñas, ya que consisten en la llave y ROWID.

Si se especifica un área de desbordamiento de fila, a continuación, la base de datos se puede dividir una fila en una tabla organizada por índices de lo siguiente:

• La entrada de índice

Esta parte contiene los valores de columna de todas las columnas de clave principal, una RowId físico que apunta a la parte desbordamiento de la fila y, opcionalmente, algunas de las columnas sin clave. Esta parte se almacena en el segmento de índice.

• La parte de desbordamiento

Esta parte contiene los valores de columna de las columnas sin clave restantes. Esta parte se almacena en el segmento de área de almacenamiento de desbordamiento.


Índices secundarios en las tablas de índice organizadas


Un índice secundario es un índice en una tabla organizada por índices. En cierto sentido, es un índice en un índice. El índice secundario es un objeto de esquema independiente y se almacena por separado de la tabla organizada por índices.

Como se explica en "Tipos de datos ROWID", Oracle Database utiliza identificadores de fila llamados ROWIDs lógicas para las tablas de índice organizadas. Un ROWID lógico es una representación codificada en base 64 de la clave primaria de tabla. La longitud ROWID lógico depende de la longitud de la clave primaria.

Las filas de bloques hoja de índice se pueden mover dentro o entre los bloques debido a inserciones. Las filas de las tablas de índice organizadas no migran como filas montón organizados hacen (véase "Las filas encadenadas y migradas"). Dado que las filas de las tablas de índice organizadas no tienen direcciones físicas permanentes, la base de datos utiliza ROWIDs lógicas basadas en la clave principal.

Por ejemplo, supongamos que la tabla de departamentos es organizada por índices. La columna location_id almacena el ID de cada departamento. La tabla almacena las filas de la siguiente manera, con el último valor que el ID de la población:

 

10,Administration,200,1700

20,Marketing,201,1800

30,Purchasing,114,1700

40,Human Resources,203,2400

 

Un índice secundario en la columna location_id podría tener entradas de índice de la siguiente manera, donde el valor después de la coma es el ROWID lógico:

 

1700,*BAFAJqoCwR/+

1700,*BAFAJqoCwQv+

1800,*BAFAJqoCwRX+

2400,*BAFAJqoCwSn+

 

Los índices secundarios proporcionan acceso rápido y eficiente a las tablas de índice organizadas con columnas que no son ni la clave principal ni un prefijo de la clave primaria. Por ejemplo, una consulta de los nombres de los departamentos cuyo identificador es mayor que 1700 podrían usar el índice secundario para acelerar el acceso de datos.

 

ROWIDs conjeturas lógicas y físicas

Los índices secundarios utilizan las ROWIDs lógicas para localizar filas de la tabla. Un ROWID lógico incluye una conjetura física, que es el ROWID física de la entrada de índice cuando se hizo por primera vez. Oracle Database puede utilizar las sugerencias físicas para investigar directamente en el bloque de la hoja de la tabla organizada por índices, sin pasar por la búsqueda de la clave principal. Cuando la ubicación física de una fila cambia, el ROWID lógica sigue siendo válido incluso si contiene una conjetura física que es rancio.

Para una tabla de montón organizado, el acceso de un índice secundario consiste en un análisis del índice secundario y un adicional de I / O para buscar el bloque de datos que contiene la fila. Para las tablas de índice-organizados, el acceso de un índice secundario varía, dependiendo del uso y la exactitud de conjeturas físicas:

• Sin conjeturas físicas, el acceso implica dos exploraciones de índices: un análisis del índice secundario seguido de un análisis del índice de clave primaria.

• Con conjeturas físicas, el acceso depende de la precisión:

o Con conjeturas físicas precisas, acceso implica una exploración de índice secundario y un adicional de I / O para ir a buscar el bloque de datos que contiene la fila.

o Con conjeturas físicas imprecisas, acceso implica una exploración de índice secundario y un I / O para ir a buscar el bloque de datos incorrecto (según lo indicado por la conjetura), seguida de una exploración de índice único de la tabla de índice organizado por el valor de la clave primaria.

Índices de mapas de bits de las tablas de índice organizadas

Un índice secundario en una tabla organizada por índices puede ser un índice de mapa de bits. Como se explica en "Indicadores de mapa de bits", un índice de mapa de bits almacena un mapa de bits para cada clave de índice.

Cuando existen índices de mapa de bits en una mesa organizada por índices, todos los índices de mapa de bits utilizan una tabla de asignación de almacenamiento dinámico organizado. La tabla de asignación almacena los ROWIDs lógicas de la tabla organizada por índices. Cada fila de la tabla de asignación almacena un ROWID lógico para la fila de tabla organizada por índices correspondientes.

La base de datos tiene acceso a un índice de mapa de bits utilizando una clave de búsqueda. Si la base de datos se encuentra la clave, a continuación, la entrada de mapa de bits se convierte en un ROWID física. Con mesas montón organizados, la base de datos utiliza el ROWID física para acceder a la tabla base. Con las tablas de índice-organizados, la base de datos utiliza el ROWID física para acceder a la tabla de asignación, que a su vez produce un ROWID lógico que la base de datos utiliza para acceder a la tabla de índice-organizada.
Nota:

Movimiento de filas en una tabla organizada por índices no deja los índices bitmap construidas sobre la mesa organizada por índices inutilizable.


Indices BTREE
Muchas veces, usamos los índices de acuerdo a las búsquedas que se están haciendo delimitando la información por la parte Where de una consulta. Sin embargo, no sabemos cómo es que se usa o cómo es que funciona dicho índice por dentro. Aquí una breve, resumida pero nutritiva explicación al respecto. Espero les guste.
Ok, vamos a pensar que tenemos varios números para alimentar una estructura. Los números son:
7 4 12 10 3 1 5

Búsqueda en un arreglo (tabla)

Al meter los números mencionados en un arreglo ordenado, quedarían como sigue:
Ahora, para buscar un número en dicho arreglo, no tenemos otra que compararlo contra cada uno de los elementos del mismo. Para encontrar un elemento de esta forma, se tiene que si el arreglo tiene n elementos, entonces, por promedio demoraremos n/2 comparaciones en encontrar el número que buscamos.
Así, en nuestro arreglo, tardaremos 3.5 comparaciones en promedio en encontrar cualquier número. Es decir, podríamos demorar una comparación si buscamos el 1 y 7 comparaciones si buscamos el 12.
Este arreglo nos simula una búsqueda de tipo FULL TABLE ACCESS en una tabla que NO tiene índices o cuya búsqueda se hace por un campo de una tabla que no está indexado.
Ok, entonces, ¿de qué forma podemos realizar una búsqueda más rápida?
Búsqueda en un árbol binario
¿Qué pasa si como van llegando nuestros números de prueba, los metemos en un árbol binario?
Hay que recordar que conforme lleguen los elementos, se pone el de valor intermedio en el nodo raíz y de ahí, los elementos mayores a ese nodo, se colocan a la derecha y los elementos menores, se colocan a la izquierda. Si es necesario, se balancea el árbol para que quede con las hojas repartidas equitativamente. Así, obtenemos un árbol como el que sigue:
Para realizar una búsqueda en este árbol se realizará mucho más rápido que en nuestro ejemplo anterior. Por ejemplo, para buscar el número 1, tendremos que hacer 3 comparaciones para encontrarlo, primero contra 5, después contra el 3 y finalmente contra el 1.
Después de comparar el número a buscar contra cada nodo, se sabrá para dónde ir: a la izquierda si es menor al nodo o a la derecha si es mayor al nodo.
Si buscamos el número 12, también se realizan 3 comparaciones: primero contra el 5, después contra 10 y al final, contra el mismo 12. Como se puede ver, se agiliza la búsqueda.
Pero, otra vez, ¿qué será más rápido?

Búsqueda en un árbol B-Tree (B* o B+)

Para responder a la última pregunta del punto anterior, tenemos que recurrir a los árboles B-Tree o B+ como se puede encontrar referencia a ellos. Prácticamente todos los índices de los RBDMS más famosos y comunes, entre ellos Oracle; se basan en este tipo de árboles. La tecnología detrás de estos árboles no es parte de este post; pero si, una explicación general
¿Cómo es un árbol de este tipo? En la siguiente imagen, vemos un ejemplo del mismo:
Es muy similar a un árbol binario. Sólo que cada uno de los nodos es un arreglo de n elementos. Y de cada elemento de dicho arreglo, se deriva un nuevo nodo hijo con los mismos n elementos. En RDBMS como Oracle, Informix, DB2; n vale 128.
Nota. Hay que recordar que hablando ya de índices, cada uno de los elementos de cada nodo será un registro.
De este forma en el 1er nivel del árbol podemos guardar:
128 elementos o registros
En el 2o nivel, tendremos 128 x 128 registros, es decir:
16,384 registros
En el 3er nivel, tendremos 128 x 128 x 128, es decir:
2’097,152 registros
En total, en un árbol con 3 niveles, tendremos capacidad para guardar:
2’113,664 elementos o registros
Ahora, ¿cuánto nos tardamos en encontrar un elemento en un árbol de estas dimensiones? Supongamos que nuestro elemento se encuentra en el nivel más bajo de este árbol.
Para encontrar nuestro registro, comparamos contra los elementos en el nodo raíz. Si recordamos nuestra comparación en arreglos, tardaremos n/2 comparaciones en saber cuál es el nodo hijo al que tendremos que ir. Basado en el tamaño de n, sabremos que en promedio, tardaremos 64 comparaciones en cada nodo.
Bajo nuestro supuesto de que el registro que buscamos está hasta el 3er nivel, tendremos en total 64 comparaciones x 3 nodos. Es decir:
¡ 192 comparaciones para encontrar un registro en una tabla de 2’113,664 registros !
¡Imaginen! si agregamos un nivel más de elementos, será un índice de 270’549,120 registros y para encontrar un registro, nos demorará ¡sólo 256 comparaciones!