Este documento introduce los conceptos de colecciones en PL/SQL y proporciona ejemplos prácticos de su uso. Explica el método BULK COLLECT para recuperar grandes cantidades de datos de forma eficiente de una base de datos. Luego presenta un paquete que define funciones que reciben y devuelven diferentes tipos de colecciones, incluidas matrices asociativas, tablas anidadas y arrays variables. Finalmente, muestra ejemplos de cómo implementar y llamar a las funciones del paquete.
El documento describe un proyecto de una asignatura de Sistemas Cliente-Servidor sobre consultas SQL. Explica conceptos básicos de SQL como lenguaje de consultas estructuradas para bases de datos relacionales. Luego presenta ejemplos de sentencias SQL SELECT para realizar consultas con restricciones, proyecciones, enlaces entre tres tablas y autoenlaces, y el uso de la cláusula GROUP BY. Finalmente muestra ejemplos de sentencias INSERT, UPDATE y DELETE para modificar filas de una tabla.
1) El documento habla sobre el proceso de tuning o afinamiento de bases de datos, el cual busca detectar cuellos de botella y lograr que los procesos se ejecuten de manera más eficiente con menos recursos.
2) Se mencionan cuatro áreas clave para el tuning en Oracle: SGA, causas de mal desempeño, razones para un pobre rendimiento del RDBMS, y programas.
3) Se detallan cuatro metas principales para mejorar rápidamente el rendimiento en Oracle: asignar suficiente memoria, cargar datos
Este documento describe el análisis de dominancia usando el paquete ruby-statsample. El análisis de dominancia determina la importancia relativa de predictores para predecir un criterio. Ruby-statsample permite realizar análisis de dominancia completa, condicional y general, así como indicadores de reproducibilidad mediante remuestreo bootstrap. El proceso incluye instalar Ruby y gemas, preparar los datos, diseñar el script Ruby y ejecutar el análisis.
El documento habla sobre una sesión sobre SQL Server Rápido y Furioso del 2 de Setiembre de 2015. La sesión cubrirá temas como la configuración de SQL Server, tablas variables vs temporales, búsquedas de texto, query hints, índices sugeridos e in-memory. El próximo evento será sobre SQL como servicio en la nube el 9 de Setiembre.
Este documento presenta 12 ejercicios sobre el uso de funciones y procedimientos PL/SQL. Los ejercicios cubren temas como funciones con parámetros, la sentencia INTO, funciones para calcular préstamos morosos basados en días, e inserción, actualización y eliminación de datos usando las sentencias INSERT, UPDATE y DELETE.
Laravel es un framework de código abierto para desarrollar aplicaciones web en PHP que sigue el patrón MVC. Utiliza Eloquent ORM para mapear tablas de base de datos a objetos y Blade como motor de plantillas. La estructura principal incluye carpetas para la aplicación, vistas, controladores y más. Eloquent ORM permite crear, leer, actualizar y eliminar registros de la base de datos como objetos.
El documento proporciona información sobre cursores en SQL Server. Explica que un cursor permite recorrer y procesar fila a fila los resultados de una consulta en lugar de tratarlos como un conjunto. Detalla los pasos para crear un cursor, incluyendo declararlo, abrirlo, recorrerlo mediante fetches, cerrarlo y liberarlo. También incluye ejemplos de cómo usar cursores para copiar datos entre tablas y mostrar detalles de pedidos según una tabla de cabeceras.
El documento proporciona información sobre cursores en SQL Server. Explica que un cursor permite recorrer y procesar fila a fila los resultados de una consulta en lugar de tratarlos como un conjunto. Detalla los pasos para crear un cursor, incluyendo declararlo, abrirlo, recorrerlo fila a fila, cerrarlo y liberar los recursos. También incluye ejemplos de cómo usar cursores para copiar datos entre tablas y mostrar detalles de pedidos.
El documento describe un proyecto de una asignatura de Sistemas Cliente-Servidor sobre consultas SQL. Explica conceptos básicos de SQL como lenguaje de consultas estructuradas para bases de datos relacionales. Luego presenta ejemplos de sentencias SQL SELECT para realizar consultas con restricciones, proyecciones, enlaces entre tres tablas y autoenlaces, y el uso de la cláusula GROUP BY. Finalmente muestra ejemplos de sentencias INSERT, UPDATE y DELETE para modificar filas de una tabla.
1) El documento habla sobre el proceso de tuning o afinamiento de bases de datos, el cual busca detectar cuellos de botella y lograr que los procesos se ejecuten de manera más eficiente con menos recursos.
2) Se mencionan cuatro áreas clave para el tuning en Oracle: SGA, causas de mal desempeño, razones para un pobre rendimiento del RDBMS, y programas.
3) Se detallan cuatro metas principales para mejorar rápidamente el rendimiento en Oracle: asignar suficiente memoria, cargar datos
Este documento describe el análisis de dominancia usando el paquete ruby-statsample. El análisis de dominancia determina la importancia relativa de predictores para predecir un criterio. Ruby-statsample permite realizar análisis de dominancia completa, condicional y general, así como indicadores de reproducibilidad mediante remuestreo bootstrap. El proceso incluye instalar Ruby y gemas, preparar los datos, diseñar el script Ruby y ejecutar el análisis.
El documento habla sobre una sesión sobre SQL Server Rápido y Furioso del 2 de Setiembre de 2015. La sesión cubrirá temas como la configuración de SQL Server, tablas variables vs temporales, búsquedas de texto, query hints, índices sugeridos e in-memory. El próximo evento será sobre SQL como servicio en la nube el 9 de Setiembre.
Este documento presenta 12 ejercicios sobre el uso de funciones y procedimientos PL/SQL. Los ejercicios cubren temas como funciones con parámetros, la sentencia INTO, funciones para calcular préstamos morosos basados en días, e inserción, actualización y eliminación de datos usando las sentencias INSERT, UPDATE y DELETE.
Laravel es un framework de código abierto para desarrollar aplicaciones web en PHP que sigue el patrón MVC. Utiliza Eloquent ORM para mapear tablas de base de datos a objetos y Blade como motor de plantillas. La estructura principal incluye carpetas para la aplicación, vistas, controladores y más. Eloquent ORM permite crear, leer, actualizar y eliminar registros de la base de datos como objetos.
El documento proporciona información sobre cursores en SQL Server. Explica que un cursor permite recorrer y procesar fila a fila los resultados de una consulta en lugar de tratarlos como un conjunto. Detalla los pasos para crear un cursor, incluyendo declararlo, abrirlo, recorrerlo mediante fetches, cerrarlo y liberarlo. También incluye ejemplos de cómo usar cursores para copiar datos entre tablas y mostrar detalles de pedidos según una tabla de cabeceras.
El documento proporciona información sobre cursores en SQL Server. Explica que un cursor permite recorrer y procesar fila a fila los resultados de una consulta en lugar de tratarlos como un conjunto. Detalla los pasos para crear un cursor, incluyendo declararlo, abrirlo, recorrerlo fila a fila, cerrarlo y liberar los recursos. También incluye ejemplos de cómo usar cursores para copiar datos entre tablas y mostrar detalles de pedidos.
Este documento presenta los fundamentos de la programación en SQL Server, incluyendo el uso de variables, bloques de código, estructuras de control y bucles. Explica qué es la programación SQL y para qué sirve, los tipos de datos y variables, y provee ejemplos del uso de if/else, case y while. También cubre el manejo de errores y excepciones mediante try/catch y raiserror. El objetivo es facilitar la comprensión de estos conceptos básicos para interactuar con bases de datos a través del lenguaje SQL.
Este documento describe los tipos de datos compuestos en PL/SQL, incluyendo registros y tablas. Explica cómo definir registros y tablas, y cómo declarar y manipular variables de estos tipos. También cubre el uso de paquetes PL/SQL para agrupar objetos relacionados como procedimientos, funciones y tipos de datos.
Este documento describe las nuevas características de Transact SQL (T-SQL) para SQL Server 2005. Algunas de las principales características son la capacidad de numerar filas con Row_Number(), usar TOP con parámetros, mejoras en el manejo de errores con TRY/CATCH, tipos de datos dinámicos como VARCHAR(MAX) y nuevas acciones para restricciones foreign key como SET DEFAULT y SET NULL. Además, SQL Server 2005 introduce triggers DDL para auditar eventos de nivel de base de datos.
Cómo hacer analítica de los logs que producen las aplicaciones. Introducción teorica y práctica de las tres herramientas ELK(ElasticSearch, Logstash y Kibana).
Este documento presenta una introducción a los tipos de datos, tablas, vistas y procedimientos almacenados en SQL Server. Explica los diferentes tipos de datos y sus categorías. Luego, describe cómo crear tablas, incluidas las llaves primarias y columnas nulas. También explica cómo crear vistas y los beneficios de su uso. Finalmente, detalla los procedimientos almacenados, incluidas sus propiedades y cómo mejoran el rendimiento de las aplicaciones.
Este documento presenta una introducción a las funciones de agrupamiento en SQL como COUNT, MAX, MIN, SUM y AVG, las cuales permiten trabajar con grupos de datos. También explica conceptos como GROUP BY, HAVING, JOIN y otras funciones como IFNULL y CASE. Finalmente, introduce conceptos básicos de modelado de datos como entidades, atributos, relaciones y sus características.
Este documento proporciona una introducción básica a MySQL. Explica que MySQL es un sistema de gestión de bases de datos relacional muy popular, especialmente para aplicaciones web. Detalla cómo instalar el servidor y cliente de MySQL, y proporciona ejemplos de comandos básicos como crear bases de datos y tablas, insertar y consultar datos.
Este documento describe diferentes estructuras de control en Transact SQL como IF, CASE, WHILE y GOTO. También explica conceptos como transacciones, autorizaciones, desautorizaciones y sublenguajes especializados como SQL hospedado y SQL/CLI para interactuar con bases de datos desde lenguajes de programación.
Rendimiento en aplicaciones web con Symfony2Asier Marqués
Este documento proporciona consejos sobre el rendimiento web y el rendimiento de bases de datos. Resalta la importancia de diseñar aplicaciones de forma escalable y optimizada desde el principio. Recomienda evitar consultas innecesarias, usar índices adecuados, particionar tablas grandes y almacenar en caché resultados cuando sea posible. También analiza herramientas para medir el rendimiento como Varnish y sugiere opciones alternativas como NoSQL para ciertos casos.
20 tips para escribir stored procedures en sql server774angito
Este documento proporciona 20 consejos para escribir stored procedures en SQL Server, incluyendo usar identación y comentarios, declarar e inicializar variables al comienzo, evitar cursores cuando sea posible, y usar JOIN en lugar de subconsultas para mejorar el rendimiento.
Los procedimientos almacenados permiten definir programas o funciones en la base de datos para ser usados de forma repetida. Mejoran el rendimiento al almacenar planes de consulta en caché y reducir el tráfico de red. En PostgreSQL se pueden escribir en varios lenguajes como PL/pgSQL y se usan para crear funciones, disparadores y estructuras de control complejas.
Las tablas particionadas dividen grandes tablas en múltiples particiones para mejorar la escalabilidad, rendimiento y manejabilidad. En PostgreSQL se implement
Las tablas particionadas permiten dividir los datos de una gran tabla en múltiples tablas más pequeñas para mejorar el rendimiento de las consultas, inserciones y otras operaciones. En PostgreSQL, el particionado se implementa mediante herencia de tablas, donde cada partición es una tabla hija de una tabla principal vacía. Las tablas hijas pueden particionarse por rangos de valores o listas de valores y se definen restricciones CHECK para cada partición.
Este documento describe variables de tipo cursor en Oracle PL/SQL. Explica que las variables de tipo cursor son referencias a cursores que apuntan a áreas de trabajo donde se almacenan los datos de consultas. Discute dos tipos de variables de cursor - restrictivas y no restrictivas - y proporciona ejemplos de cómo definir, declarar y usar variables de tipo cursor en PL/SQL. También describe cómo compartir cursores entre procedimientos almacenados y programas de clientes escritos en otros lenguajes.
Este documento describe diferentes técnicas avanzadas de SQL injection, incluyendo el uso de stored procedures y extended stored procedures para ejecutar código de manera arbitraria en la base de datos, así como técnicas de blind SQL injection que se basan en respuestas verdadero/falso y en retardos de tiempo para extraer información de forma encubierta.
Este documento resume los conceptos clave relacionados con el análisis del rendimiento en Oracle. Explica las vistas dinámicas más importantes para el monitoreo del rendimiento, como Statspack que genera informes de rendimiento. También describe las incidencias más comunes que afectan el rendimiento como la contención en latches y la memoria insuficiente. Finalmente, resume la información clave que provee el informe de Statspack como los eventos con mayor espera y el uso de recursos.
PEMEX Petroquímica busca automatizar el proceso de carga de su Base de Datos Institucional (BDI-PPQ) mediante una interfaz que extraiga datos de ventas del Sistema Integral de Información Operativa Comercial (SIIOC) y los procese para generar reportes en Excel que alimenten la BDI-PPQ de forma más rápida y confiable que el proceso manual actual.
Este documento define ResultSet como una interfaz que proporciona acceso a los resultados de consultas ejecutadas. Describe cómo crear un ResultSet mediante métodos como executeQuery y cómo recuperar y manipular los datos de un ResultSet accediendo a sus filas y columnas. También resume las características y tipos de ResultSet, como su tipo de desplazamiento, concurrencia y habilidad para cerrar el cursor.
Este documento presenta los fundamentos de la programación en SQL Server, incluyendo el uso de variables, bloques de código, estructuras de control y bucles. Explica qué es la programación SQL y para qué sirve, los tipos de datos y variables, y provee ejemplos del uso de if/else, case y while. También cubre el manejo de errores y excepciones mediante try/catch y raiserror. El objetivo es facilitar la comprensión de estos conceptos básicos para interactuar con bases de datos a través del lenguaje SQL.
Este documento describe los tipos de datos compuestos en PL/SQL, incluyendo registros y tablas. Explica cómo definir registros y tablas, y cómo declarar y manipular variables de estos tipos. También cubre el uso de paquetes PL/SQL para agrupar objetos relacionados como procedimientos, funciones y tipos de datos.
Este documento describe las nuevas características de Transact SQL (T-SQL) para SQL Server 2005. Algunas de las principales características son la capacidad de numerar filas con Row_Number(), usar TOP con parámetros, mejoras en el manejo de errores con TRY/CATCH, tipos de datos dinámicos como VARCHAR(MAX) y nuevas acciones para restricciones foreign key como SET DEFAULT y SET NULL. Además, SQL Server 2005 introduce triggers DDL para auditar eventos de nivel de base de datos.
Cómo hacer analítica de los logs que producen las aplicaciones. Introducción teorica y práctica de las tres herramientas ELK(ElasticSearch, Logstash y Kibana).
Este documento presenta una introducción a los tipos de datos, tablas, vistas y procedimientos almacenados en SQL Server. Explica los diferentes tipos de datos y sus categorías. Luego, describe cómo crear tablas, incluidas las llaves primarias y columnas nulas. También explica cómo crear vistas y los beneficios de su uso. Finalmente, detalla los procedimientos almacenados, incluidas sus propiedades y cómo mejoran el rendimiento de las aplicaciones.
Este documento presenta una introducción a las funciones de agrupamiento en SQL como COUNT, MAX, MIN, SUM y AVG, las cuales permiten trabajar con grupos de datos. También explica conceptos como GROUP BY, HAVING, JOIN y otras funciones como IFNULL y CASE. Finalmente, introduce conceptos básicos de modelado de datos como entidades, atributos, relaciones y sus características.
Este documento proporciona una introducción básica a MySQL. Explica que MySQL es un sistema de gestión de bases de datos relacional muy popular, especialmente para aplicaciones web. Detalla cómo instalar el servidor y cliente de MySQL, y proporciona ejemplos de comandos básicos como crear bases de datos y tablas, insertar y consultar datos.
Este documento describe diferentes estructuras de control en Transact SQL como IF, CASE, WHILE y GOTO. También explica conceptos como transacciones, autorizaciones, desautorizaciones y sublenguajes especializados como SQL hospedado y SQL/CLI para interactuar con bases de datos desde lenguajes de programación.
Rendimiento en aplicaciones web con Symfony2Asier Marqués
Este documento proporciona consejos sobre el rendimiento web y el rendimiento de bases de datos. Resalta la importancia de diseñar aplicaciones de forma escalable y optimizada desde el principio. Recomienda evitar consultas innecesarias, usar índices adecuados, particionar tablas grandes y almacenar en caché resultados cuando sea posible. También analiza herramientas para medir el rendimiento como Varnish y sugiere opciones alternativas como NoSQL para ciertos casos.
20 tips para escribir stored procedures en sql server774angito
Este documento proporciona 20 consejos para escribir stored procedures en SQL Server, incluyendo usar identación y comentarios, declarar e inicializar variables al comienzo, evitar cursores cuando sea posible, y usar JOIN en lugar de subconsultas para mejorar el rendimiento.
Los procedimientos almacenados permiten definir programas o funciones en la base de datos para ser usados de forma repetida. Mejoran el rendimiento al almacenar planes de consulta en caché y reducir el tráfico de red. En PostgreSQL se pueden escribir en varios lenguajes como PL/pgSQL y se usan para crear funciones, disparadores y estructuras de control complejas.
Las tablas particionadas dividen grandes tablas en múltiples particiones para mejorar la escalabilidad, rendimiento y manejabilidad. En PostgreSQL se implement
Las tablas particionadas permiten dividir los datos de una gran tabla en múltiples tablas más pequeñas para mejorar el rendimiento de las consultas, inserciones y otras operaciones. En PostgreSQL, el particionado se implementa mediante herencia de tablas, donde cada partición es una tabla hija de una tabla principal vacía. Las tablas hijas pueden particionarse por rangos de valores o listas de valores y se definen restricciones CHECK para cada partición.
Este documento describe variables de tipo cursor en Oracle PL/SQL. Explica que las variables de tipo cursor son referencias a cursores que apuntan a áreas de trabajo donde se almacenan los datos de consultas. Discute dos tipos de variables de cursor - restrictivas y no restrictivas - y proporciona ejemplos de cómo definir, declarar y usar variables de tipo cursor en PL/SQL. También describe cómo compartir cursores entre procedimientos almacenados y programas de clientes escritos en otros lenguajes.
Este documento describe diferentes técnicas avanzadas de SQL injection, incluyendo el uso de stored procedures y extended stored procedures para ejecutar código de manera arbitraria en la base de datos, así como técnicas de blind SQL injection que se basan en respuestas verdadero/falso y en retardos de tiempo para extraer información de forma encubierta.
Este documento resume los conceptos clave relacionados con el análisis del rendimiento en Oracle. Explica las vistas dinámicas más importantes para el monitoreo del rendimiento, como Statspack que genera informes de rendimiento. También describe las incidencias más comunes que afectan el rendimiento como la contención en latches y la memoria insuficiente. Finalmente, resume la información clave que provee el informe de Statspack como los eventos con mayor espera y el uso de recursos.
PEMEX Petroquímica busca automatizar el proceso de carga de su Base de Datos Institucional (BDI-PPQ) mediante una interfaz que extraiga datos de ventas del Sistema Integral de Información Operativa Comercial (SIIOC) y los procese para generar reportes en Excel que alimenten la BDI-PPQ de forma más rápida y confiable que el proceso manual actual.
Este documento define ResultSet como una interfaz que proporciona acceso a los resultados de consultas ejecutadas. Describe cómo crear un ResultSet mediante métodos como executeQuery y cómo recuperar y manipular los datos de un ResultSet accediendo a sus filas y columnas. También resume las características y tipos de ResultSet, como su tipo de desplazamiento, concurrencia y habilidad para cerrar el cursor.
Similaire à MAGIC PL_SQL ORACLE_ Ejemplos de Colecciones.pdf (20)
Mi Carnaval, Aplicación web para la gestión del carnaval y la predicción basa...micarnavaltupatrimon
Mi Carnaval es la plataforma que permite conectar al usuario con la cultura y la emoción del Carnaval de Blancos y Negros en la ciudad de Pasto, esta plataforma brinda una amplia oferta de productos, servicios, tiquetería e información relevante para generarle valor al usuario, además, la plataforma realiza un levantamiento de datos de los espectadores que se registran, capturando su actividad e información relevante para generar la analítica demográfica del evento en tiempo real, con estos datos se generan modelos predictivos, que permiten una mejor preparación y organización del evento, de esta manera ayudando a reducir la congestión, las largas filas y, así como a identificar áreas de alto riesgo de delincuencia y otros problemas de seguridad.
Mi Carnaval, Aplicación web para la gestión del carnaval y la predicción basa...micarnavaltupatrimon
Mi Carnaval es la plataforma que permite conectar al usuario con la cultura y la emoción del Carnaval de Blancos y Negros en la ciudad de Pasto, esta plataforma brinda una amplia oferta de productos, servicios, tiquetería e información relevante para generarle valor al usuario, además, la plataforma realiza un levantamiento de datos de los espectadores que se registran, capturando su actividad e información relevante para generar la analítica demográfica del evento en tiempo real, con estos datos se generan modelos predictivos, que permiten una mejor preparación y organización del evento, de esta manera ayudando a reducir la congestión, las largas filas y, así como a identificar áreas de alto riesgo de delincuencia y otros problemas de seguridad.
Casos de éxito en Negocios online: Estrategias WPO que funcionan - Presentac...Javier Martinez Seco
El 15 de junio de 2024 Javier Martínez Seco, director de Ecode, presentó en SEonthebeach 2024 una ponencia titulada "Casos de éxito en Negocios online - Estrategias WPO que funcionan". Javier compartió su experiencia de más de 15 años en el ámbito de las tecnologías web, destacando su especialización en desarrollo web a medida, SEO técnico y optimización del rendimiento web (WPO).
- Presentación inicial: Javier Martínez es ingeniero informático especializado en tecnologías web, con un historial que incluye la creación y mejora de más de 1000 sitios web y negocios online. Realiza auditorías, consultorías, formación a equipos de desarrollo y desarrollo a medida.
- Sitios web que funcionan bien desde el principio: destacó la diferencia entre un sitio web que simplemente "funciona" y uno que "funciona bien". Ejemplos reales desarrollados por Ecode.
- Calidad en el rendimiento web: explicó qué aspectos deben considerarse para conseguir calidad en el rendimiento de una web. Detalló los procesos que el navegador debe seguir para renderizar una página web, incluyendo la descarga del documento HTML, CSS y demás recursos (imágenes, tipografías, ficheros JavaScript).
- Estrategias de carga óptima: Javier presentó estrategias de carga óptima teniendo en cuenta diferentes objetivos y condiciones de trabajo. Habló sobre la importancia de simular condiciones reales de usuario y ajustar la velocidad y CPU para estas simulaciones. También mencionó la extensión de Chrome Web Vitals.
- Pruebas de rendimiento: indicó cómo probar el rendimiento de carga de una página web en su primera visita.
- Realidad del sector y mercado actual: Javier describió la situación actual del sector, donde se priorizan tecnologías populares que facilitan el trabajo de creación web. Sin embargo, advirtió sobre la dependencia de tecnologías conocidas y la necesidad de adaptar el negocio online a estas tecnologías.
- Ejemplos de cargas no óptimas: presentó ejemplos de malas cargas de diferentes webs populares desarrolladas con CMS y tecnologías como Shopify, Webflow, Prestashop, Magento, Salesforce, Elementor, WordPress y Drupal. La tecnología lenta es tecnología mala.
- ¿Merece la pena hacerlo mejor?: Javier subrayó la importancia de medir la situación actual y evaluar la oportunidad de mejora.
- Javier finalizó la ponencia hablando sobre cómo trabaja actualmente con su empresa Ecode, enfocada en construir sitios web muy optimizados desde el inicio. Presentó un caso de éxito: La Casa del Electrodoméstico, una tienda online a medida con una facturación anual de millones de euros y más de 10 millones de carritos de compra, donde más del 90% de las sesiones cumplen con los parámetros LCP, INP y CLS durante toda la sesión.
La ponencia de Javier Martínez Seco en SEonthebeach 2024 ofreció una visión completa y práctica sobre la optimización del rendimiento web, demostrando cómo las estrategias WPO bien implementadas pueden marcar la diferencia en el éxito de los negocios online.
Aplicación de las sentencias de control en telecomunicacionesambuludimateo2
if y switch son fundamentales en la programación moderna debido a su capacidad para controlar el flujo de ejecución y tomar decisiones basadas en condiciones específicas.
DuckDuckGo, es el motor de búsqueda centrado en la privacidad que lleva años creciendo como una sólida alternativa a buscadores como Google, Bing y Yahoo. Sobre todo, una alternativa para todos aquellos que no quieran ser rastreados y que quieran maximizar la privacidad cuando buscan cosas en Internet.
1. 14/2/24, 02:51 MAGIC PL/SQL ORACLE: Ejemplos de Colecciones
https://magicplsql.blogspot.com/2017/01/ejemplos-de-colecciones.html 1/18
MAGIC PL/SQL ORACLE
MAGIC PL/SQL ORACLE
lunes, 9 de enero de 2017
Ejemplos de Colecciones
Objetivos:
• Introducción al método BULK COLLECT.
• Ver Ejemplos Prácticos de Colecciones de PL/SQL.
• Usar Colecciones como valor de retorno de Subprogramas.
NOTA: Usamos como ejemplo la Base de Datos: ORCL, la cual viene por defecto
en cualquier versión de ORACLE.
_____________________________________________________________
_______________________
BULK COLLECT
Con BULK COLLECT podemos obtener grandes cantidades de datos de manera
mas rápida y optima que con cualquier otro método de consulta. Al usar BULK
COLLECT, el motor de PL/SQL le dice al motor SQL que colecte muchas filas a la
vez y las coloque en una Colección previamente definida. Durante una recolección
masiva de Oracle, el motor SQL recupera todas las filas y las carga en
la Colección para luego cambiar de nuevo al motor PL/SQL. Cuanto mayor sea el
número de filas que desea extraer, mayor seria el rendimiento de la consulta.
Ejemplo:
Nota: El siguiente ejemplo tiene como Fin Único mostrar el
desempeño/rendimiento del método BULK COLLECT, por lo cual, el mismo
►
► 2016 (52)
▼
▼ 2017 (24)
▼
▼ enero (4)
Las Colecciones de PL/SQL
Ejemplos de Colecciones
JOBS(Tareas) de Base de Datos
Leyendo archivos con UTL_FILE
en ORACLE
►
► febrero (4)
►
► marzo (3)
►
► abril (5)
►
► mayo (3)
►
► junio (2)
►
► julio (3)
►
► 2018 (6)
Publicaciones por Fecha
Implementaciones
ORACLE FORMS
PL-SQL
SQL
Etiquetas
Más wrwilliamss@gmail.com Escritorio Cerrar sesión
2. 14/2/24, 02:51 MAGIC PL/SQL ORACLE: Ejemplos de Colecciones
https://magicplsql.blogspot.com/2017/01/ejemplos-de-colecciones.html 2/18
puede no se perciba una utilidad en el mundo real.
SET SERVEROUTPUT ON
DECLARE
--Definimos este CURSOR con el fin de mostrar el rendimiento de
BULK COLLECT.
CURSOR c_cross_join IS
SELECT cross.* --131,079,601 Registros en Total.
FROM
(
SELECT
e.employee_id,
e.last_name,
e.salary
FROM hr.employees e
CROSS JOIN hr.employees e1
) cross
CROSS JOIN
(
SELECT
e.employee_id,
e.last_name,
e.salary
FROM hr.employees e
CROSS JOIN hr.employees e1
) cross1
WHERE ROWNUM < 1000001; --Para los fines de este ejemplo,
un millón sera suficiente.
--Record con campos acordes al CURSOR: c_cross_join.
TYPE typ_emp_rec IS RECORD
(
emp_id hr.employees.employee_id%TYPE,
emp_name hr.employees.last_name%TYPE,
emp_sal hr.employees.salary%TYPE
);
Denunciar abuso
Autor
Contacto
Social Buttons
SQL
PL/SQL
ORACLE FORMS
IMPLEMENTACIONES
Main Menu
3. 14/2/24, 02:51 MAGIC PL/SQL ORACLE: Ejemplos de Colecciones
https://magicplsql.blogspot.com/2017/01/ejemplos-de-colecciones.html 3/18
--Definimos el Tipo Colección(Matriz Asociativa)
TYPE typ_assoc_array
IS TABLE OF typ_emp_rec
INDEX BY PLS_INTEGER;
--Definimos la variable Colección: v_assoc_array donde haremos el
FETCH de los datos.
v_assoc_array typ_assoc_array;
--La variable v_method indicara el método a ejecutar:
---Si es 1 ejecutara el método BULK COLLECT.
---De lo contrario usara el Tradicional.
v_method NUMBER := 1;
v_method_name VARCHAR2(12);
v_counter NUMBER := 1;
BEGIN
CASE
WHEN v_method = 1 THEN
OPEN c_cross_join;
LOOP --LOOP Simple
--La cláusula LIMIT hará que el BULK COLLECT colecte los
registros de 500 mil en 500 mil.
FETCH c_cross_join BULK COLLECT INTO v_assoc_array LIMIT
500000;
EXIT
WHEN v_counter > 1; --Para salir del LOOP en la segunda
Iteración.
v_counter := v_counter+1;
END LOOP;
CLOSE c_cross_join;
v_method_name := 'BULK COLLECT';
ELSE
FOR i IN c_cross_join LOOP --CURSOR FOR LOOP
Share
Best Newest Oldest
0 Comments
Williams Ramos
Start the discussion…
Be the first to comment.
Subscribe
Privacy
Do Not Sell My
Data
Nombre
Correo electrónico *
Contacto
4. 14/2/24, 02:51 MAGIC PL/SQL ORACLE: Ejemplos de Colecciones
https://magicplsql.blogspot.com/2017/01/ejemplos-de-colecciones.html 4/18
v_assoc_array(v_counter).emp_id := i.employee_id;
v_assoc_array(v_counter).emp_name := i.last_name;
v_assoc_array(v_counter).emp_sal := i.salary;
v_method_name := 'Tradicional';
v_counter := v_counter+1;
END LOOP;
END CASE;
--Notaran que la Colección trae el millón de registros del CURSOR
solo cuando se usa el método Tradicional
--Esto es porque por cada Iteración del LOOP Simple se reemplazan
los 500 mil primeros Indices de la Colección
--con los nuevos datos extraídos del CURSOR. Recuerden que el Fin
del ejemplo es mostrar el Rendimiento del BULK COLLECT.
DBMS_OUTPUT.PUT_LINE('Número de Indices: '||v_assoc_array.COUNT);
--Muestro la Fecha y Hora para que se vea claro que primero ejecuto
el método BULK COLLECT.
DBMS_OUTPUT.PUT_LINE('Método: '||v_method_name||CHR(10)||'Fecha y
Hora de Ejecución: '||SYSTIMESTAMP);
END;
/
/*El ejemplo muestra lo eficiente que resulta el uso de BULK COLLECT
cuando se trata de grandes cantidades de datos. Primero ejecutamos el
método BULK COLLECT y luego el Tradicional, esto para mostrar que
aunque ya Oracle diseñó el Plan de Ejecución para la consulta, aun
así el BULK COLLECT resulta mas optimo.*/
---OUTPUT:
Mensaje *
Enviar
Las Variables de
PL/SQL
Objetivos: • Reconocer
identificadores válidos y
no válidos. • Enumerar
los usos de variables. • Declarar e
inicializar va...
JOBS(Tareas) de Base
de Datos
Objetivos: • Conocer
que es un JOB de Base
de Datos. •
Familiarizarnos con el Paquete:
DBMS_SCHEDULER . • Conocer sus
usos y las ve...
Manejo de Excepciones
Objetivos: • Definir las
excepciones de PL/SQL
. • Reconocer las
excepciones no
controladas(unhandled exceptions). •
Listar y utilizar l...
Entradas populares
Página
Principal Buscar
Buscar este blog
5. 14/2/24, 02:51 MAGIC PL/SQL ORACLE: Ejemplos de Colecciones
https://magicplsql.blogspot.com/2017/01/ejemplos-de-colecciones.html 5/18
Ver que con el método Tradicional el SCRIPT se tomo 2 Segundo mientras que con
el BULK COLLECT solo tardó 1 Segundo. Tener en cuenta que a mayor la
cantidad de datos mejor el rendimiento,
Nota: Si se usa el método BULK COLLECT sin la cláusula LIMIT y de paso se le
quitamos la condición de filtro: WHERE ROWNUM < 1000001 al CURSOR,
Oracle trataría de extraer los 131,079,601 Registros y esto podría congelar el
computador.
_____________________________________________________________
_______________________
6. 14/2/24, 02:51 MAGIC PL/SQL ORACLE: Ejemplos de Colecciones
https://magicplsql.blogspot.com/2017/01/ejemplos-de-colecciones.html 6/18
Funciones que Reciben y Retornan
Colecciones
Ejemplo:
Nota: A continuación creamos un Paquete de Base de Datos en cual aparte de usar
las Colecciones, implementamos el concepto de Sobrecarga (Overload) de
Funciones, si no esta familiarizado con ellas puede adquirir ayuda en esta
publicación: Sobrecargas en Oracle.
Si necesita ayuda con los paquetes, este tema podría ayudarle: Paquetes de
PL/SQL.
CREATE OR REPLACE PACKAGE hr.pkg_collections IS
--Definimos los Tipo Records:
TYPE typ_emp_rec IS RECORD
(
last_name hr.employees.last_name%TYPE,
salary hr.employees.salary%TYPE,
job_title hr.jobs.job_title%TYPE,
department_name hr.departments.department_name%TYPE,
country_name hr.countries.country_name%TYPE
);
--Definimos los Tipo Colecciones:
--Para usarlos como parámetros de entrada:
TYPE typ_assoc_array_in
IS TABLE OF hr.jobs.job_id%TYPE
INDEX BY PLS_INTEGER;
TYPE typ_nest_tab_in
IS TABLE OF hr.departments.department_id%TYPE;
TYPE typ_varray_in
IS VARRAY(1) OF hr.countries.country_id%TYPE;
--Para usarlos de Retorno:
TYPE typ_assoc_array
7. 14/2/24, 02:51 MAGIC PL/SQL ORACLE: Ejemplos de Colecciones
https://magicplsql.blogspot.com/2017/01/ejemplos-de-colecciones.html 7/18
IS TABLE OF typ_emp_rec
INDEX BY PLS_INTEGER;
TYPE typ_nest_tab
IS TABLE OF typ_emp_rec;
TYPE typ_varray
IS VARRAY(200) OF typ_emp_rec;
--Definimos los Subprogramas:
FUNCTION f_bring_details (p_input IN typ_assoc_array_in)
RETURN typ_assoc_array;
FUNCTION f_bring_details (p_input IN typ_nest_tab_in)
RETURN typ_nest_tab;
FUNCTION f_bring_details (p_input IN typ_varray_in)
RETURN typ_varray;
END pkg_collections;
/
SHOW ERROR
/*He aquí la Especificación de Paquete: pkg_collections, los objetos,
variables y subprogramas definidos aquí serán públicos, de esta manera
cualquier usuario con privilegios sobre el paquete podrá crear
instancias de los mismos. Notar como la función: f_bring_details
aparece 3 veces con tipos de parámetros y retornos distintos (cada uno
recibe y retorna un tipo colección diferente). De esta manera
podrán ver como cada Colección tiene un manejo ligeramente distinto
pero se pueden usar para el mismo fin.*/
---
CREATE OR REPLACE PACKAGE BODY hr.pkg_collections IS
--Definimos las variables y CURSORES Privados:
v_filter_char VARCHAR2(10);
v_filter_number NUMBER;
v_counter NUMBER(3) := 1;
CURSOR c_emp_details IS
SELECT
e.last_name,
e.salary,
8. 14/2/24, 02:51 MAGIC PL/SQL ORACLE: Ejemplos de Colecciones
https://magicplsql.blogspot.com/2017/01/ejemplos-de-colecciones.html 8/18
j.job_title,
d.department_name,
c.country_name
FROM
employees e,
departments d,
jobs j,
locations l,
countries c
WHERE (
j.job_id = v_filter_char
OR
d.department_id = v_filter_number
OR
c.country_id = v_filter_char
)
AND e.job_id = j.job_id
AND e.department_id = d.department_id
AND d.location_id = l.location_id
AND l.country_id = c.country_id
ORDER BY e.employee_id DESC;
--Implementación de los los Subprogramas:
FUNCTION f_bring_details (p_input IN typ_assoc_array_in)
RETURN typ_assoc_array IS
v_assoc_array typ_assoc_array;
BEGIN
v_filter_char := p_input(1);
FOR i IN c_emp_details LOOP
v_assoc_array(v_counter).last_name := i.last_name;
v_assoc_array(v_counter).salary := i.salary;
v_assoc_array(v_counter).job_title := i.job_title;
v_assoc_array(v_counter).department_name := i.department_name;
v_assoc_array(v_counter).country_name := i.country_name;
9. 14/2/24, 02:51 MAGIC PL/SQL ORACLE: Ejemplos de Colecciones
https://magicplsql.blogspot.com/2017/01/ejemplos-de-colecciones.html 9/18
v_counter := v_counter+1;
END LOOP;
RETURN v_assoc_array;
END f_bring_details;
FUNCTION f_bring_details (p_input IN typ_nest_tab_in)
RETURN typ_nest_tab IS
v_nest_tab typ_nest_tab;
BEGIN
v_nest_tab := typ_nest_tab();
v_filter_char := p_input(1);
FOR i IN c_emp_details LOOP
v_nest_tab(v_counter).last_name := i.last_name;
v_nest_tab(v_counter).salary := i.salary;
v_nest_tab(v_counter).job_title := i.job_title;
v_nest_tab(v_counter).department_name := i.department_name;
v_nest_tab(v_counter).country_name := i.country_name;
v_counter := v_counter+1;
END LOOP;
RETURN v_nest_tab;
END f_bring_details;
FUNCTION f_bring_details (p_input IN typ_varray_in)
RETURN typ_varray IS
v_varray typ_varray;
BEGIN
v_varray := typ_varray();
v_filter_char := p_input(1);
FOR i IN c_emp_details LOOP
v_varray(v_counter).last_name := i.last_name;
v_varray(v_counter).salary := i.salary;
10. 14/2/24, 02:51 MAGIC PL/SQL ORACLE: Ejemplos de Colecciones
https://magicplsql.blogspot.com/2017/01/ejemplos-de-colecciones.html 10/18
v_varray(v_counter).job_title := i.job_title;
v_varray(v_counter).department_name := i.department_name;
v_varray(v_counter).country_name := i.country_name;
v_counter := v_counter+1;
END LOOP;
RETURN v_varray;
END f_bring_details;
END pkg_collections;
/
SHOW ERROR
/*He aquí el cuerpo del Paquete: pkg_collections; El mismo es donde
desarrollamos la lógica del negocio y le damos funcionalidad a los
subprogramos definidos en la especificación. Notar que en el cuerpo
podemos también crear variables, CURSORES y hasta subprogramas
que sirven de respaldo para implementar todo la lógica. Tenga en
cuenta que los Objetos creados solo en el cuerpo del paquete son
privados por lo cual ningún usuario podría crear instancias de los
mismo fuera del paquete.*/
_____________________________________________________________
_______________________
Implementación del Paquete: pkg_collections.
Ejemplos:
SET SERVEROUTPUT ON
DECLARE
v_assoc_array_in hr.pkg_collections.typ_assoc_array_in;
v_assoc_array hr.pkg_collections.typ_assoc_array;
BEGIN
v_assoc_array_in(1) := 'IT_PROG';
v_assoc_array := hr.pkg_collections.f_bring_details(v_assoc_array_in);
IF v_assoc_array.COUNT > 0 THEN
11. 14/2/24, 02:51 MAGIC PL/SQL ORACLE: Ejemplos de Colecciones
https://magicplsql.blogspot.com/2017/01/ejemplos-de-colecciones.html 11/18
DBMS_OUTPUT.PUT_LINE(
LPAD('=',100,'=')||CHR(10)||
'Nombre || Salario || Empleo || Departamento ||
País
'||CHR(10)||LPAD('=',100,'=')
);
FOR i IN v_assoc_array.FIRST..v_assoc_array.LAST LOOP
DBMS_OUTPUT.PUT_LINE
(
RPAD(v_assoc_array(i).last_name, 15, ' ')||
RPAD(v_assoc_array(i).salary, 10, ' ')||
RPAD(v_assoc_array(i).job_title, 26, ' ')||
RPAD(v_assoc_array(i).department_name, 20, ' ')||
v_assoc_array(i).country_name
);
END LOOP;
END IF;
END;
/
/*Para el ejemplo elegimos usar la sobrecarga que recibe y retorna el
Tipo Colección: Matriz Asociativa. Notar que con tan solo pasarle una
variable del Tipo: Matriz Asociativa Oracle se encarga de seleccionar la
función acorde a ella.*/
---OUTPUT:
12. 14/2/24, 02:51 MAGIC PL/SQL ORACLE: Ejemplos de Colecciones
https://magicplsql.blogspot.com/2017/01/ejemplos-de-colecciones.html 12/18
Nota: La implementación de las demás funciones del paquete es similar a la que
acabo de presentar, por tal razón no la publicare, si tienes dudas de como
realizarlas, el siguiente Link le seria de gran ayuda: Las Colecciones de PL/SQL.
_____________________________________________________________
_______________________
Bonus:
Para concluir decidimos presentar un ejemplo ligeramente complejo en cual
usamos las Colecciones para similar un escenario común del día a día. El SCRIPT
le permite crear una relación similar a la siguiente:
Nos limitamos este pequeño Albor para así facilitar el entendimiento del ejemplo,
pero es prudente recargar que estas Estructuras de Datos combinadas con los
Records tienen la capacidad de modelar escenarios de la vida diaria Bastante
Complejos.
DECLARE
--Record: typ_room_rec para representar los muebles de una casa.
TYPE typ_room_rec IS RECORD
(
room_type VARCHAR2(30),
room_size VARCHAR2(30)
13. 14/2/24, 02:51 MAGIC PL/SQL ORACLE: Ejemplos de Colecciones
https://magicplsql.blogspot.com/2017/01/ejemplos-de-colecciones.html 13/18
);
--Colección: typ_room_tab para representar una lista de muebles.
TYPE typ_room_tab
IS TABLE OF typ_room_rec
INDEX BY PLS_INTEGER;
--Record: typ_people_rec para representar personas.
TYPE typ_people_rec IS RECORD
(
name VARCHAR2(50),
sex CHAR(1),
age NUMBER(2),
kin VARCHAR2(15)
);
--Colección: typ_people_tab para representar un lista de personas.
TYPE typ_people_tab
IS VARRAY(8) OF typ_people_rec;
--Record: typ_estate_rec para representar una casa.
TYPE typ_estate_rec IS RECORD
(
estate_type VARCHAR2(30),
location VARCHAR2(50),
rooms typ_room_tab,
people typ_people_tab
);
--Colección: typ_state_tab para representar un lista de casas.
TYPE typ_state_tab
IS TABLE OF typ_estate_rec;
--Record: typ_owner_rec para representar el dueño de una lista de
casas.
TYPE typ_owner_rec IS RECORD
14. 14/2/24, 02:51 MAGIC PL/SQL ORACLE: Ejemplos de Colecciones
https://magicplsql.blogspot.com/2017/01/ejemplos-de-colecciones.html 14/18
(
owner VARCHAR2(30),
estates typ_state_tab
);
v_owner_rec typ_owner_rec;
v_room_type VARCHAR2(30);
v_room_size VARCHAR2(30);
v_name VARCHAR2(30);
v_sex CHAR(1);
v_age NUMBER(2);
v_kin VARCHAR2(30);
BEGIN
v_owner_rec.owner := 'Moquete';
v_owner_rec.estates := typ_state_tab();
v_owner_rec.estates.EXTEND;
v_owner_rec.estates(1).estate_type := 'Apartamento';
v_owner_rec.estates(1).location := 'San Juan de la Maguana';
FOR i IN 1..5 LOOP
CASE
WHEN i < 3 THEN
v_room_type := 'Baño';
v_room_size := '5 M2';
ELSE
v_room_type := 'Habitación';
v_room_size := '10 M2';
END CASE;
v_owner_rec.estates(1).rooms(i).room_type := v_room_type;
v_owner_rec.estates(1).rooms(i).room_type := v_room_type;
END LOOP;
v_owner_rec.estates(1).people := typ_people_tab();
v_owner_rec.estates(1).people.EXTEND(3);
15. 14/2/24, 02:51 MAGIC PL/SQL ORACLE: Ejemplos de Colecciones
https://magicplsql.blogspot.com/2017/01/ejemplos-de-colecciones.html 15/18
FOR i IN
v_owner_rec.estates(1).people.FIRST..v_owner_rec.estates(1).people.LAST
LOOP
CASE
WHEN i < 2 THEN
v_name := 'Lola';
v_sex := 'F';
v_age := 32;
v_kin := 'Esposa';
WHEN i > 2 THEN
v_name := 'Carlitos';
v_sex := 'M';
v_age := 10;
v_kin := 'Hijo';
ELSE
v_name := 'Lupita';
v_sex := 'F';
v_age := 12;
v_kin := 'Hija';
END CASE;
v_owner_rec.estates(1).people(i).name := v_name;
v_owner_rec.estates(1).people(i).sex := v_sex;
v_owner_rec.estates(1).people(i).age := v_age;
v_owner_rec.estates(1).people(i).kin := v_kin;
END LOOP;
DBMS_OUTPUT.PUT_LINE(LPAD('=',45,'=')||CHR(10)||'Reporte!!!'||CHR(10)|
|LPAD('=',45,'='));
DBMS_OUTPUT.PUT_LINE('Usuario: '||v_owner_rec.owner);
DBMS_OUTPUT.PUT_LINE('Cantidad de Viviendas:
'||v_owner_rec.estates.COUNT);
FOR i IN v_owner_rec.estates.FIRST..v_owner_rec.estates.LAST LOOP
16. 14/2/24, 02:51 MAGIC PL/SQL ORACLE: Ejemplos de Colecciones
https://magicplsql.blogspot.com/2017/01/ejemplos-de-colecciones.html 16/18
Entrada más reciente Entrada antigua
Página Principal
a la/s enero 09, 2017
Etiquetas: Implementaciones
DBMS_OUTPUT.PUT_LINE(LPAD('-',45,'-')||CHR(10)||'Detalles
Vivienda!!!'||CHR(10)||LPAD('-',45,'-'));
DBMS_OUTPUT.PUT_LINE('Tipo: '||v_owner_rec.estates(i).estate_type);
DBMS_OUTPUT.PUT_LINE('Ubicación: '||v_owner_rec.estates(i).location);
DBMS_OUTPUT.PUT_LINE('Cantidad de Habitaciones:
'||v_owner_rec.estates(i).rooms.COUNT);
DBMS_OUTPUT.PUT_LINE('Cantidad de Habitantes:
'||v_owner_rec.estates(i).people.COUNT);
END LOOP;
END;
/
/**/
----OUTPUT:
Escribiendo Código Flexible en Oracle Forms
17. 14/2/24, 02:51 MAGIC PL/SQL ORACLE: Ejemplos de Colecciones
https://magicplsql.blogspot.com/2017/01/ejemplos-de-colecciones.html 17/18
Las Variables de PL/SQL
Objetivos: • Reconocer identificadores válidos y no válidos. • Enumerar
los usos de variables. • Declarar e inicializar va...
JOBS(Tareas) de Base de Datos
Objetivos: • Conocer que es un JOB de Base de Datos. • Familiarizarnos con
el Paquete: DBMS_SCHEDULER . • Conocer sus usos y las ve...
Manejo de Excepciones
Objetivos: • Definir las excepciones de PL/SQL . • Reconocer las
excepciones no controladas(unhandled exceptions). • Listar y utilizar l...
18. 14/2/24, 02:51 MAGIC PL/SQL ORACLE: Ejemplos de Colecciones
https://magicplsql.blogspot.com/2017/01/ejemplos-de-colecciones.html 18/18
Imágenes del tema de luoman. Con tecnología de Blogger.