miércoles, 11 de abril de 2018

Procedimientos almacenados

Un procedimiento almacenado (stored procedure en inglés) es un programa (o procedimiento) almacenado físicamente en una base de datos. Su implementación varía de un gestor de bases de datos a otro. La ventaja de un procedimiento almacenado es que al ser ejecutado, en respuesta a una petición de usuario, es ejecutado directamente en el motor de bases de datos, el cual usualmente corre en un servidor separado. Como tal, posee acceso directo a los datos que necesita manipular y sólo necesita enviar sus resultados de regreso al usuario, deshaciéndose de la sobrecarga resultante de comunicar grandes cantidades de datos salientes y entrantes.
Los procedimientos pueden ser ventajosos: Cuando una base de datos es manipulada desde muchos programas externos. Al incluir la lógica de la aplicación en la base de datos utilizando procedimientos almacenados, la necesidad de embeber la misma lógica en todos los programas que acceden a los datos es reducida. Esto puede simplificar la creación y, particularmente, el mantenimiento de los programas involucrados.
Podemos ver un claro ejemplo de estos procedimientos cuando requerimos realizar una misma operación en un servidor dentro de algunas o todas las bases de datos y a la vez dentro de todas o algunas de las tablas de las bases de datos del mismo. Para ello podemos utilizar a los Procedimientos almacenados auto creables que es una forma de generar ciclos redundantes a través de los procedimientos almacenados.

Diferencias entre procedimientos y macros



Las macros son mas rápidas porque se ejecutan en linea en un programa y los procedimientos son mas lentos a la hora de ejecutar el programa.
Las macros pueden pasar y recibir parámetros.
La escritura de una macro es simple en cambio la de los procedimientos es mas compleja.
Los procedimientos ayudan a reducir el código y los macros lo hacen mas grande.

Ejemplo macros:


Arquitectura física de una base de datos en SQL Server

La forma en la que "vemos" una base de datos, y la manera en que esta base de datos reside o se estructura en un ordenador o un conjunto de ellos puede ser muy diferente. 

Un administrador de bases de datos (DBA) ve:
Mientras que SQL Server ve:
Bases de Datos almacenadas físicamente en archivos
Bases de Datos almacenadas físicamente en archivos
Tablas, índices, vistas y otros objetos colocados en grupos de archivos
Páginas asignadas a tablas e índices
Columnas (campos) filas (registros) y almacenadas en tablas
Información almacenada en paginas

Una Base de Datos se crea sobre un conjunto de archivos de base de datos. La forma en la que se almacene va a afectar en gran media al rendimiento (velocidad) de respuesta ante consultas y actualizaciones.
La página es el nivel inferior de entrada/salida de SQL Server, y es la unidad de almacenamiento fundamental. Las páginas contienen los propios datos o bien información acerca de la disposición física de los datos.
Existen seis tipos de página en SQL Server:

Tipo de Página
Almacena
Datos
Las filas reales (registros) que forman las tablas de datos.
Índice
Los elementos de índice y punteros.
Texto e imagen
Los datos de texto e imágenes
Mapa de Asignación Global
Información acerca de las extensiones empleadas
Página de Espacio Libre
Información acerca del espacio libre en las páginas.
Mapa de Asignación de Índices
Información acerca de las extensiones usadas por una tabla o índice.
Todas las páginas tienen una disposición similar. Todas tienen una cabecera de página de 96 bytes, y un cuerpo que, en consecuencia, ocupa 8.096 bytes. La información almacenada en la cabecera y en el cuerpo depende del tipo de página. El administrador de una base de datos, con sus privilegios, puede examinar el contenido de una página mediente el comando DBCC PAGE.
Un archivo de base de datos puede configurarse para crecer automáticamente, si se desea, o se puede limitar en su crecimiento. La unidad más pequeña de entrada/salida y la estructura básica de almacenamiento es una página de 8 KB. Las páginas de una tabla o índice se agrupan de ocho en ocho, en extensiones. Las extensiones pueden compartirse entre tablas, lo que hace que se desperdicie menos espacio de almacenamiento entre tablas pequeñas. Utilizando grupos de archivos, se puede especificar el archivo (o conjunto de archivos) en el que se debería almacenar una tabla o índice.
Un índice agrupado ordena la tabla de acuerdo a la clave del índice. Los índices no agrupados (también llamados árboles binarios) apuntan a las filas de datos.
El tamaño máximo de un único archivo de base de datos es de 32 TB (treinta y dos billones de bytes), y el tamaño máximo de una base de datos es de 1.048.516 TB.

Programa de multiplicación de números de 2 cifras



;EMU8086
.model small ;Modelo de memoria
.stack

.data  ;Definicion de datos(variables), donde se almacenara informacion
.code 
   ;Variables del primer numero ingresado
   unidades_n1      db ?
   decenas_n1       db ?
  
   ;Variables del segundo numero ingresado
   unidades_n2      db ?
   decenas_n2       db ?
  
   ;Variables temporales para los resultados de la primera multiplicacion
   res_temp_dec_n1  db ?
   res_temp_cen_n1  db ?
  
   ;Variables temporales paara los resultados de la segunda multiplicacion
   res_temp_dec_n2  db ?
   res_temp_cen_n2  db ?
  
   ;Variables para los resultados
   res_unidades     db ?
   res_decenas      db ?
   res_centenas     db ?
   res_uni_millar   db ?
  
   ;Variable de acarreo en multiplicacion
   acarreo_mul      db 0
  
   ;Variable de acarreo en suma
   acarreo_suma     db 0
  
.startup
   ;cls
   mov ah,00h         ;Function(Set video mode)
   mov al,03          ;Mode 80x25 8x8 16
   int 10h            ;Interruption Video

   mov ah,01h         ;Function(character read)
   int 21h            ;Interruption DOS functions
   sub al,30h         ;ajustamos valores
   mov decenas_n1,al  ;[chr1].chr2 * chr3 = ac.r1.r2

   mov ah,01h         ;Function(character read)
   int 21h            ;Interruption DOS functions
   sub al,30h         ;Ajustamos valores
   mov unidades_n1,al ;chr1.[chr2] * chr3 = ac.r1.r2

   mov ah,02h         ;Function(character to send to standard output)
   mov dl,'*'         ;Character to show
   int 21h

   mov ah,01h         ;Function(Read character)
   int 21h            ;Interruption DOS Functions
   sub al,30h         ;Transform(0dec = 30hex)
   mov decenas_n2,al  ;chr1.chr2 * [chr3] = ac.r1.r2
  
   mov ah,01h         ;Function(Read character)
   int 21h            ;Interruption DOS Functions
   sub al,30h         ;Transform(0dec = 30hex)
   mov unidades_n2,al
  
   mov ah,02h         ;Character to send to standar output
   mov dl,'='         ;
   int 21h            ;Interruption DOS functions

   ;Realizamos las operaciones
  
   ;Primera multiplicacion  ; Explicacion utilizando la multiplicacion de 99*99 ->(n1*n2)
   mov al,unidades_n1       ; al=9
   mov bl,unidades_n2       ; bl=9
   mul bl                   ; 9*9=81 -> (al=81)
   mov ah,00h               ;
   AAM                      ; Separa el registro ax en su parte alta y baja
   mov acarreo_mul,ah       ; acarreo_mul = 8
   mov res_unidades,al      ; res_unidades= 1 -> Reultado de unidades
  
   ;Segunda multiplicacion
   mov al,decenas_n1        ; al=9
   mov bl,unidades_n2       ; bl=9
   mul bl                   ; 9*9=81 -> (al=81)
   mov res_temp_dec_n1,al   ; res_temp_dec_n1= 81
   mov bl,acarreo_mul       ; bl= 8
   add res_temp_dec_n1,bl   ; res_temp_dec_n1= 81+8= 89
   mov ah,00h               ;
   mov al,res_temp_dec_n1   ; al= 89
   AAM                      ; Separa el registro ax en su parte alta y baja
   mov res_temp_cen_n1,ah   ; res_temp_cen_n1= 8 
   mov res_temp_dec_n1,al   ; res_temp_dec_n1= 9    
   
   ;Tercera multiplicacion  ; Resultado actual = 000>1
   mov al,unidades_n1       ; al= 9
   mov bl,decenas_n2        ; bl= 9
   mul bl                   ; 9*9=81 -> (al=81)
   mov ah,00h               ;
   AAM                      ; Separa el registro ax en su parte alta y baja
   mov acarreo_mul,ah       ; acarreo_mul= 8
   mov res_temp_dec_n2,al   ; res_temp_dec_n2= 1
                            ;
   mov bl, res_temp_dec_n1  ; bl= 9
   add res_temp_dec_n2,bl   ; res_temp_dec_n2= 1+9= 10
   mov ah,00h               ;
   mov al, res_temp_dec_n2  ; al = 10
   AAM                      ; Separa el registro ax en su parte alta y baja
   mov acarreo_suma, ah     ; acarreo_suma = 1
   mov res_decenas,al       ; res_decenas  = 0 -> Reultado de decenas
  
   ;Tercera multiplicacion  ; Resultado actual = 00>01
   mov al,decenas_n1        ; al= 9
   mov bl,decenas_n2        ; bl= 9
   mul bl                   ; 9*9=81 -> (al=81)
   mov res_temp_cen_n2,al   ; res_temp_cen_n2= 81
   mov bl,acarreo_mul       ; bl= 8
   add res_temp_cen_n2,bl   ; res_temp_cen_n2= 89
   mov ah,00h               ;
   mov al,res_temp_cen_n2   ; al= 89
   AAM                      ; Separa el registro ax en su parte alta y baja
   mov res_uni_millar,ah    ; res_uni_millar = 8
   mov res_temp_cen_n2,al   ; res_temp_cen_n2= 9
                            ;
   mov bl, res_temp_cen_n1  ; bl= 8
   add res_temp_cen_n2, bl  ; res_temp_cen_n2= 17
   mov bl, acarreo_suma     ; bl= 1
   add res_temp_cen_n2,bl   ; res_temp_cen_n2= 17+1= 18
   mov ah,00h               ;
   mov al,res_temp_cen_n2   ; al= 18
   AAM                      ;
   mov acarreo_suma,ah      ; acarreo_suma= 1
   mov res_centenas,al      ; res_centenas= 8 -> Resultado de centenas
  
                            ; Resultado actual= 0>801
   mov bl, acarreo_suma     ; bl= 1
   add res_uni_millar, bl   ; res_uni_millar= 8+1= 9 -> Resultado de unidades de millar
                            ; Reultado actual 9801

   ;Mostramos resultados
   mov ah,02h
   mov dl,res_uni_millar
   add dl,30h
   int 21h
  
   mov ah,02h
   mov dl,res_centenas
   add dl,30h
   int 21h      

   mov ah,02H
   mov dl,res_decenas
   add dl,30h
   int 21h       

   mov ah,02H
   mov dl,res_unidades
   add dl,30h
   int 21h      
.exit
end

jueves, 15 de marzo de 2018

Clase 14 marzo 2018

Memoria
  • Shared Global Area (SGA): es el área más grande de memoria y quizás el más importante
  • Shared Pool: es una caché que mejora el rendimiento ya que almacena parte del diccionario de datos y el parsing de algunas consultas en SQL.El área de memoria que comprende la Shared Pool contiene la “library cache”, “el data dictionary cache” y el “result cache”.

  • El “data dictionary cache” es una especie de metadatos de la base de datos, es en definitiva una colección de tablas y vistas que contienen información de la base de datos, sus estructuras y sus usuarios. Es una zona bastante accedida de la base de datos.
    Otra área es la “library cache”. Es sin duda otra zona bastante concurrida de la base de datos. Oracle representa cada sentencia SQL que se ejecuta con una zona SQL compartida, con lo que Oracle es capaz de reconocer cuando 2 usuarios ejecutan la misma sentencia, y así poder reutilizar la misma área para ambos usuarios. Esta zona de memoria compartida contiene el plan de ejecución, con lo que Oracle ahorra memoria utilizando la misma área para las sentencias que se ejecutan en múltiples ocasiones.
    En la “result cache” se almacenan filas y no bloques. En este área por ejemplo podemos guardar listas de valores muy utilizadas. Para ello tendremos que definir un tipo de Hint especial en nuestras consultas que hagan que los resultados obtenidos se almacenen en esta cache.
  • Redo Log Buffer: contiene un registro de todas las transacciones dentro de la base, las cuales se almacenan en el respectivo archivo de Redo y en caso de siniestro se vuelven a ejecutar aquellos cambios que aún no se hayan reflejado en el archivo de datos (commit).
  • Large Pool: espacio adicional, generalmente usado en casos de multithreading y esclavos de I/O.Esta zona es opcional. El administrador del sistema puede configurarla siempre que quiera reservar memoria para realizar operaciones de backup o recuperación de la base de datos o consultas en paralelo.
  • Java Pool: usado principalmente para almacenar objetos Java.La memoria java pool es usada en la memoria del servidor para todas las sesiones que utilicen código java y datos en la JVM. Esta memoria es usada de diferentes maneras dependiendo del modo en el que la base de datos esté corriendo.


instancia de Oracle

Es el conjunto de procesos del servidor que permiten el acceso a la base de datos. Es un conjunto de estructuras de datos y procesos en memoria. Está formado por: 
SGA. Area global de sistema. Se trata de la zona de memoria común para todos los procesos de servidor, contien las siguientes estructuras de datos fundamentales:
  •  Buffer de caché de base de datos. Almacena bloques de datos leídos de la base de datos a fin de que las próximas consultas no necesiten acudir a disco y se las pueda servir de estos datos en la caché.
  • Buffer redo log. Estructura que almacena los datos anteriores y posteriores a cada instrucción y así facilitar tanto su anulación, como su realización en caso de problemas. 
  •  Large pool. Área de la memoria que proporciona espacio para los datos necesarios para realizar operaciones de backup y restauración, así como los datos de sesión y otros que permitan aliviar el trabajo de la instancia.
  • Shared pool. Consta de la caché del diccionario de datos y de la caché de instrucciones SQL, PL/SQL. De esa forma se acelera la ejecución de consultas e instrucciones que utilicen los mismos metadatos o bien que se traten de instrucciones parecidas a otras anteriormente ejecutadas. 
         - Cache Library.
           -Data Dictionary Cache. 
  • Java Pool. Sólo se usa si hemos instalado Java para agilizar el proceso de las instrucciones en ese lenguaje.
Archivos 
  • Control (ctl): almacenan información acerca de la estructura de archivos de la base.
  • Rollback (rbs): cuando se modifica el valor de alguna tupla en una transacción, los valores nuevos y anteriores se almacenan en un archivo, de modo que si ocurre algún error, se puede regresar (rollback) a un estado anterior.
  • Redo (rdo): bitácora de toda transacción, en muchos dbms incluye todo tipo de consulta incluyendo aquellas que no modifican los datos.
  • Datos (dbf): el tipo más común, almacena la información que es accesada en la base de datos.
  • Indices (dbf) (dbi): archivos hermanos de los datos para acceso rápido.
  • Temp (tmp): localidades en disco dedicadas a operaciones de ordenamiento o alguna actividad particular que requiera espacio temporal adicional.

miércoles, 14 de marzo de 2018

Memoria de una base de datos


Buffer Cache (o Database Buffer Cache)

Su función es mantener bloques de datos más recientemente leídos directamente de los archivos de datos, esto se hace para un mejor desempeño pues si los datos son de nuevo requeridos por un usuario, su acceso es más rápido.

Cuando se procesa una consulta, el servidor busca los bloques de datos requeridos en esta estructura. Si el bloque no se encuentra en esta estructura, el proceso servidor lee el bloque de la memoria secundaria y coloca una copia en esta estructura. De esta forma, otras peticiones que requieran de este bloque de datos no requerirán de acceso a memoria secundaria (lecturas físicas).

Los bloques pueden contener datos modificados que no son permanentemente escritos a disco y los cuales maneja Oracle de una manera consistente para atender la concurrencia de los usuarios conectados a la base de datos, dichos usuarios comparten el acceso a esta área. Los bloques modificados se llamas bloques sucios.


Área de SQL Compartido, Shared SQL Pool

En esta zona se encuentran las sentencias SQL que han sido analizadas. El análisis sintáctico de las sentencias SQL lleva su tiempo y Oracle mantiene las estructuras asociadas a cada sentencia SQL analizada durante el tiempo que pueda para ver si puede reutilizarlas.

Antes de analizar una sentencia SQL, Oracle mira a ver si encuentra otra sentencia exactamente igual en la zona de SQL compartido. Si es así, no la analiza y pasa directamente a ejecutar la que mantiene en memoria. De esta manera se premia la uniformidad en la programación de las aplicaciones. La igualdad se entiende que es lexicográfica, espacios en blanco y variables incluidas.

La base de datos Oracle asigna memoria a la shared pool cuando una nueva instrucción sql se analiza. El tamaño de esta memoria depende de la complejidad de la instrucción. Si toda la shared pool ya ha sido asignada la base de datos Oracle puede liberar elementos de la shared pool hasta que haya suficiente espacio libre para nuevas sentencias. Al liberar un elemento de la shared pool el sql asociado debe ser recompilado y reasignado a otra área de sql compartida la próxima vez que se ejecute.

El contenido de la zona de SQL compartido es:
  • Las sentencias SQL y PL/SQL (texto de la sentencia)
  • Plan de ejecución de la sentencia SQL.
  • Lista de objetos referenciados.

Large Pool

El administrador de la base de datos puede configurar esta área de memoria opcional, para proveer localidades más amplias de memoria para:
  • Memoria de sesiones.
  • Procesos de I/O del servidor
  • Backups de la base de datos y operaciones de recuperación.
Al asignar espacios dentro de large pool para un servidor compartido, Oracle puede usar la shared pool principalmente para guardar en caché las sentencias compartidas de sql y evitar la sobrecarga causada por la disminución de la caché de sql compartida. Además la memoria para backup y operaciones de recuperación y para procesos de I/O del servidor es asignada en buffers de algunos cientos de kilobytes, por lo que la large pool mucho más capaz de satisfacer dicha demanda de memoria que la shared pool.

Java Pool

La memoria java pool es usada en la memoria del servidor para todas las sesiones que utilicen código java y datos en la JVM. Esta memoria es usada de diferentes maneras dependiendo del modo en el que la base de datos esté corriendo.

Algunas de las cuales son:
  • Análisis sintáctico de código y scripts en Java.
  • Tareas de instalación relacionada con aplicaciones Java.
  • Procedimientos almacenados de código Java.
La Java Pool utiliza el algoritmo LRU (Least-Recently-Used), el cual se encarga de mantener en memoria el código Java que se utiliza con mayor frecuencia.