mejoras en expresiones regulares 11gr2

Servicio de Base de Datos

Mejoras en expresiones regulares de las funciones integradas de SQLElREGEXP_INSTRyREGEXP_SUBSTRfunciones incluyen un nuevoSUBEXPRparmetro que limita la coincidencia de patrn para una subexpresin especfico en el patrn de bsqueda. SQL> SELECT REGEXP_INSTR ('1234567890 ',' (123) (4 (56) (78)), 1, 1, 0, 'i', 1) de la doble;

REGEXP_INSTR ('1234567890 ',' (123) (4 (56) (78)) ', 1,1,0,' I ', 1) -------------------------------------------------- ------- 1

Una fila seleccionada.

SQL> SELECT REGEXP_INSTR ('1234567890 ',' (123) (4 (56) (78)), 1, 1, 0, 'i', 3) de la doble;

REGEXP_INSTR ('1234567890 ',' (123) (4 (56) (78)) ', 1,1,0,' I ', 3) -------------------------------------------------- ------- 5


SQL> SELECT REGEXP_SUBSTR ('1234567890 ',' (123) (4 (56) (78)), 1, 1, 'i', 0) de la doble;

REGEXP_S -------- 12345678



REG --- 123



RE - 56


SQL> El nuevoREGEXP_COUNTfuncin devuelve el nmero de veces que el patrn de bsqueda aparece en cadena de origen.SQL> SELECT REGEXP_COUNT ('123 123 123 123 ', '123', 1, 'i') de la doble;

REGEXP_COUNT ('123123123123 ', '123', una 'I') ---------------------------------------- 4


SQL> SELECT REGEXP_COUNT ('123 123 123 123 ', '123', 9 'i') de la doble;

REGEXP_COUNT ('123123123123 ', '123', 9 'I') ---------------------------------------- 2


SQL> SIMPLE_INTEGER tipo de datosElSIMPLE_INTEGERtipo de datos es un subtipo de laPLS_INTEGERtipo de datos y puede aumentar drsticamente la velocidad de la aritmtica de enteros en el cdigo nativo compilado, pero slo muestra las mejoras de rendimiento marginal en cdigo interpretado.El procedimiento siguiente se compara el rendimiento de laSIMPLE_INTEGERyPLS_INTEGERtipos de datos.CREAR O CAMBIAR simple_integer_test_proc PROCEDIMIENTO AS l_start nmero; NMERO l_loops: = 10000000; l_pls_integer PLS_INTEGER: = 0; l_pls_integer_incr PLS_INTEGER: = 1; l_simple_integer SIMPLE_INTEGER: = 0; l_simple_integer_incr SIMPLE_INTEGER: = 1; INICIO

l_start: DBMS_UTILITY.get_time =;

For i in 1 .. l_loops LOOP l_pls_integer: = + l_pls_integer l_pls_integer_incr; END LOOP;

DBMS_OUTPUT.PUT_LINE ("PLS_INTEGER: '| | (DBMS_UTILITY.get_time - l_start) | |' hsecs ');


For i in 1 .. l_loops LOOP l_simple_integer: = + l_simple_integer l_simple_integer_incr; END LOOP;

DBMS_OUTPUT.PUT_LINE ("SIMPLE_INTEGER: '| | (DBMS_UTILITY.get_time - l_start) | |' hsecs ');

END simple_integer_test_proc; / Cuando se ejecuta en el modo por defecto interpreta la mejora del rendimiento de laSIMPLE_INTEGERtipo de datos no es espectacular.SQL> JUEGO DE serveroutput SQL> EXEC simple_integer_test_proc; PLS_INTEGER: 47 hsecs SIMPLE_INTEGER: 44 hsecs

PL / SQL terminado con xito.

SQL> Nos nativa compilar el procedimiento mediante la alteracin de laPLSQL_CODE_TYPEvalor de la sesin y volver a compilar el procedimiento.ALTER SET SESSION PLSQL_CODE_TYPE = Nativo; ALTER PROCEDIMIENTO COMPILAR simple_integer_test_proc; Compilar de forma nativa el procedimiento produce importantes mejoras de velocidad para ambos tipos de datos, pero ms an para elSIMPLE_INTEGERtipo de datos.SQL> JUEGO DE serveroutput SQL> EXEC simple_integer_test_proc; PLS_INTEGER: 10 hsecs SIMPLE_INTEGER: 2 hsecs


SQL> Las mejoras de velocidad son el resultado de dos diferencias fundamentales entre los dos tipos de datos.En primer lugar,SIMPLE_INTEGERyPLS_INTEGERtienen el mismo rango (-2.147.483.648 a 2.147.483.647), peroSIMPLE_INTEGERarropa cuando se excede de sus lmites, en lugar de tirar un error comoPLS_INTEGER.JUEGO DE serveroutput DECLARE l_simple_integer SIMPLE_INTEGER: = 2147483645; INICIO For i in 1 .. 4 LOOP l_simple_integer: = l_simple_integer + 1; DBMS_OUTPUT.PUT_LINE (to_char (l_simple_integer, 'S9999999999')); END LOOP;

For i in 1 .. 4 LOOP l_simple_integer: = l_simple_integer - 1; DBMS_OUTPUT.PUT_LINE (to_char (l_simple_integer, 'S9999999999')); END LOOP; END; / +2147483646 +2147483647 -2147483648 -2147483647 -2147483648 +2147483647 +2147483646 +2147483645


SQL> En segundo lugar,SIMPLE_INTEGERnunca puede tener un valor NULL, ya sea cuando se declara, o por la cesin.DECLARE l_simple_integer SIMPLE_INTEGER; INICIO NULL; END; / * ERROR en lnea 2: ORA-06550: lnea 2, columna 20: PLS-00218: una variable declarada como NOT NULL deben tener una asignacin de inicializacin

SQL>

DECLARE l_simple_integer SIMPLE_INTEGER: = 0; INICIO l_simple_integer: = NULL; END; / * ERROR en la lnea 4: ORA-06550: lnea 4, columna 23: PLS-00382: la expresin es de tipo incorrecto ORA-06550: lnea 4, columna 3: PL / SQL: Instruccin omite

SQL> La eliminacin de desbordamiento y el resultado NULL comprobacin en una reduccin significativa en los gastos generales en comparacin conPLS_INTEGER.CONTINUAR DeclaracinElCONTINUEsaltos declaracin de la iteracin de bucle de corriente y empieza el siguiente.Se puede utilizar por s mismo, o como parte de unCONTINUE WHENla declaracin, como se muestra a continuacin.JUEGO DE serveroutput DECLARE NMERO l_number: = 0; INICIO For i in 1 .. 100 LOOP Continuar cuando MOD (i, 2) = 0;

- Hacer algo aqu! l_number: = l_number + 1; END LOOP;

DBMS_OUTPUT.PUT_LINE ("continuar cuando: '| | l_number);

l_number: = 0;

For i in 1 .. 100 LOOP SI MOD (i, 2) = 0 THEN CONTINUE; END IF;

- Hacer algo aqu! l_number: = l_number + 1; END LOOP;

DBMS_OUTPUT.PUT_LINE ("SI .. CONTINUAR: '| | l_number); END; / Continuar cuando: 50 SI .. CONTINUAR: 50


SQL> Este tipo de proceso siempre ha sido posible utilizandoIFdeclaraciones ya sea por su propia cuenta o con las excepciones oGOTOdeclaraciones, pero laCONTINUEdeclaracin es ms claro y trae PL / SQL en lnea con langauges otros.Los siguientes ejemplos muestran el tipo de cdigo necesario para realizar la misma tarea antes de laCONTINUEsentencia se aadi a PL / SQL.JUEGO DE serveroutput DECLARE ex_continue excepcin; NMERO l_number: = 0; INICIO For i in 1 .. 100 LOOP INICIO SI MOD (i, 2)! = 0 THEN RAISE ex_continue; END IF;

- Hacer algo aqu! l_number: = l_number + 1; EXCEPCIN CUANDO ENTONCES ex_continue NULL; END; END LOOP;

DBMS_OUTPUT.PUT_LINE ("Excepcin: '| | l_number);

l_number: = 0;

For i in 1 .. 100 LOOP SI MOD (i, 2)! = 0 THEN

- Hacer algo aqu! l_number: = l_number + 1;

END IF; END LOOP;

DBMS_OUTPUT.PUT_LINE ("SI: '| | l_number);

l_number: = 0;

For i in 1 .. 100 LOOP SI MOD (i, 2) = 0 THEN GOTO label_continue; END IF;

- Hacer algo aqu! l_number: = l_number + 1;

NULL; END LOOP;

DBMS_OUTPUT.PUT_LINE ("GOTO: '| | l_number); END; / EXCEPCIN: 50 SI: 50 GOTO: 50


SQL> Secuencias en PL / SQL ExpresionesElNEXTVALyCURRVALpseudocolumnas secuencia de ahora se puede acceder en expresiones PL / SQL, as como consultas.Esto hace que el cdigo de aspecto sencillo, y la documentacin sugiere que mejora el rendimiento.El siguiente ejemplo se compara la velocidad de los mtodos nuevos y originales de acceder a estos valores de secuencia.CREAR inicio de la secuencia test1_seq CON 1.000.000;

JUEGO DE serveroutput DECLARE l_start nmero; NMERO l_loops: = 100000; l_value nmero; INICIO


For i in 1 .. l_loops LOOP SELECCIONAR test1_seq.NEXTVAL EN l_value De la doble; END LOOP;

DBMS_OUTPUT.PUT_LINE ("NEXTVAL SELECT = '| | (DBMS_UTILITY.get_time - l_start) | |' hsecs ');


For i in 1 .. l_loops LOOP l_value: = test1_seq.NEXTVAL; END LOOP;

DBMS_OUTPUT.PUT_LINE ("expresin NEXTVAL = '| | (DBMS_UTILITY.get_time - l_start) | |' hsecs ');


For i in 1 .. l_loops LOOP SELECCIONAR test1_seq.CURRVAL EN l_value De la doble; END LOOP;

DBMS_OUTPUT.PUT_LINE ("CURRVAL SELECT = '| | (DBMS_UTILITY.get_time - l_start) | |' hsecs ');


For i in 1 .. l_loops LOOP l_value: = test1_seq.CURRVAL; END LOOP;

DBMS_OUTPUT.PUT_LINE ("Expresin CURRVAL = '| | (DBMS_UTILITY.get_time - l_start) | |' hsecs ');

END; / NEXTVAL SELECT = 2196 hsecs Expresin NEXTVAL = 2203 hsecs CURRVAL SELECT = 1007 hsecs Expresin CURRVAL = 1003 hsecs


SQL> Se puede ver que en cuanto al tiempo transcurrido se refiere, hay poca diferencia entre los dos mtodos.

Mejoras en el SQL dinmicoNativas SQL dinmico y el paquete DBMS_SQL ahora soportan sentencias de SQL dinmico de ms de 32 KB.ElEXECUTE IMMEDIATEdeclaracin,ABIERTA PARAdeclaracin yDBMS_SQL.PARSEprocedimiento aceptar todas las sentencias SQL en la forma de CLOB.

ElDBMS_SQL.TO_REFCURSORfuncin convierte un cursor ID DBMS_SQL en un REF CURSOR.JUEGO DE serveroutput DECLARE l_cursor nmero; l_return nmero;

l_ref_cursor SYS_REFCURSOR; TIPO ES t_emp_tab TABLA DE ROWTYPE% emp; l_emp_tab t_emp_tab; INICIO l_cursor: DBMS_SQL.open_cursor =;

DBMS_SQL.parse (l_cursor, 'SELECT * FROM emp ", DBMS_SQL.NATIVE);

l_return: DBMS_SQL.EXECUTE = (l_cursor);

- Connvert de DBMS_SQL a un REF CURSOR. l_ref_cursor: DBMS_SQL.to_refcursor = (l_cursor); FETCH GRANEL l_ref_cursor reunir en l_emp_tab;

DBMS_OUTPUT.PUT_LINE ("nmero de empleados: '| | l_emp_tab.count);

L_ref_cursor cerca; END; / Nmero de empleados: 14


SQL> ElDBMS_SQL.TO_CURSOR_NUMBERfuncin convierte un REF CURSOR en un cursor DBMS_SQL ID.JUEGO DE serveroutput DECLARE l_ref_cursor SYS_REFCURSOR;

l_cursor nmero; NMERO l_count: = 0; INICIO L_ref_cursor ABIERTO "SELECT * FROM emp;

l_cursor: DBMS_SQL.to_cursor_number = (l_ref_cursor);

MIENTRAS DBMS_SQL.fetch_rows (l_cursor)> 0 LOOP l_count: = l_count + 1; END LOOP;

DBMS_OUTPUT.PUT_LINE ("nmero de empleados: '| | l_count);

DBMS_SQL.close_cursor (l_cursor); END; / Nmero de empleados: 14


SQL> Adems, el paquete DBMS_SQL ahora soporta todos los tipos de datos con el apoyo de SQL dinmico nativo.

Generalizada InvocacinGeneralizada invocacin permite un subtipo para invocar un mtodo de un tipo primario (supertipo) con la siguiente sintaxis.(AUTO COMO supertype_name). Method_name El siguiente ejemplo muestra esto en accin.

En primer lugar, crear un tipo con algunos atributos y una funcin miembro.CREAR O CAMBIAR TIPO my_type como objeto ( nmero de identificacin, Descripcin VARCHAR2 (50), Show_attributes funciones miembro RETORNO VARCHAR2) NO FINAL; /

CREAR O CAMBIAR my_type tipo de cuerpo como

Show_attributes funciones miembro RETORNO VARCHAR2 IS INICIO RETURN 'id =' | | Identificacin | | 'descripcin =' | | descripcin; END;

END; / A continuacin, crear un subtipo de este objeto, lo que aade un nuevo atributo y mtodo, as como anular lashow_attributesfuncin miembro.CREAR O CAMBIAR my_subtype tipo bajo my_type ( short_desc VARCHAR2 (10), ABSOLUTA show_attributes funcin miembro RETORNO VARCHAR2, Show_parent_attributes funciones miembro RETORNO VARCHAR2); /

CREAR O CAMBIAR my_subtype tipo de cuerpo como

ABSOLUTA show_attributes miembro de devolucin de funciones VARCHAR2 IS INICIO RETURN (yo como my_type) show_attributes | | 'short_desc =' | | short_desc.; END;

Show_parent_attributes funciones miembro RETORNO VARCHAR2 IS INICIO RETURN (yo como my_type) show_attributes.; END;

END; / Observe el mtodo del tipo de padres que se accede utilizando la sintaxis de invocacin generalizada.El cdigo siguiente crea un subtipo, y llama a sus funciones miembro.JUEGO DE serveroutput DECLARE my_subtype l_subtype: = my_subtype (1, 'Descripcin extensa para el 1', 'S descripcin 1'); INICIO DBMS_OUTPUT.PUT_LINE ("show_attributes = '| | l_subtype.show_attributes); DBMS_OUTPUT.PUT_LINE ("show_parent_attributes = '| | l_subtype.show_parent_attributes); END; / show_attributes = id = 1 Descripcin descripcin = largo por 1 short_desc Desc = S 1 show_parent_attributes = id = 1 = Descripcin detallada descripcin de un


SQL> Un tipo se puede invocar a las funciones de miembro de cualquier tipo primario de esta manera, independientemente de la profundidad de la herencia.

La notacin con nombre y mixtos en las invocaciones del Subprograma PL / SQLAntes de 11g, PL / SQL invoca desde SQL tena que tener sus parmetros pasados usando la notacin posicional, lo que hace difcil determinar el significado de los parmetros.Oracle 11g permite la notacin posicional, el nombre y la mezcla que se utiliza cuando se llama PL / SQL de SQL, como se muestra a continuacin.- Construir una funcin de prueba con mltiples parmetros. CREAR O CAMBIAR test_func FUNCIN (p_value_1 EN INCUMPLIMIENTO nmero 0, p_value_2 EN nmero predeterminado 0) Devuelve el nmero AS INICIO RETORNO p_value_1 + p_value_2; END test_func; /

Funcin creada.

SQL> - la notacin posicional. SQL> SELECT test_func (10, 20) de la doble;

TEST_FUNC (10,20) ---------------- 30


SQL> - notacin mixta. SQL> SELECT test_func (10, p_value_2 => 20) de la doble;

TEST_FUNC (10, P_VALUE_2 => 20) --------------------------- 30


SQL> - nombre de notacin. SQL> SELECT test_func (p_value_1 => 10, p_value_2 => 20) de la doble;

TEST_FUNC (P_VALUE_1 => 10, P_VALUE_2 => 20) -------------------------------------- 30


SQL> Subprograma automtica InliningCada llamada a un procedimiento o funcin produce una leve, pero medible, sobrecarga en el rendimiento, lo que es especialmente notable cuando el subprograma se llama dentro de un bucle.Evitar procedimientos y funciones no es una opcin, ya que va contra el concepto de programacin modular, por lo que los programas de voluminosos y difciles de manejar.Inline subprograma automtica puede reducir los gastos generales asociados con los subprogramas de llamada, dejando a su cdigo fuente original en su estado modular normal.Esto se hace mediante la sustitucin de las llamadas de subprograma con una copia del cdigo en el subprograma en tiempo de compilacin.

El proceso de inclusin entre lneas subprograma es controlada por elPLSQL_OPTIMIZE_LEVELparmetro y elINLINEpragma.CuandoPLSQL_OPTIMIZE_LEVEL=2(por defecto), elINLINEpragma determina si la siguiente declaracin o una declaracin debe ser entre lneas o no.CuandoPLSQL_OPTIMIZE_LEVEL=3, el optimizador de cdigo en lnea de forma automtica.En este caso elINLINEpragma se puede desactivar procesos en lnea para una declaracin, o aumentar la probabilidad de que el optimizador elegir a una declaracin en lnea.La relacin es ms fcil de entender cuando vea el siguiente ejemplo.

Estas pruebas utilizan un bloque annimo con una funcin definida en el bloque de declaraciones.La funcin se llama repetidamente en un bucle.Los ajustes paraPLSQL_OPTIMIZE_LEVELy elINLINEpragma son alterados para cambiar subprograma procesos en lnea y fuera.En primer lugar, nos aseguramos dePLSQL_OPTIMIZE_LEVEL=2y ejecutar el cdigo sinINLINEconjunto pragma.Con estos ajustes, no podemos esperar para ver subprograma inline llevando a cabo.ALTER SET SESSION PLSQL_OPTIMIZE_LEVEL = 2;

JUEGO DE serveroutput DECLARE NMERO l_loops: = 10000000; l_start nmero; l_return nmero;

Add_numbers FUNCIN (p_1 en nmero, p_2 en nmero) Devuelve el nmero AS INICIO RETORNO p_1 + p_2; Add_numbers END;

INICIO l_start: DBMS_UTILITY.get_time =;

For i in 1 .. l_loops LOOP - PRAGMA en lnea (add_numbers, 'YES'); l_return: = add_numbers (1, i); END LOOP;

DBMS_OUTPUT.PUT_LINE ("Tiempo transcurrido: '| | (DBMS_UTILITY.get_time - l_start) | |' hsecs '); END; / Tiempo transcurrido: 509 hsecs


SQL> Esto se traduce en un lapso de tiempo de 509 hsecs.

A continuacin, mantenga la configuracin de la optimizacin de lo mismo, pero incluyen laINLINEpragma con un ajuste de "S" para las llamadas a laADD_NUMBERSfuncin.Ahora se espera subprograma procesos en lnea para tomar su lugar.ALTER SET SESSION PLSQL_OPTIMIZE_LEVEL = 2;




For i in 1 .. l_loops LOOP PRAGMA en lnea (add_numbers, 'YES'); l_return: = add_numbers (1, i); END LOOP;



SQL> Esto le da un tiempo transcurrido de 245 HSEC, que es aproximadamente la mitad de la prueba anterior, lo que implica que inline subprograma est llevando a cabo.

A continuacin, asegrese de quePLSQL_OPTIMIZE_LEVEL=3y ejecutar el cdigo sinINLINEconjunto pragma.Ahora se espera que el optimizador elija implcitamente a la lneaADD_NUMBERSllamada.ALTER SET SESSION PLSQL_OPTIMIZE_LEVEL = 3;




For i in 1 .. l_loops LOOP - PRAGMA en lnea (add_numbers, 'YES'); l_return: = add_numbers (1, i); END LOOP;



SQL> Esto le da un tiempo transcurrido de 245 HSEC, lo que implica que inline subprograma est an en marcha.

Por ltimo, nos aseguramos dePLSQL_OPTIMIZE_LEVEL=3y ejecutar el cdigo con unINLINEpragma en "NO".Es de esperar que no haya procesos en lnea de laADD_NUMBERSllame ahora.ALTER SET SESSION PLSQL_OPTIMIZE_LEVEL = 3;




For i in 1 .. l_loops LOOP PRAGMA en lnea (add_numbers, 'NO'); l_return: = add_numbers (1, i); END LOOP;



SQL> Esto le da un tiempo transcurrido de 500 hsecs, lo que implica que inline no se llev a cabo como se esperaba.

ElINLINEpragma slo afecta a los siguientes tipos de declaraciones. Asignacin Llamar Condicional CASE CONTINUE-WHEN EXECUTE IMMEDIATE EXIT-WHEN LOOP RETURNEn todos los casos, afecta a cada llamada a subprograma especificada de la declaracin.

El optimizador puede optar por ignorar unaINLINEpragma configuracin del "SI" si cree inline no es deseable, sino un ajuste de "NO" siempre evitar procesos en lnea.

El compilador inlines subprogramas temprano en el proceso de optimizacin, que puede prevenir ms tarde, las optimizaciones ms poderosa que tienen lugar.Como resultado, el rendimiento casi siempre mejora con la inclusin entre lneas, pero en algunos casos puede no ser eficaz.

PL / mbito de aplicacinPL / Scope es una herramienta que recoge informacin acerca de los identificadores definidos por el usuario en tiempo de compilacin.La recopilacin de datos PL / mbito de aplicacin es controlada por elPLSCOPE_SETTINGSparmetro, que tiene un valor predeterminado de "IDENTIFIERS:NONE".Cambiar este valor a "IDENTIFIERS:ALL"para permitir la recopilacin.SQL> ALTER SESIN "IDENTIFICADORES: ALL 'PLSCOPE_SETTINGS =;

Sesin alterado.

SQL> La recoleccin de datos se realiza para todos los objetos compilados despus de la bandera es definida, por lo que ahora debe crear un objeto de reunir algunos datos.CREAR O CAMBIAR test_plscope PROCEDIMIENTO (p_in EN nmero) l_var nmero; INICIO l_var: = p_in; l_var: = l_var + 1; END; / Los datos se almacenan en el espacio de tablas SYSAUX, por lo que el espacio actual utilizado para PL / mbito de datos se pueden visualizar con la siguiente consulta.SELECCIONAR space_usage_kbytes DESDE $ v sysaux_occupants DONDE occupant_name = 'PL / SCOPE;

SPACE_USAGE_KBYTES ------------------ 384


SQL> Los datos de PL / mbito de aplicacin est disponible en el_IDENTIFIERS%puntos de vista.La consulta siguiente muestra los datos recopilados durante la elaboracin deltest_plscopeprocedimiento.COLUMNA FORMATO nombre A30 SELECCIONAR LPAD ('', nivel * 2, '') | | nombre como nombre, tipo, uso, usage_id, lnea, columna DE user_identifiers EMPIECE CON usage_context_id = 0 ANTES DE CONECTAR POR usage_id = usage_context_id;

NOMBRE TIPO DE USO USAGE_ID LNEA DE COL ------------------------------ ------------------ - --------- ---------- ---------- ---------- TEST_PLSCOPE Declaracin de procedimiento 1 1 11 TEST_PLSCOPE procedimiento de definicin 2 1 11 FORMAL EN LA DECLARACIN P_IN 3 1 25 L_VAR de declaracin de variables 4 2 3 L_VAR variable de asignacin 5 4 3 FORMAL EN REFERENCIA P_IN 6 4 12 L_VAR variable de asignacin 7 6 3 L_VAR variable de referencia de 8 6 12

8 filas seleccionadas.

SQL> Lo ms probable es que la mayora de los usuarios ver los datos de PL / mbito de aplicacin a travs de un IDE PL / SQL, como SQL Developer.

La documentacin indica que algunos identificadores no inscrito, salvo que elSTANDARDpaquete se vuelve a compilar despus de laPLSCOPE_SETTINGSparmetro se establece de la siguiente manera.Esto se traduce en ms de 7.000 objetos no vlidos, la mayora de los cuales no se vuelva a compilar, incluso cuando se utiliza el guin urlrp.sql.No recomiendo este mtodo si desea que una instancia de trabajo.

PL / SQL compilador nativo genera cdigo nativo directamenteLa compilacin nativa de cdigo PL / SQL, como es posible desde Oracle 9i.Ver: PL / SQL compilacin nativa (9i) PL / SQL Mejoras de compilacin nativa (10g)En estas versiones de la base de datos, el cdigo PL / SQL se convierte en cdigo C, compilar y ejecutar los procedimientos externos.Compilados de forma nativa utilizando PL / SQL es necesario un compilador de C en el servidor y la intervencin del DBA.Adems, con compilados de forma nativa PL / SQL en un entorno RAC puede ser problemtico.

En Oracle 11g, PL / SQL compilacin como nativo no requiere compilador de C, sin intervencin del DBA y es totalmente compatible en un entorno RAC.Al establecer laPLSQL_CODE_TYPEa un valor deNATIVE, ms que el valor predeterminado deINTERPRETED, el cdigo es compilado en cdigo mquina y se almacena en el tablespace SYSTEM.Cuando el cdigo se llama, se carga en la memoria compartida, por lo que es accesible para todas las sesiones de esa instancia.El%_PLSQL_OBJECT_SETTINGSvistas incluyen la corrientePLSQL_CODE_TYPEajuste para cada objeto de PL / SQL.

Recuerde, la compilacin nativa mejorar la velocidad de cdigo de procedimiento, pero no tiene efecto sobre el rendimiento de SQL.Cuando el cdigo lleva a cabo muchas operaciones matemticas, como elSIMPLE_INTEGERejemplo, la compilacin nativa puede producir considerables mejoras de rendimiento.Si el cdigo es predominantemente realizar SQL, poca mejora se notar.

Al igual que con versiones anteriores de base de datos, es posible compilar de forma nativa todo el cdigo PL / SQL en la base de datos, siempre y cuando siga elprocedimiento de apoyo.

Nueva PL / SQL Advertencia del compiladorUn nuevo PL / SQL advertencia del compilador ha sido aadido a identificarWHEN OTHERSmanejadores de excepciones que no hacen re-raise errores usandoRAISEoRAISE_APPLICATION_ERROR.Manipuladores de tal excepcin a menudo puede ocultar los fracasos de cdigo que generan difcil de identificar los errores.El siguiente ejemplo muestra la advertencia del compilador espera que cuando elPLSQL_WARNINGSbandera est activa.SQL> ALTER SESIN plsql_warnings = SET "permite: todos;

Sesin alterado.

SQL> CREATE OR REPLACE others_test PROCEDIMIENTO AS 2 EMPEZAR 3 RAISE_APPLICATION_ERROR (-20000, 'Fuerza y de excepcin'); 4 EXCEPCIN 5 CUANDO OTROS ENTONCES 6 NULL; 7 END; 8 /

SP2-0804: Procedimiento creado con advertencias de compilacin

SQL> SHOW ERRORES Los errores de OTHERS_TEST PROCEDIMIENTO:

Line / Error COL -------- ------------------------------------------ ----------------------- 5.8 PLW-06009: Procedimiento "OTHERS_TEST" manejador de los dems no terminan en Suba o RAISE_APPLICATION_ERROR

SQL> Esto es slo un mensaje de advertencia, por lo que slo identifica el cdigo posible problema, no la impide.

PLS-00436 de restriccin en los estados ParaTodos eliminadoLa restriccin de PLS-00436 se ha eliminado, lo que significa que ahora puede hacer referencia a los elementos individuales de una coleccin en elSETyWHERElas clusulas de una instruccin DML en una ParaTodos construir.Para verlo en accin, crear y rellena una tabla de prueba con el siguiente cdigo.CREATE TABLE forall_test ( nmero de identificacin, Descripcin VARCHAR2 (50) );

INSERT INTO forall_test VALUES (1, 'uno'); INSERT INTO forall_test VALUES (2, 'dos'); INSERT INTO forall_test VALUES (3, 'tres'); INSERT INTO forall_test VALUES (4, 'cuatro'); INSERT INTO forall_test VALUES (5, 'cinco'); COMMIT; El bloque de PL / SQL a continuacin rellena una coleccin con los datos existentes, que modifica los datos de la coleccin, a continuacin, actualiza la tabla con los datos modificados.La consulta final muestra los datos modificados en la tabla.DECLARE TIPO ES t_forall_test_tab TABLA DE ROWTYPE forall_test%; l_tab t_forall_test_tab; INICIO - Recuperar los datos existentes en una coleccin. SELECT * A GRANEL EN RECOGER l_tab DE forall_test;

- Modificar los datos de la coleccin. For i in l_tab.first .. l_tab.last LOOP l_tab (i) Descripcin: = 'Descripcin para' | | i;. END LOOP;

- Actualizacin de la tabla utilizando la coleccin. ParaTodos i EN l_tab.first .. l_tab.last ACTUALIZACIN forall_test Descripcin SET = l_tab (i). Descripcin WHERE id = l_tab (i) Identificacin.;

COMMIT; END; /

SELECT * FROM forall_test;

ID DESCRIPCIN ---------- --------------------------- 1 Descripcin de una 2 Descripcin de dos 3 Descripcin de tres 4 Descripcin de 4 5 Descripcin de 5

5 filas seleccionadas.

SQL> Notificacin tanto en elSETyWHEREclusulas contienen referencias a columnas individuales de la coleccin.Esto hace que el uso a granel-se une a DML an ms fcil ya que no es necesario para mantener las colecciones mltiples si es necesario hacer referencia a las columnas de laWHEREclusula.Tambin puede mejorar el rendimiento de las actualizaciones, como las versiones anteriores requiere la actualizacin de toda la fila con elROWpalabra clave, que incluyen cambios potencialmente innecesario de la clave principal y las columnas de clave

Tabla_1 ==== 1000000Tabla_2 ====5000En la clusula FROM, en qu orden van las tablas?a) FROM Tabla_1, Tabla_2b) FROM Tabla_2, Tabla_1La respuesta correcta es: B) FROM Tabla_2, Tabla_1

Oracle Parsea las tablas de derecha a izquierda. Las dems tablas lo hacen de izquierda a derecha (orden dispuesto en la clusula FROM )

Tabla_1 ==== 10000000Tabla_2 ====5000Tabla_3 ==== 2500000Tabla 1 FK ------ Tabla_3Tabla_2 FK ----- Tabla_3Tabla_1Tabla_2

En la clusula FROM, en que orden van las tablas?a) FROM Tabla_1, Tabla_2, Tabla_3b) FROM Tabla_2, Tabla_1, Tabla_3c) FROM Tabla_3, Tabla_2, Tabla_1d) FROM Tabla_3, Tabla_1, Tabla_2

La respuesta correcta es: A) y B)

La tabla PIVOTE, es la tabla que es intercepcin entre las tablas. La tabla que tiene elementos de todas las tablas involucradas para poder hacer la relacin.

Tipos de bases de datos en Oracle

OLTP - transaccional OLAP procesamiento por lotes (DW ) Multipropsito transaccional y reportera

Declaracin para Mltiples INSERT

Tipos deINSERT

Los diferentes tipos de INSERT mltitablas son:

Incondicional INSERT Condicional INSERT ALL Pivoteado INSERT Condicional INSERT FIRST

Multitable INSERT Statements

Syntax for multitable INSERT: INSERT [conditional_insert_clause][insert_into_clause values_clause] (subquery)

conditional_insert_clause: [ALL] [FIRST][WHEN condition THEN] [insert_into_clause values_clause][ELSE] [insert_into_clause values_clause]

Incondicional INSERT ALL

Select the EMPLOYEE_ID, HIRE_DATE, SALARY, and MANAGER_ID values from the EMPLOYEES table for those employees whose EMPLOYEE_ID is greater than 200.

Insert these values into the SAL_HISTORY and MGR_HISTORY tables by using a multitable INSERT.

Declaracin MERGE Usted puede condicionalmente hacer un insert, una actualizacin o un borrado de registros en una tabla, utilizando MERGE.

Merging Rows: Ejemplo

ndices virtuales

El proceso de afinamiento de instrucciones SQL, requiere que de manera alterna, podamos definir estrategias de indexacin, para observar su efecto en los planes de ejecucin.

Crear ndices adicionales, no es el problema.

El problema es, que crear ndices extras sobre tablas grandes, puede tomar un monto considerado de tiempo y espacio en disco. Adicionalmente, los ndices creados pueden ser utilizados por otras sesiones de usuarios y podra afectar el rendimiento en otras partes de la aplicacin. Esto puede ser problemtico cuando estamos intentando identificar el problema en un sistema en produccin.

En contraste a los ndices convencionales, los ndices virtuales no estn asociados a un segmento, el tiempo de creacin y el espacio asociado en disco es irrelevante. Adicionalmente, no pueden ser vistos por otras sesiones, por tanto, no se ve afectado el normal funcionamiento del sistema.

Este clase muestra de manera sencilla como utilizarlos y las consideraciones que debemos tener en cuenta.

Columnas Virtuales

Frmula / columnas calculadas - sobre la base de datos Restricciones adicionales - sobre la base de datos Nueva categora para la particin - sobre la base de datos Integridad creativa de referencia - en la base de datos

Sin columnas virtuales- inconvenientes

Triggers - caros Vistas- a veces se olvidan Re-diseo Mucho trabajo duro!

272015 Servicio de Base de Datos.

mejoras en expresiones regulares 11gr2

Documents