martes, 22 de mayo de 2018

Exposiciones - Lenguajes de interfaz

Equipo # 1 - Programación del puerto paralelo

Un puerto paralelo es una interfaz entre un computador y un periférico, cuya principal característica es que los bits de datos viajan juntos, enviando un paquete de byte a la vez. Es decir, se implementa un cable o una vía física para cada bit de datos formando un bus. Mediante el puerto paralelo podemos controlar también periféricos como focos, motores entre otros dispositivos.

El cable paralelo es el conector físico entre el puerto paralelo y el dispositivo periférico. En un puerto paralelo habrá una serie de bits de control en vías aparte que irán en ambos sentidos por caminos distintos. 

El puerto paralelo de las computadoras, de acuerdo a la norma Centronics, está compuesto por un bus de comunicación bidireccional de 8 bits de datos, además de un conjunto de líneas de protocolo. Las líneas de comunicación cuentan con un retenedor que mantiene el último valor que les fue escrito hasta que se escribe un nuevo dato, las características eléctricas son:

  • Tensión de nivel alto: 3,3 o 5 V
  • Tensión de nivel bajo: 0 V
  • Intensidad de salida máxima: 2,6 mA
  • Intensidad de entrada máxima: 24 mA

Los sistemas operativos basados en DOS y compatibles gestionan las interfaces de puerto paralelo con los nombres LPT1, LPT2 y así sucesivamente (LPT significa Line Print Terminal), mientras que los de tipo Unix los nombran como /dev/lp0, /dev/lp1, y demás. Las direcciones base de los dos primeros puertos son:

  • LPT1 = 0x378
  • LPT2 = 0x278

Para puertos de más de 1 han recomendado a la dirección:




La estructura consta de tres registros: de control, de estado y de datos.

  • El registro de control es un bidireccional de 4 bits, con un bit de configuración que no tiene conexión al exterior, su dirección en el LPT1 es 0x37A.
  • El registro de estado, se trata de un registro de entrada de información de 5 bits, su dirección en el LPT1 es 0x379.
  • El registro de datos, se compone de 8 bits, es bidireccional. Su dirección en el LPT1 es 0x378.

Los pines del puerto paralelo con conector DB25 son:



Las líneas invertidas toman valor verdadero cuando el nivel lógico es bajo. Si no están invertidas, entonces el nivel lógico alto es el valor verdadero.

El pin 25 en el conector DB25 podría no estar conectado a la tierra en computadoras modernas.

Equipo # 2 - Programación del puerto USB

Puerto USB

Un puerto es una localización en la computadora en donde conectamos los periféricos. Estos pueden enviar información a la computadora, recibir información de la misma o hacer ambas cosas. La primer versión del puerto USB apareció en el año de 1997, junto con el lanzamiento del microprocesador Intel Pentium II.



La palabra USB viene de la frase en Ingles “Universal Serial Bus” que se utiliza para describir un tipo de puerto de PC en donde se conectan distintos periféricos tales como impresoras, cámaras fotográficas, teclados de computadoras e infinidad de productos de uso generalizado.




El puerto USB cuenta con la tecnología "Plug&Play" la cual permite conectar, desconectar y reconocer dispositivos sin necesidad de reiniciar o apagar la computadora, a diferencia de sus antecesores. En él se definen los conectores y los cables, una topología especial tipo estrella para conectar hasta 127 dispositivos y protocolos que permiten la detección y configuración automática de los dispositivos conectados

Antes de la creación del puerto USB los periféricos se conectaban mapeados directamente en direcciones de entrada y salida, a cada uno se le asignaba una dirección específica y en algunos casos un canal de acceso directo a memoria. Esto causaba que existiera conflicto en la asignación de los recursos. Además de que cada dispositivo tenía su propio puerto de conexión y utilizaba sus cables específicos, lo que daba lugar a un incremento en los costos. Todo esto en conjunto motivaron a la creación del puerto USB.


Programación del puerto USB

En lenguaje ensamblador, se puede acudir a la interrupción 14H de la ROM-BIOS para configurar, leer, escribir o simplemente para conocer el estado del puerto; cada una de estas cuatro opciones es un servicio de la interrupción, y se seleccionan a través del registro AH. Para configurar o inicializar el puerto serie, bastará con utilizar el servicio 00 de la interrupción, colocando en el registro AL los valores equivalentes a los parámetros.


Configurar el puerto serial para 1200 baudios, sin bit de paridad, sin bit de parada y 8 bits

       
mov ah,0 ;servicio 00 de INT 14h: inicializar puerto 
mov a1,83 ;configuración: 1200 baudios, no paridad 
;un bit de parada, 8 bits de datos 
mov dx,00 ;Seleccionar puerto COM1 
int 14 ;interrupción del BIOS 
mov ah,4c ;servicio 4ch de INT 21h: terminar 
int 21 ;interrupción servicio del DOS
       


Buffer de vídeo en modo texto

Una controladora de vídeo con modo de texto suele usar dos zonas de memoria distintas:

  • Memoria de caracteres: conteniendo la estructura de píxeles de cada carácter de la fuentes en uso.
  • Matriz de pantalla o Buffer de pantalla: conteniendo la matriz de los caracteres mostrados en la pantalla, almacenados como índices a la memoria de caracteres.

La memoria de caracteres suele residir en ROM por defecto. Sin embargo, muchos sistemas también permiten el uso de RAM para este propósito, haciendo posible redefinir el juego de caracteres para fines específicos de cada aplicación. El uso de caracteres residentes en RAM también facilitan algunas técnicas especiales, como la implementación de un buffer de vídeo para gráficos pixelados.


Acceso a discos en lenguaje ensamblador

A continuación algunos servicios de la INT 13h

       
 LEER ESTADO DEL DISCO
AH = 01h (servicio o número de función)
DL = No. de unidad (80h-FFh para discos duros, 128-255 decimal; 0-7Fh para u. de floppy).
 LEER SECTOR(ES)
AH = 02h (servicio o número de función)
AL = número de sectores a leer (Base 1: 1..255)
CH = bits 0-7, No. de cilindro o pista (LSB del No. de cilindro, 10-bits, 0-1023)
CL = bits 6-7, No. de cilindro o pista.
CL = bits 0-5, No. de sector inicial (Base 1: 1-63)
DH = No. de cabezal o lado (Base 0: 0-15, con traducción puede ser 0-255)
DL = No. de unidad (80h-FFh para discos duros, 128-255 decimal; 0-7Fh para u. de floppy)
ES:BX = dirección del buffer E/S.

· ESCRIBIR SECTOR(ES)
AH = 03h (número de la función de escritura)
· OBTENER LOS PARÁMETROS DEL DISCO AH = 08h (número de la función para obener los parámetros de la unidad).
DL = número de unidad (igual que para leer/esribir sectores)
· LECTURA EXTENDIDA DE SECTOR(ES) 
AH = 42h
DL = número de unidad (igual que para leer/esribir sectores)
DS:SI = puntero a la estructura del paquete pedido al disco
       


Vídeo:



Proyecto - Administración de Bases de Datos

Código de la Interfaz y conexión a la base de datos desde Python


       
# -*- coding: utf-8 -*-
import MySQLdb
from tkinter import *
import tkinter.messagebox
from tkinter import ttk

def conectar():
    try:
        global db
        global cur
        db = MySQLdb.connect(host='localhost', password='chocopizza', user='root', db='escuela')
        cur = db.cursor()
        print ("Conexion Correcta")
    except MySQLdb.Error as err:
        print ("MySQL Error: %s" % str(err))

def cerrarS():
    if not db.open:
        print("Cierre incorrecto")
        db.close()
    else:
        print("Cierre Correcto")

def AlDobleClick(a):
    try:
        item = ListaPrincipal.selection()
        borrar(ListaPrincipal.item(item)['values'][0])
    except IndexError as err:
        print("Error de variables: %s" % str(err))

def BorrarCampos():
    EntryNom.delete('0', 'end')
    EntryApeP.delete('0', 'end')
    EntryApeM.delete('0', 'end')
    EntryCor.delete('0', 'end')

def AlSeleccionar(a):
    global indexTupla
    BorrarCampos()
    try:
        item = ListaPrincipal.selection()
        indexTupla = ListaPrincipal.item(item)['values'][0]
        EntryNom.insert('0', ListaPrincipal.item(item)['values'][1])
        EntryApeP.insert('0', ListaPrincipal.item(item)['values'][2])
        EntryApeM.insert('0', ListaPrincipal.item(item)['values'][3])
        EntryCor.insert('0', ListaPrincipal.item(item)['values'][4])
    except IndexError as err:
        print("Error de variables: %s" % str(err))

def VenPrin():
    global VenP
    global EntryNom
    global EntryApeP
    global EntryApeM
    global EntryCor
    global ListaPrincipal
    conectar()

    VenP = Tk()
    VenP.title('Sesión de Administrador')
    VenP.geometry("600x360")
    VenP.resizable(False, False)
    VenP.configure(background='light gray')

    ListaPrincipal = ttk.Treeview(VenP)
    ListaPrincipal.grid(row=0, column=0, columnspan=5)

    ListaPrincipal["columns"] = ["num_cont", "Nombre", "Apellido_P", "Apellido_M", "Correo"]
    ListaPrincipal["show"] = "headings"
    ListaPrincipal.heading("num_cont", text="Nº de control")
    ListaPrincipal.column("num_cont", minwidth=0, width=50, stretch=NO)
    ListaPrincipal.heading("Nombre", text="Nombre")
    ListaPrincipal.column("Nombre", minwidth=0, width=150, stretch=NO)
    ListaPrincipal.heading("Apellido_P", text="Apellido Paterno")
    ListaPrincipal.column("Apellido_P", minwidth=0, width=100, stretch=NO)
    ListaPrincipal.heading("Apellido_M", text="Apellido Materno")
    ListaPrincipal.column("Apellido_M", minwidth=0, width=100, stretch=NO)
    ListaPrincipal.heading("Correo", text="Correo")
    ListaPrincipal.column("Correo", minwidth=0, width=200, stretch=NO)
    ListaPrincipal.bind("", AlDobleClick)
    ListaPrincipal.bind("<>", AlSeleccionar)

    rellenar()

    LabelNom = Label(VenP, text="Nombre: ")
    LabelNom.grid(row=1, column=1, sticky=W)
    EntryNom = Entry(VenP)
    EntryNom.grid(row=1, column=2, sticky=W)

    LabelApeP = Label(VenP, text="Apellido Paterno:")
    LabelApeP.grid(row=1, column=3, sticky=W)
    EntryApeP = Entry(VenP)
    EntryApeP.grid(row=1, column=4, sticky=W)

    LabelApeM = Label(VenP, text="Apellido Materno:")
    LabelApeM.grid(row=2, column=1, sticky=W)
    EntryApeM = Entry(VenP)
    EntryApeM.grid(row=2, column=2, sticky=W)

    LabelCor = Label(VenP, text="Correo:")
    LabelCor.grid(row=2, column=3, sticky=W)
    EntryCor = Entry(VenP)
    EntryCor.grid(row=2, column=4, sticky=W)

    Agregar = Button(VenP, text='Agregar', fg='Green', command=nuevo)
    Agregar.place(relx=0.15, rely=.85, anchor=CENTER)

    Limpiar = Button(VenP, text='Limpiar', fg='Black', command=BorrarCampos)
    Limpiar.place(relx=0.48, rely=.85, anchor=CENTER)

    Editar = Button(VenP, text='Editar', fg='Blue', command=editar)
    Editar.place(relx=0.85, rely=.85, anchor=CENTER)

    rmuser = Button(VenP, text='X', fg='red', command=CerrarSes, font=("Arial", 12))
    rmuser.place(relx=0.95, rely=.90, anchor=CENTER)

    VenP.mainloop()

def CerrarSes():
    cerrarS()
    VenP.destroy()

def rellenar():
    for i in ListaPrincipal.get_children():
        ListaPrincipal.delete(i)

    cur.execute("SELECT * FROM alumnos")
    index = iid = 0
    for row in cur.fetchall():
        ListaPrincipal.insert("", iid, index, values=row)
        index = iid = index + 1  # Contador de columnas

def LlamarProcc(dat):
    cur.callproc('alumnosx', dat)
    db.commit()

def ErrorProc():
    db.rollback()
    tkinter.messagebox.showinfo("Error al conectar", "El procedimiento ha fallado")

def nuevo():
    Nom=EntryNom.get()
    ApeP=EntryApeP.get()
    ApeM=EntryApeM.get()
    Cor=EntryCor.get()
    if len(Nom) != 0 or len (ApeP) != 0 or len(ApeM) != 0:
        cur.execute("SELECT num_cont FROM alumnos ORDER BY num_cont DESC LIMIT 1")
        try:
            VarT = ((cur.fetchone()[0]) + 1)
        except TypeError:
            VarT = 0
        Num = int(VarT)

        Datos = [Num, Nom, ApeP, ApeM, Cor, 'nuevo']
        try:
            LlamarProcc(Datos)
        except:
            ErrorProc()

        rellenar()
    else:
        tkinter.messagebox.showinfo("No ingresaste datos", "Por favor, escribe los datos a guardar")

def borrar(ID):
    result = tkinter.messagebox.askquestion("Se borrará el registro", "¿Estás seguro?", icon='warning')
    if result == 'yes':
        Datos = [ID, EntryNom, EntryApeP, EntryApeM, EntryCor, 'eliminar']
        try:
            LlamarProcc(Datos)
        except:
            ErrorProc()
    rellenar()

def editar():
    Nom = EntryNom.get()
    ApeP = EntryApeP.get()
    ApeM = EntryApeM.get()
    Cor = EntryCor.get()
    Datos = [indexTupla, Nom, ApeP, ApeM, Cor, 'editar']
    try:
        LlamarProcc(Datos)
    except:
        ErrorProc()
    rellenar()

VenPrin()

       


Proyecto y base de datos:

https://mega.nz/#!l48FxLKR!tHLPUsGIdsWtHmD4IFK8jiXugFgTIjxbpp39N6Iptf8

viernes, 18 de mayo de 2018

Programas lenguajes de interfaz

Programa que realiza una resta utilizando macros:

       
restas macro p, s

    mov al, p
    sub al, s
    add al, 30h
    mov resta, al
    mov ah, 09
    lea dx, msj3
    int 21h
    mov ah, 02
    mov dl, resta
    int 21h
    mov ah, 4ch
    int 21h
endm

.model small

.stack 64

.data


    n1 db 0
    n2 db 0
    resta db 0

    msj  db "Dame el primer valor: $"
    msj2 db 10,13, "Dame el segundo valor $"
    msj3 db 10,13, "resta = $"


.code


mov ax, @data
mov ds, ax
mov ah, 09
lea dx, msj
int 21h


mov ah, 01
int 21h
sub al, 30h
mov n1, al

mov ah, 09
lea dx, msj2
int 21h

mov ah, 01
int 21h
sub al, 30h
mov n2, al

restas n1, n2

ret
       



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Macro imprime


       
org 100h



inicio macro   ; Declaramos la macro, le damos el nombre de inicio

  mov ax,@data   ; Cargamos el segmento de datos.
  mov ds,ax
  mov dx,ax

endm


imprime macro numero  ;Nuestra segunda macro se llama imprime, nuestro parametro es numero

  mov ah,02h
  mov dl,numero  ;Indica que mueva al registro DL lo que pasamos como parametro.
  add dl,2Fh  ;suma 2Fh para imprimir el numero real.
  int 21h

endm



.data                                                                  

    mensaje db "Programa de macro que imprime del 9 al 0",13,10,"$"
    mensaje2 db 13,10, "Loop que imprime del 0 al 9",13,10,"$"
    num db 0 ;declaramos nuestra variable.

.code

    mov cx,10
    lea dx,mensaje
    mov ah,09h
    int 21h    

inicio:

    mov num,cl
    imprime num ; Llamamos al macro con el valor de nuestra variable.
    loop inicio ; Se repite el ciclo  


    lea dx,mensaje2
    mov ah,09h
    int 21h

    MOV DL, "0"; Se transfiere la letra 0 al registro de datos en la parte baja del registro DX
    MOV CX, 10; Se transfiere 10 al registro CX
    PRINT_LOOP:; Se comenzara a imprimir hasta acabar las 26 interaciones
    MOV AH, 02; Se transfiere 02 al acumulador de byte alto
    INT 21h; Se efectua la interrupcion del dato ascii leido desde el teclado
    INC DL; Siguiente caracter numerico
    LOOP PRINT_LOOP; Continua hasta acabar las 10 vueltas

end  

       


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Macro que realiza una suma:


       

sumas macro a, b      ; Macro de la suma

    mov al, a         ; Se mueve el primer numero a al
    add al, b         ; A la parte baja del registro AX se le suma el segundo numero (b)
    add al, 30h       ; A la parte baja del registro AX se le suma 30h para obtener de nuevo el numero en decimal
    mov suma, al      ; Se mueve la parte baja del registro AX a suma
    mov ah, 09        ; Salida de cadena de caracteres
    lea dx, msj3      ; Se imprime el mensaje 3
    int 21h           ; Interrupcion
    mov ah, 02        ; Peticion para colocar el cursor
    mov dl, suma      ; Se mueve suma a la parte baja del registro DX
    int 21h           ; Interrupcion
    mov ah, 4ch       ; Se termina el programa
    int 21h           ; Interrupcion

endm

  
.model small          ;Modelo de memoria mas utilizado
.stack 64
.data                 ;segmento de datos con  variables

    n1 db 0
    n2 db 0
    suma db 0

    msj  db "Dame el primer valor: $"
    msj2 db 10,13, "Dame el segundo valor $"
    msj3 db 10,13, "suma = $"

  

.code                 ; Segmento de codigo

mov ax, @data         ; Se mueve data a ax
mov ds, ax            ; Movemos el registro AX a DS
mov ah, 09            ; Salida de una cadena de caracteres
lea dx, msj           ; Se imprime el primer mensaje
int 21h               ; Interrupcion

mov ah, 01            ; Peticion de leer caracter
int 21h               ; Interrupcion
sub al, 30h           ; Se resta 30h para obtener el numero
mov n1, al            ; Se mueve al a n1


mov ah, 09            ; Salida de una cadena de caracteres
lea dx, msj2          ; Se imprime el segundo mensaje
int 21h               ; Interrupcion
mov ah, 01            ; Peticion de leer caracter
int 21h               ; Interrupcion
sub al, 30h           ; Se resta 30h para obtener el numero
mov n2, al            ; Se mueve al a n2


sumas n1, n2          ; Se llama al macro y se le envian los parametros

  

ret

       


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Programa que utiliza una macro para mostrar en pantalla si eres o no mayor de edad:


       
.model small ;modelo de memoria

.stack 64 ;segmento de pila

mmayor macro:    ;declaracion de macro mmayor

    MOV DX,OFFSET mens2;se lee la variable mens2

    MOV AH,9

INT 21H;interupcion del DOS

endm;fin del macro

mmenor macro:  ;declaracion de macro mmenor

    MOV DX,OFFSET mens3se lee la variable mens3

    MOV AH,9;trabaja con la interrupcion

    INT 21H;interrupcion del DOS

endm;fin del macro

finn macro:;declaracion de macro fin

    mov ah,4ch;sentencia para terminar el programa

    int 21h;interrupcion del DOS

    endm;fin del macro

;============================empieza segmento datos

.data

    num1 db 0    ;variable para almacenar la edad

    diez db 10   ;variable para poder imprimir 2 caracteres(se multiplica por el primer numero ingresado,para ser decenas)

    mens db "ingresa tu edad ","$"  ;mensaje inicial

    mens2 db 13,10,"Eres mayor de edad","$" ; Mensaje para mayor de edad

    mens3 db 13,10,"Eres menor de edad","$" ; Mensaje para menor de edad

 ;===================================================termina segmento datos

;=================inicia segmento codigo

.code

    inicio proc far

        mov ax,@data;direccionamos el segmento de datos

        mov ds,ax ;los datos se mueven a ax

        mov ah,09;trabaja con la interrupcion

        lea dx, mens;se lee la variable mens

        int 21h ;interrupcion del DOS
      

        mov ah,01;;espera la entrada del teclado

        int 21h ;interrupcion de DOS

      

        sub al,30h;se le restan 30 para convertir a numero

        mul diez;se multiplica el numero ingresado para convertirlo a decenas
              

        mov num1,al;el resultado se mueve al registro al
      

        mov ah,01;se espera entrada del teclado

        int 21h;interrupcion del DOS
      

        sub al,30h;se tranforma a numero el segundo digito ingresado

        add num1,al ;se suma a las decenas obtenidas

        mov al,num1;se mueva a al el resultado de la suma
   

        cmp al,18;se compara si el contenidos de al es 18

        jge mayor;en caso de ser mayor se salta al proceso mayor

      

        ;=========== de no cumplirse(sea menor a 18)el programa continua a este segmento

        mov ah,09    ;trabaja con la interrupcion

        lea dx,mens3; Se lee la variable mens3

        int 21h; Interrupcion del DOS

        jmp fin; Y salta a proceso fin

      

        ;====================procesos

        mayor:;se declara el proceso mayor

        mmayor; El proceso llama a la MACRO mmayor
 

        fin:;se declara el proceso fin

        finn;el prceso llama al MACRO finn

       

inicio endp   ;se termina a inicio 


       


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 

Macro con archivo TXT
       

include 'macros.txt'

data segment
    var dw 6
    ends

main proc
   mov bx,1
   mov ax,1
   m_suma bx
   m_final
end main



Contenido del archivo .txt



m_final macro
mov ah, 4ch
int 21h
endm


m_suma macro var
add ax, bx
endm
       

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
Macro que se manda a llamar con diferentes archivos de texto TXT


       
MyMacro MACRO p1, p2, p3

    MOV AX, p1

    MOV BX, p2

    MOV CX, p3

ENDM

ORG 100h

include 'MyMacro1.txt'

include 'MyMacro2.txt'

    
ret

PRIMER ARCHIVO DE TEXTO:  MyMacro1.txt   
                                

MyMacro 1, 2, 3
                    

SEGUNDO ARCHIVO DE TEXTO:  MyMacro2.txt   

MyMacro 4, 5, DX

       


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Programa que imprime números a partir de macros


       

imprime macro numero  ;Nuestra macro se llama imprimir, nuestro parámetro es numero

  mov ah,02h
  mov dl,numero  ;Indica que mueva al registro DL lo que pasamos como parámetro.
  add dl,30h  ;suma 30h para imprimir el número real.
  int 21h

endm

lup macro 
    mov num,cl
    imprime num ;Llamamos al macro con el valor de nuestra variable.
    loop inicio ;repite ciclo
endm

Fin macro
    mov ah,04ch ;Finaliza el programa.
    int 21h
    endm

.model small
.stack 64
.data

  num db 0  ;declaramos nuestra variable.

.code
  mov cx,9
inicio:   
    lup  

  Fin
end
       

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Programa que utiliza macros para mostrar mensaje de buenos días

       

FIN MACRO 
MOV AH, 4CH  ;TERMINACION DEL PROGRAMA
INT 21H       

ENDM

;---------------------------------------------------

PILA SEGMENT PARA STACK "STACK"
DB 200 DUP (0)                     ;ESPACIO DE LAS INSTRUCCIONES
PILA ENDS

;---------------------------------------------------

DATOS SEGMENT PARA "DATA" ;DATOS A INGRESAR
VA DB "DESPUES DE MEDIO DIA (Y/N): ","$" ;SELECCION DE INICIO DEL PROGRAMA
VD DB 13,10," BUENOS DIAS","$"           ;MENSAJES MOSTRADOS EN PANTALLA                
VT DB 13,10," BUENAS TARDES","$"         ;MENSAJES MOSTRADOS EN PANTALLA
DATOS ENDS

;---------------------------------------------------

CODIGO SEGMENT PARA "CODE"
EMPIEZA PROC FAR
ASSUME CS: CODIGO, DS: DATOS, SS: PILA

MOV AX, DATOS   ;MANDAR LLAMAR A DATOS
MOV DS, AX

MOV AH, 0FH
INT 10H
MOV AH, 00H
INT 10H 


MOV DX,OFFSET VA   ;IMPRIMIR MENSAJE "DESPUES DE MEDIO DIA"
MOV AH,9
INT 21H

CALL PREGUNTA

EMPIEZA ENDP


PREGUNTA PROC NEAR     ;Inicia el 


MOV AH, 01H   ;ESPERA UNA ACCION
INT 21H


CMP AL, "Y"   ;Asignar una accion a una tecla
JZ TARDES

CMP AL, "N"   ;Asignar una accion a una tecla
JZ DIAS


CMP AL, "y"   ;Asignar una accion a una tecla
JZ TARDES

CMP AL, "n"   ;Asignar una accion a una tecla
JZ DIAS   

TARDES: 

MOV DX, OFFSET VT   ;IMPRIMIR MENSAJE "BUENOS TARDES"
MOV AH, 09
INT 21H

FIN

DIAS:

MOV DX, OFFSET VD   ;IMPRIMIR MENSAJE "BUENOS DIAS"
MOV AH, 09
INT 21H 

FIN


RET

PREGUNTA ENDP   ;FIN DE PREGUNTA PROC

CODIGO ENDS

END EMPIEZA
       
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Hacer programa que realice una multiplicación

       
.model small

.stack



.data        ;definición de datos(variables), donde se almacenara información

.code

   chr1  db ? ;primer digito
   chr2  db ? ;segundo digito
   chr3  db ? ;multiplo
   chr4  db ?
   r1    db ? ;resultado 1
   r2    db ? ;resultado 2
   r3    db ?
   r4    db ?
   ac    db 0 ;acarreo
   ac1   db 0

.startup

   ;cls

   operacion macro a, b, c, d ;creacion de macro operacion con 4 parametros
   mov al,a  ;unidad del segundo numero
   mov bl,b  ;unidad del primer numero
   mul bl       ;multiplicar
   mov ah,0     ;limpiamos ah0

   aam          ;separamos de hex a dec
   mov ac1,ah   ;decenas del primera multiplicacion
   mov r4,al    ;unidades del primera multiplicacion
           
   mov al,a  ;unidades del segundo numero
   mov bl,d  ;decentas del primer numero
   mul bl       ;multiplicar
   mov r3,al    ;movemos el resultado de la operacion a r3
   mov bl,ac1   ;movemos el acarreo a bl
   add r3,bl    ;sumamos resultado mas acarreo
   mov ah,00h   ;limpiamos ah por residuos
   mov al,r3    ;movemos el resultado de la suma a al
   aam          ;separamos  de hex a dec

   mov r3,al    ;guardamos unidades en r3
   mov ac1,ah   ;guardamos decenas en ac1

   
   mov al,c    ;al = chr3
   mov bl,b    ;bl = chr2
   mul bl         ;AL = chr3*chr2 (BL*AL)
   mov Ah,0h      ;
   AAM            ;ASCII Adjusment
   mov ac,AH      ;ac = AH (Acarreo)
   mov r2,AL      ;r2 = AL       (Unidad del resultado)

   mov al,c    ;AL = chr3
   mov bl,d    ;BL = chr1
   mul bl         ;AL = chr1*chr3 (BL*AL)
   mov r1,al      ;r1 = AL       (Decena del resultado)
   mov bl,ac      ;BL = Acarreo anterior
   add r1,bl      ;r1 = r1+ac (r1 + Acarreo)
   mov ah,00h     ;
   mov al,r1      ;AL = r1 (Asignaci?n para el ajust)
   AAM            ;ASCII Adjustment
   mov r1,al      ;r1 = AL
   mov ac,ah      ;ac = AH (Acarreo para la Centena del resultado)
   endm
  
   ;suma final
   ;R4 resulta ser las unidades de mul y no se toma en cuenta ya que se pasa entero

 
   suma macro respuesta3,respuesta2,respuesta1,acomulador ;creacion de macro suma con 4 parametros
   mov ax,0000h   ;limpiamos ax  

   mov al,respuesta3      ;movemos el segundo resultado de la primera mult a al
   mov bl,respuesta2      ;movemos primer resultado de la segunda mult a bl
   add al,bl      ;sumamos
   mov ah,00h     ;limpiamos ah
   aam            ;separamos hex a dec

   mov respuesta3,al      ;r3 guarda las decenas del resultado final
   mov respuesta2,ah      ;r2 se utiliza como nuevo acarreo
  
   mov ax,0000h   ;''''
  

   mov al,acomulador     ;movemos el acarreo de la primera mult a al
   mov bl,respuesta1      ;movemos segundo resultado de la segunda mult a bl
   add al,respuesta2      ;sumamos el nuevo  acarreo de la suma anterior  a al
   add al,bl      ;sumamos al a bl
   mov ah,00h     ;limpiamos el registro ah
   aam            ;separamos de hex a dec

   mov respuesta1,al      ;r1 guarda las centenas
   mov respuesta2,ah      ;ah se sigue utilizando como acarreo  

   mov al,respuesta2      ;movemos el acarreo a al
   mov bl,ac      ;movemos ac a bl
   add al,bl      ;sumamos al a bl
   ;aam            ;separamos hex a dec
   mov ac,al      ;mov al a ac como nuestro acarreo final
   endm
  
   mov ah,00h     ;Function(Set video mode)
   mov al,03      ;Mode 80x25 8x8 16
   int 10h        ;Interruption Video

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

   mov ah,01h     ;Function(character read) Guarda en AL
   int 21h        ;Interruption DOS functions
   sub al,30h     ;Ajustamos valores
   mov chr2,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) Guarda en AL
   int 21h        ;Interruption DOS Functions
   sub al,30h     ;Transform(0dec = 30hex)
   mov chr3,al    ;chr1.chr2 * [chr3] = ac.r1.r2
  
   mov ah,01h     ;Function(Read character) Guarda en AL
   int 21h        ;Interruption DOS Functions
   sub al,30h     ;Transform(0dec = 30hex)
   mov chr4,al    ;chr1.chr2 * [chr3] = ac.r1.r2


   mov ah,02h     ;Character to send to standar output
   mov dl,'='     ;
   int 21h        ;Interruption DOS functions

  
   ;Realizamos operacion
   operacion chr4,chr2,chr3,chr1 ;llamada al macro con parametros
   suma r3,r2,r1,ac1 ;llamada al macro con parametros


   mov ah,02h
   mov dl,ac
   add dl,30h
   int 21h        ;Mostramos ac (millar)


   mov ah,02H
   mov dl,r1
   add dl,30h
   int 21h        ;Mostramos r1 (centena)


   mov ah,02H
   mov dl,r3
   add dl,30h
   int 21h        ;Mostramos r3 (decena)
  
   mov ah,02H
   mov dl,r4
   add dl,30h
   int 21h        ;unidad      

.exit

end


       

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Macro del segmento de datos
       
inicio macro   ;declaramos la macro, le damos el nombre de inicio
mov ax,data   ;Cargamos el segmento de datos.
mov ds,ax
mov dx,ax
endm

.model small
.stack 64
.data

msj db "Este es mi primer macro",10,13,"$"

.code

inicio  ;Llamamos al macro, lo unico que hace es cargar msj del segmento de datos.

mov ah,09h
lea dx,msj ;puede ser mov dx,offset msj
int 21h ;interrupcion
mov ax,4c00h ;Sale del programa
int 21h  ;interrupcion

end

       

martes, 8 de mayo de 2018

Unidad III y IV de Administración de bases de datos

Unidad # 3 - Configuración y administración del espacio en disco

3.1 Estructuras lógicas de almacenamiento 


Una base de datos está formada por una o varias unidades lógicas llamadas tablespaces. Un tablespace es la unidad de almacenamiento lógico. Además, cada una de estos tablespaces está formada por uno o varios ficheros físicos que son los datafiles. Un datafile solamente puede pertenecer a un tablespace. Por lo tanto, los datafiles de una base de datos son todos los datafiles que forman parte de todos los tablespaces de la base.



Cuando se crea una base de datos, lleva implícita la creación de 3 ó 4 tablespaces que son:
  • SYSTEM: es el tablespace principal de la base de datos, donde se almacena el diccionario de datos y el tablespace por defecto de todos los demás usuarios si no les asignamos otro distinto.
  • SYSAUX: Es principalmente donde se almacenan las metricas del sistema, los snapshots y demás estadísticas. Si no tenemos cuidado con la configuración de nuestra base de datos a nivel de tiempo de retención de toda esta recopilación de métricas, podemos tener problemas en el futuro con el tamaño de este tablespace.
  • UNDO: Es el tablespace de rollback de la base de datos y es obligatorio crearlo siempre y cuando tengamos el parámetro UNDO_MANAGEMENT=AUTO, si su valor es MANUAL, se crearán segmentos de rollback en el tablespace system en lugar del tablespace UNDO.
  • TEMP: Es un tablespace temporal, el cual se utiliza para realizar las ordenaciones y agrupaciones en las queries, dejando luego libre el espacio que se ha utilizado. Se pueden crear varios tablespaces TEMP en la base de datos, habiendo un parámetro global que indica cual va a ser utilizado por defecto, pero teniendo también la posibilidad de definir un temporary tablespace a nivel de schema.


En la base de datos tenemos dos tablas en las que podemos consultar la informacion de nuestros tablespaces, V$TABLESPACE y DBA_TABLESPACES.

Segmentos
Un segmento almacena la información de una estructura lógica de Oracle dentro de un Tablespace. Está formado por una o más extensiones y, a medida que va creciendo el segmento se van asignando nuevas extensiones al mismo. Hay cuatro tipos de segmentos: de datos, de índices, temporales y de rollback.

Tendremos segmentos de datos para tablas, segmentos de índices para índices, segmentos de rollback para poder deshacer o rehacer cambios por transacciones y segmentos temporales.

Un segmento de datos es el lugar donde se almacenan todos los datos de una tabla, de una partición de una tabla o de un cluster de tablas. Se crea el segmento de datos a la hora de ejecutar la sentencia create que crea la tabla, cluster o partición. En dicha sentencia se indican también los valores de la cláusula storage, en el cuál se va a determinar la forma en que dicho segmento va a ir asignando y desasignando las extensiones.

Podemos consultar la informacion de los segmentos en la tabla:

 DBA_SEGMENTS.

Extensiones
Una extensión es una unidad lógica de almacenamiento que está formada por un número determinado de bloques de datos contiguos. La agrupación de una o varias extensiones forman un segmento que puede ser una tabla, un índice, un segmento de rollback o un segmento temporal. Por lo tanto, datos de una tabla, sabemos que están en un solo segmento de tipo tabla, que a su vez estará formado por una o varias extensiones y que, cada una de esas extensiones está formada por un número determinado de bloques de datos.

Bloques
El bloque es la unidad mínima de almacenamiento en Oracle y podemos elegir el tamaño en el momento de la creación de nuestra base de datos, dependiendo del uso que vayamos a dar a la misma y no pudiendo modificar este dato, más que en ciertos upgrades a versiones más modernas del producto.

Para una mayor optimizacion del rendimiento de I/O, Oracle recomienda que el tamaño del bloque sea multiplo del tamaño del OS block (bloque del sistema operativo).
Todos los bloques de una base de datos poseen la siguiente estructura:
  • Cabecera. Contiene información general sobre el bloque como el tipo de segmento al que pertenece (índice, tabla, rollback) o la dirección del bloque.
  • Directorio de Tablas.  Contiene información acerca de las tablas que tienen datos en el bloque.
  • Directorio de Filas. Contiene información sobre las filas que se encuentran en cada momento en el bloque. Esta información incluye la dirección de la fila dentro de la subzona “Datos de Filas” del bloque en la que debe buscar Oracle los datos. El espacio ocupado por esta subzona va aumentando a medida que se insertan nuevas filas en el bloque, sin embargo, nunca se libera el espacio. Si se borran filas de datos que estaban en el bloque, en el directorio de filas desaparecerá la entrada que apuntaba a ellas, pero el espacio permanecerá reservado, aunque vacío. A medida que se insertan nuevas filas de datos en el bloque, también se insertan registros en el Directorio de Filas, pero antes de aumentar el tamaño de esta subzona para la nueva entrada, se comprueba si alguna de las entradas que hay está vacía y en ese caso se “ocupa” y no hace falta que crezca más la subzona.
  • Espacio Libre. Esta subzona está reservada para la inserción de nuevas filas en el bloque o, para la modificación de campos que requieren más espacio que el que tenían con anterioridad. Esto último ocurre, por ejemplo, con los campos que son de tipo varchar2.Si en el bloque se están almacenando datos de segmentos de tipo tabla o índice, en la subzona de Espacio Libre también se utiliza para llevar un registro de las transacciones que en cada momento acceden a datos del bloque. Se necesita una entrada de transacción siempre que se realice una insert, update, delete o select for update sobre filas del bloque. El tamaño necesario para cada una de las entradas de transacciones depende del sistema operativo.
  • Datos de Filas. En esta subzona se almacenan los datos de las tablas o de los índices del bloque. Se puede dar el caso de que una fila no entre completa en el bloque y tenga que ocupar más de un bloque. Este caso especial se comentará más a fondo en el apartado de encadenamiento y migración de filas.


3.1.1 Definición de espacio de almacenamiento 

Almacenamiento físico de bases de datos
La mayoría de las bases de datos se almacenan en las llamadas memorias secundarias, especialmente discos duros, aunque, en principio, pueden emplearse también discos ópticos, etc.

Las razones por las cuales las bases de datos se almacenan en memorias secundarias son:
En general, las bases de datos son demasiado grandes para entrar en la memoria primaria.
  • La memoria secundaria suele ser más barata que la memoria primaria (aunque esta última tiene mayor velocidad).
  • La memoria secundaria es más útil para el almacenamiento de datos permanente, puesto que la memoria primaria es vólatil.

En cuanto al respaldo de las bases de datos, suelen emplearse tanto discos duros, como cintas magnéticas, discos ópticos o similares.

Técnicas de almacenamiento y recuperación de bases de datos
Las técnicas empleadas para almacenar bases de datos son sumamente importantes para la velocidad de acceso y recuperación de datos. Las técnicas dependen del tipo de almacenamiento, el uso que se le da o se le dará a la base de datos, la estructura de la misma, el sistema gestor de bases de datos empleado, etc.

Esta dependencia no significa necesariamente que haya que cambiar la estructura de la base de datos si se cambian las técnicas empleadas. Las técnicas de almacenamiento son independientes de la base de datos, pero, de todas maneras, las mejores técnicas muchas veces pueden determinarse viendo la estructura de la base de datos, entre otras características.

Los encargados de elegir estas técnicas son los diseñadores y administradores de bases de datos, y dependen también de las capacidades del SGBD. En general, el SGBD ofrece diferentes opciones y técnicas para organizar los datos.

La idea es que los encargados de la base de datos encuentren las técnicas idóneas, o sea, aquellas que permitan la mayor velocidad posible de acceso a los datos. Una mala decisión en esta área puede resultar en una menor velocidad de acceso a la base de datos, o en un uso excesivo del espacio de almacenamiento, o incluso, puede aumentar la velocidad de consulta de una base de datos, pero disminuir la velocidad de actualización de la misma.

3.1.2 El almacenamiento en archivos de las bases de datos


Las bases de datos se almacenan en ficheros o archivos. Existen diferentes formas de organizaciones primarias de archivos que determinan la forma en que los registros de un archivo se colocan físicamente en el disco y, por lo tanto, cómo se accede a éstos.


Las distintas formas de organizaciones primarias de archivos son:


  • Archivos de montículos (o no ordenados): esta técnica coloca los registros en el disco sin un orden específico, añadiendo nuevos registros al final del archivo.
  • Archivos ordenados (o secuenciales): mantiene el orden de los registros con respecto a algún valor de algún campo (clave de ordenación).
  • Archivos de direccionamiento calculado: utilizan una función de direccionamiento calculado aplicada a un campo específico para determinar la colocación de los registros en disco.
  • Árboles B: se vale de la estructura de árbol para las colocaciones de registros.

Existe una segunda forma de acceder a los datos llamada organización secundaria o estructura de acceso auxiliar. Estas permiten que los accesos a los registros de un archivo basado en campos alternativos, sean más eficientes que los que han sido utilizados para la organización primaria de archivos.


El DBMS asigna espacio de almacenamiento a las bases de datos cuando los usuarios introducen create database o alter database. El primero de los comandos puede especificar uno o más dispositivos de base de datos, junto con la cantidad de espacio en cada uno de ellos que será asignado a la nueva base de datos. 

Si se utiliza la palabra clave default o se omite completamente la cláusula on, el DBMS pone la base de datos en uno o más de los dispositivos predeterminados de base de datos especificados en master..sysdevices

Para especificar un tamaño (en este ejemplo, 4MB) para una base de datos que se va a almacenar en una ubicación predeterminada, utilice on default = size de esta forma:
create databasenewpubson default = 4

Para situar la base de datos en dispositivos específicos, dé el nombre del dispositivo o dispositivos en que desea almacenarla. Como la sintaxis indica, puede solicitar que se almacene en más de un dispositivo de base de datos, con una cantidad de espacio diferente en cada uno.Todos los dispositivos mencionados en create database deben estar enumerados en sysdevices

En otras palabras, deben haberse inicializado con disk init. La instrucción siguiente crea la base de datos newdb y asigna 3MB en mydata y 2MB en newdata

Warning! A menos que cree una base de datos pequeña o que no sea crucial, sitúe siempre el diario en un dispositivo de base de datos aparte.

Si la cantidad de espacio solicitada a un dispositivo específico de base de datos no está disponible, el DBMS crea la base de datos con tanto espacio como sea posible en cada dispositivo y muestra un mensaje informando el espacio asignado en cada uno. (Esto no se considera un error.) 

Si hay menos espacio del mínimo necesario para una base de datos en el dispositivo especificado (o en el predeterminado, si no se especifica un nombre), el comando create database falla.


3.1.3 Bitácoras

Una partición de disco, en mantenimiento, es el nombre genérico que recibe cada división presente en una sola unidad física de almacenamiento de datos. Toda partición tiene su propio sistema de archivos (formato); generalmente, casi cualquier sistema operativo interpreta, utiliza y manipula cada partición como un disco físico independiente, a pesar de que dichas particiones estén en un solo disco físico. 

Una partición de un disco duro es una división lógica en una unidad de almacenamiento (por ejemplo un disco duro o unidad flash), en la cual se alojan y organizan los archivos mediante un sistema de archivos. Existen distintos esquemas de particiones para la distribución de particiones en un disco. Los más conocidos y difundidos son MBR (Master Boot Record) y GPT (GUID Partition Table). Las particiones, para poder contener datos tienen que poseer un sistema  de archivos. El espacio no asignado en un disco no es una partición, por lo tanto no puede tener un sistema de archivos.

Existen múltiples sistemas de archivos con diferentes capacidades:
FAT, NTFS, FAT32, EXT2, EXT3, EXT4, Btrfs, FedFS, ReiserFS, Reiser4 u otros.

Los discos ópticos (DVD, CD) utilizan otro tipo de particiones llamada UDF (Universal Disc Format) Formato de Disco Universal por sus siglas en inglés, el cual permite agregar archivos y carpetas y es por ello que es usado por la mayoría de software de escritura por paquetes, conocidos como programas de grabación de unidades ópticas. Este sistema de archivos es obligatorio en las unidades de (DVD) pero también se admiten en algúnos (CD).



En Windows, las particiones reconocidas son identificadas con una letra seguida por un signo de doble punto (p.ej. C:\). prácticamente todo tipo de discos magnéticos y memorias flash (como pendrives) pueden particionarse. 

En sistemas UNIX y UNIX-like las particiones de datos son montadas en un mismo y único árbol jerárquico, en el cual se montan a través de una carpeta, proceso que sólo el superusuario (root) puede realizar.
  • Algunos sistemas de archivos (por ejemplo, versiones antiguas de sistemas FAT de Microsoft) tienen tamaños máximos más pequeños que los que el tamaño que proporciona un disco, siendo necesaria una partición de tamaño pequeño, para que sea posible el adecuado funcionamiento de este antiguo sistema de archivos.
  • Se puede guardar una copia de seguridad de los datos del usuario en otra partición del mismo disco, para evitar la pérdida de información importante. Esto es similar a un RAID, excepto en que está en el mismo disco.
  • En algunos sistemas operativos aconsejan más de una partición para funcionar, como, por ejemplo, la partición de intercambio (swap) en los sistemas operativos basados en Linux.
  • A menudo, dos sistemas operativos no pueden coexistir en la misma partición, o usar diferentes formatos de disco “nativo”. La unidad se particiona para diferentes sistemas operativos.


3.1.4 Particiones


Partición.

Parte del disco duro. En muchos casos puede ser el espacio completo del disco duro.
El almacenamiento en un disco duro ha sido desde hace mucho tiempo el método normal de almacenamiento para las computadoras modernas, desde las computadoras centrales a los equipos de escritorio, y es poco probable que cambie, considerando incluso las opciones de almacenamiento más ricas que se han añadido en Windows 2000.

RAID (Array redundante de discos independientes) es un término usado para describir una técnica que ha aparecido como una solución final exotérica para una suposición normal en la mayoría de los servidores. Hace siete u ocho años, RAID no era un término demasiado conocido, aunque el  artículo original en el que se definía RAID se escribió en 1988. Hasta hace poco, la mayoría de los sistemas de servidor dependían de discos duros caros y de gran calidad, con una frecuente copia de seguridad. 

Las copias de seguridad todavía son críticas, pero ahora se puede utilizar uno u otro  formato de RAID para proporcionar una protección sustancial frente a fallos de disco duro. Aún más, esta protección cuesta mucho menos de lo que costaban aquellos enormes discos de servidor. 

RAID se puede implementar a nivel de software o de hardware. Cuando se implementa a nivel de hardware, el vendedor del hardware proporciona una interfaz de administración para los arrays y las unidades para admitir que pueda trabajar con los diversos sistemas operativos. Windows 2000 implementa los niveles 01 y 5 de RAID en software.

Las copias de seguridad todavía son críticas, pero ahora se puede utilizar uno u otro formato de RAID para proporcionar una protección sustancial frente a fallos de disco duro. Aún más, esta protección cuesta mucho menos de lo que costaban aquellos enormes discos de servidor. 


3.1.5 Espacios Privados

Un «espacio privado» permite que los administradores y redactores gestionen el conjunto de datos del sitio. Algunas bases de datos tienen estos espacios privados llamados comúnmente paneles de control, que son formularios que aparecen al abrir la base de datos. 

Los paneles de control sirven de "puerta principal" o "recibidor" de una base de datos en el sentido de que dirigen a las personas hacia determinadas tareas, como introducir o buscar datos. Sirven también para mantener alejados a los usuarios de las tablas que contienen los datos en tiempo real. 

Cuando reciba una base de datos, debe adentrarse más allá del panel de control para averiguar cómo están estructurados los datos, pero merece la pena echar un vistazo inicial al panel de control. Le puede ofrecer algún indicio sobre las tareas que el diseñador de la base de datos consideró que realizarían los usuarios habitualmente con los datos. 

Puede hacer clic en los vínculos del panel de control para ver qué objetos, como formularios e informes, abren.


3.1.5 Espacios para objetos

Los DBMS se basan en archivos para almacenar datos, y estos archivos, o conjuntos de datos, residen en medios de almacenamiento, o dispositivos. Una buena parte del trabajo del DBA implicará la planificación para el almacenamiento real de la base de datos. Algunas tecnologías de almacenamiento son más adecuadas que otras. Sin embargo, la naturaleza mecánica de la unidad de disco los hace más vulnerables al fracaso de los componentes de otro equipo. Además, las formas en que las unidades de disco son utilizados por las bases de datos pueden hacer que la gestión del almacenamiento impredecibles, como la barra lateral "Modern DBMS de uso de disco“ Puede usarse RAID para mejorar la seguridad de los datos. 

Para aplicaciones de misión crítica la integridad de los datos puede ser más importante que la disponibilidad de datos. Si el soporte es poco fiable y un fallo de las causas de corrupción de datos, los datos perdidos pueden ser más de un problema que el tiempo de inactividad. Es imperativo, por tanto, que las soluciones de almacenamiento de base de datos para protegerlos a toda costa. La recuperación de datos desde medios de almacenamiento lleva mucho más tiempo en completarse que la recuperación de datos desde la memoria caché o la memoria.

El rendimiento de la base de datos depende de la entrada y salida a disco. La cantidad de datos almacenados es mayor que nunca antes, y los datos se almacenados por más tiempo. Algunos DBMS permiten al tamaño de los archivos temporales de expandirse y contraerse de forma automática. Dependiendo del tipo y la naturaleza de las operaciones de base de datos en proceso, esta fluctuación puede provocar picos de uso del disco. El crecimiento de la capacidad de almacenamiento aumenta aún más la complejidad de la  gestión de datos y bases de datos. Muchas organizaciones están implementando nuevas tecnologías de almacenamiento, tales como almacenamiento en red (NAS) y redes de área de almacenamiento (SAN), para ayudar a controlar la cantidad cada vez mayor de almacenamiento necesario para los usos modernos. 

La gestión del almacenamiento en el entorno dinámico de hoy es una tarea difícil DBA. Hay muchos problemas de almacenamiento que deben ser resueltos antes de que un DBA pueda crear una base de datos. Uno de los temas más importantes es la cantidad de espacio para permitir la base de datos. El cálculo espacial debe tener en cuenta no sólo tablas, índices, sino también, y dependiendo del DBMS, el registro de transacciones. Cada una de estas entidades probablemente requerirá un archivo separado o conjunto de datos, para el almacenamiento persistente.


Un segment es aquel espacio reservado por la base de datos, dentro de un datafile, para ser utilizado por un solo objeto. Así una tabla (o cualquier otro objeto) está dentro de su segmento, y nunca podrá salir de él, ya que, si la tabla crece, el segmento también crece con ella. Físicamente todo objeto en base de datos no es más que un segmento dentro de un datafile. Se puede decir que, un segmento es a un objeto de base de datos, lo que un datafile a un tablespace; el segmento es la representación física del objeto en base de datos (el objeto es solo una definición lógica).

Los segmentos son los equivalentes físicos de los objetos que almacenan datos. El uso efectivo de los segmentos requiere que el DBA conozca los objetos, que utiliza una aplicación, cómo los datos son introducidos en esos objetos y el modo en que serán recuperados. Un segmento está constituido por secciones llamadas extensiones, que son conjuntos contiguos de bloques Oracle. Una vez que una extensión existente en un segmento no puede almacenar más datos, el segmento obtendrá del espacio de tabla otra extensión. Este proceso de extensión continuará hasta que no quede más espacio disponible en los ficheros del espacio de tablas, o hasta que se alcance un número máximo de extensiones por segmento.

Existen 5 tipos de segmento:

De datos:


De índices:


De rollback:


Temporales:


De bootstrap:


3.3 Memoria Compartida

Memoria compartida distribuida
Los sistemas de memoria compartida distribuida (DSM) representan la creación hibrida de dos tipos de computación paralelos: la memoria distribuida en sistemas multiprocesador y los sistemas distribuidos. Ellos proveen la abstracción de memoria compartida en sistemas con memorias distribuidas físicamente y consecuentemente combinan las mejores características de ambos enfoques. Debido a esto, el concepto de memoria compartida distribuida es reconocido como uno de los enfoques más atractivos para la creación de sistemas escalables, de alto rendimiento de sistemas multiprocesador.

Memoria compartida basada en páginas
El esquema de DSM propone un espacio de direcciones de memoria virtual que integra la memoria de todas las computadoras del sistema, y su uso se realiza mediante paginación. Las páginas quedan restringidas a estar necesariamente en un único nodo. Cuando un programa intenta acceder a una posición virtual de memoria, se comprueba si esa página se encuentra de forma local. Si no se encuentra, se provoca un fallo de página, y el sistema operativo solicita la página al resto de nodos. El sistema funciona de forma análoga al sistema de memoria virtual tradicional, pero en este caso los fallos de página se propagan al resto de ordenadores, hasta que la petición llega al nodo que tiene la página virtual solicitada en su memoria local. A primera vista este sistema parece más eficiente que el acceso a la memoria virtual en disco, pero en la realidad ha mostrado ser un sistema demasiado lento en ciertas aplicaciones, ya que provoca un tráfico de páginas excesivo. Una mejora dirigida a mejorar el rendimiento sugiere dividir el espacio de direcciones en una zona local y privada y una zona de memoria compartida, que se usará únicamente por procesos que necesiten compartir datos. Esta abstracción se acerca a la idea de programación mediante la declaración explícita de datos públicos y privados, y minimiza el envío de información, ya que sólo se enviarán los datos que realmente vayan a compartirse.


3.4 Instancias múltiples

Una instancia de Motor de base de datos funciona como un servicio que controla todas las solicitudes de aplicación para trabajar con datos de cualquiera de las bases de datos administradas por dicha instancia. Es el destino de las solicitudes de conexión (inicios de sesión) de aplicaciones.

La conexión se ejecuta en una conexión de red si la aplicación y la instancia están en equipos independientes. 

Si la aplicación y la instancia están en el mismo equipo, la conexión de SQL Server se puede ejecutar como una conexión de red o una conexión en memoria. Cuando una conexión se ha completado, una aplicación envía instrucciones Transact-SQL a través de la conexión hasta la instancia. La instancia resuelve las instrucciones de Transact-SQL en operaciones con los datos y objetos de las bases de datos y, si se han concedido los permisos necesarios a las credenciales de inicio de sesión, realiza el trabajo. 

Los datos recuperados se devuelven a la aplicación, junto con cualesquiera mensajes como errores. Puede ejecutar múltiples instancias de Motor de base de datos en un equipo. Una instancia puede ser la instancia predeterminada. La instancia predeterminada no tiene nombre. Si una solicitud de conexión especifica solo el nombre del equipo, se establece la conexión a la instancia predeterminada. 

Una instancia con nombre es una instancia en la que se especifica un nombre de instancia al instalar la instancia. Una solicitud de conexión debe especificar el nombre del equipo y el nombre de instancia para conectar a la instancia. No hay ningún requisito para instalar una instancia predeterminada; todas las instancias que se ejecutan en un equipo pueden ser instancias con nombre.



Unidad # 4 - Operación y mantenibilidad


4.1 Bitácoras de trabajo del DBMS


Una bitácora es una herramienta que permite registrar, analizar, detectar y notificar eventos que sucedan en cualquier sistema de información utilizado en las organizaciones. La estructura más ampliamente usada para grabar las modificaciones de la base de datos. Cada registro de la bitácora escribe una única escritura de base de datos y tiene lo siguiente:
  •  Nombre de la Transaccion
  •  Valor antiguo
  •  Valor Nuevo
El sistema se mantiene al tanto de lo que hacen las transacciones mediante la bitácora del sistema de base de datos, también conocido como archivo de log, diario o registro histórico. La bitácora es un archivo en el que se almacena detalles sobre las operaciones efectuadas como parte de las transacciones que afectan a los valores de los elementos de información de la BD.

La bitácora se mantiene aislada en el disco, fuera del área de la base de datos donde se almacenan todos los datos. Por ende, no le afecta ningún tipo de fallo. Precisamente para protegerlo contra posibles fallos de estos tipos se suele realizar periódicamente una copia de seguridad del archivo de la bitácora.

También se cuenta con la posibilidad de deshacer una modificación que ya se ha escrito en la base de datos, esto se realizará usando el campo del valor antiguo de los registros de la bitácora.

4.1.1 Funciones específicas de la bitácora y la ubicación de los archivos en disco de la misma

Las operaciones COMMIT y ROLLBACK establecen lo que se le conoce como punto de sincronización lo cual representa el límite entre dos transacciones consecutivas, o el final de una unidad lógica de trabajo, y por tanto al punto en el cual la base de datos esta (o debería estar) en un estado de consistencia. Las únicas operaciones que establecen un punto de sincronización son COMMIT, ROLLBACK y el inicio de un programa.
El registro de transacciones permite las siguientes operaciones:
  •  Recuperación de transacciones individuales.
  •  Recuperación de todas las transacciones incompletas cuando se inicia el DBMS.
  •  Puesta al día de una base de datos, un archivo, un grupo de archivos o una página   restaurados hasta el momento exacto del error.
  •  Permitir replicación transaccional.
  •  Permitir soluciones de servidor en espera.
4.1.2 Recuperación (rollback)

Un rollback es una operación que devuelve a la base de datos a algún estado previo. Los rollbacks son importantes para mantener la integridad de la base de datos, ya que causan que la base de datos puede ser restaurada a una copia limpia (integra), incluso después de que se han realizado operaciones erróneas. Son importantes para la recuperación de caídas (crashes) de un servidor de base de datos; realizando rollback(devuelto) a cualquier transacción que estuviera activa en el tiempo de la caída, por lo tanto la base de datos es restaurada a un estado consistente.

4.1.3 Permanencia (commit)

En el lenguaje SQL se denomina COMMIT a aplicar los cambios y ROLLBACK a cancelar los cambios.
Una sentencia COMMIT en SQL finaliza una transacción de base de datos dentro de un sistema gestor de base de datos relacional (RDBMS) y pone visibles todos los cambios a otros usuarios. El formato general es emitir una sentencia BEGIN WORK, una o más sentencias SQL, y entonces la sentencia COMMIT. Alternativamente, una sentencia ROLLBACK se puede emitir, la cual deshace todo el trabajo realizado desde que se emitió BEGIN WORK. Una sentencia COMMIT publicará cualquiera de los savepoints(puntos de recuperación) existentes que puedan estar en uso.

4.2 Definición de los modos de operación de un DBMS. (alta, baja, recovery)

La vida de todo archivo comienza cuando se crea, y acaba cuando se borra. Durante su existencia es objeto de constante procesamiento, que con mucha frecuencia incluye acciones de consulta o búsqueda y de actualización. En el caso de la estructura archivos, entenderemos como actualización, además de las operaciones, vistas para vectores y listas enlazadas, de introducir nuevos datos (altas) o de eliminar alguno existente (bajas), la modificación de datos ya existentes, (operación muy común con datos almacenados). En esencia, es la puesta al día de los datos del archivo.

Una operación de alta en un archivo consiste en la adición de un nuevo registro. En un archivo de empleados, un alta consistirá en introducir los datos de un nuevo empleado. Para situar correctamente un alta, se deberá conocer la posición donde se desea almacenar el registro correspondiente: al principio, en el interior o al final de un archivo.

El algoritmo de ALTAS debe contemplar la comprobación de que el registro a dar de alta no existe previamente. Una baja es la acción de eliminar un registro de un archivo. La baja de un registro puede ser lógica o física. Una baja lógica supone el no borrado del registro en el archivo. Esta baja lógica se manifiesta en un determinado campo del registro con una bandera, indicador o “flag” -carácter *. $, etc.,-, o bien con la escritura o rellenado de espacios en blanco en el registro dado de baja

Altas
La operación de dar de alta un determinado registro es similar a la de añadir datos a un archivo. Es importante remarcar que en un archivo secuencial sólo permite añadir datos al final del mismo.

En otro caso, si se quiere insertar un registro en medio de los ya presentes en el archivo, sería necesaria la creación nueva del archivo.

El algoritmo para dar de alta un registro al final del fichero es como el siguiente:
  1. algoritmo altas
  2. leer registro de alta
  3. inicio
  4. abrir archivo para añadir
  5. mientras haya más registros hacer {algunos lenguajes ahorran este bucle}
  6. leer datos del registro
  7. fin_mientras
  8. escribir (grabar) registro de alta en el archivo
  9. cerrar archivo
  10. fin
Bajas
Existen dos métodos para dar de baja a un registro en un archivo secuencial, donde no es fácil eliminar un registro situado en el interior de una secuencia: Para ello podemos seguir dos métodos:
  1.  Utilizar y por tanto crear un segundo archivo auxiliar transitorio, también secuencial, copia del que se trata de actualizar. Se lee el archivo completo registro a registro y en función de su lectura se decide si el registro se debe dar de baja o no. En caso afirmativo, se omite la escritura en el archivo auxiliar. Si el registro no se va a dar de baja, este registro se reescribe en el archivo auxiliar.Tras terminar la lectura del archivo original, se tendrán dos archivos: original (o maestro) y auxiliar. El proceso de bajas del archivo concluye borrando el archivo original y cambiando el nombre del archivo auxiliar por el del inicial.
  2.  Guardar o señalar los registros que se desean dar de baja con un indicador o bandera que se guarda en un array; de esta forma los registros no son borrados físicamente, sino que son considerados como inexistentes.
Cada cierto tiempo, habrá que crear un nuevo archivo secuencial con el mismo nombre, en el que los registros marcados no se grabarán.

Propósito de Backup y Recuperación
Como administrador de copia de seguridad, la tarea principal es diseñar, implementar y gestionar una estrategia de backup y recuperación. En general, el propósito de una estrategia de recuperación de copia de seguridad y es para proteger la base de datos contra la pérdida de datos y reconstruir la base de datos después de la pérdida de datos. Normalmente, las tareas de administración de seguridad son las siguientes:
  • Planificación y probar las respuestas a diferentes tipos de fallas.
  • Configuración del entorno de base de datos de copia de seguridad y recuperación.
  • La creación de un programa de copia de seguridad
  • Seguimiento de la copia de seguridad y entorno de recuperación
  • Solución de problemas de copia de seguridad
  • Para recuperarse de la pérdida de datos en caso de necesidad
Como administrador de copia de seguridad, es posible que se le pida que realice otros deberes que se relacionan con copia de seguridad y recuperación:
  • La preservación de datos, lo que implica la creación de una copia de base de datos para el almacenamiento a largo plazo
  • La transferencia de datos, lo que implica el movimiento de datos de una base de datos o un host a otro.
De Protección de Datos
Como administrador de copia de seguridad, su trabajo principal es hacer copias de seguridad y vigilancia para la protección de datos. Una copia de seguridad es una copia de los datos de una base de datos que se puede utilizar para reconstruir los datos. Una copia de seguridad puede ser una copia de seguridad física o una copia de seguridad lógica.

Copias de seguridad físicas son copias de los archivos físicos utilizados en el almacenamiento y la recuperación de una base de datos. Estos archivos incluyen archivos de datos, archivos de control y los registros de rehacer archivados. En última instancia, cada copia de seguridad física es una copia de los archivos que almacenan información de base de datos a otra ubicación, ya sea en un disco o en medios de almacenamiento fuera de línea, tales como cinta.
Copias de seguridad lógicas contienen datos lógicos, como tablas y procedimientos almacenados. 

Copias de seguridad físicas son la base de cualquier estrategia de recuperación de copia de seguridad sólida y. Copias de seguridad lógicas son un complemento útil de las copias de seguridad físicas en muchas circunstancias, pero no son suficiente protección contra la pérdida de datos y sin respaldos físicos.
A menos que se especifique lo contrario, la copia de seguridad término tal como se utiliza en la copia de seguridad y la documentación de recuperación se refiere a una copia de seguridad física. Copia de seguridad de una base de datos es el acto de hacer una copia de seguridad física. El enfoque en la copia de seguridad y recuperación de documentación está casi exclusivamente en copias de seguridad físicas.

Las Fallas de Medios
La falta de medios es un problema físico con un disco que provoca un fallo de una leer o escribir en un archivo de disco que se requiere para ejecutar la base de datos. Cualquier archivo de base de datos puede ser vulnerable a un fallo de comunicación. La técnica de recuperación adecuada después de un fallo de los medios de comunicación depende de los archivos afectados y el tipo de copia de seguridad disponible.
Un aspecto particularmente importante de la copia de seguridad y recuperación se está desarrollando una estrategia de recuperación ante desastres para proteger contra la pérdida de datos catastrófica, por ejemplo, la pérdida de toda una serie de bases de datos.

Errores de los Usuarios
Los errores del usuario cuando se producen, ya sea debido a un error en la lógica de la aplicación o un error manual, los datos en una base de datos se modifican o eliminan incorrectamente. Errores de usuario se estima que la mayor causa de inactividad de base de datos.

La pérdida de datos debido a un error del usuario puede ser localizada o generalizada. Un ejemplo de daño localizado está eliminando a la persona equivocada en la tabla empleados. Este tipo de lesiones requiere la detección y la reparación quirúrgica. Un ejemplo de un daño generalizado es un trabajo por lotes que borra las órdenes de la empresa para el mes en curso. En este caso, se requiere una acción drástica para evitar una extensa base de datos de tiempo de inactividad.

Mientras que la formación de usuarios y el manejo cuidadoso de los privilegios pueden prevenir la mayoría de los errores de usuario, su estrategia de copia de seguridad determina la gracia de recuperar los datos perdidos cuando un error del usuario que hace perder los datos.

Errores de Aplicación
A veces, un mal funcionamiento de software puede dañar los bloques de datos. En una corrupción física, que también se conoce como la corrupción los medios de comunicación, la base de datos no reconoce el bloque en absoluto: la suma de comprobación no es válida, el bloque contiene todos los ceros, o el encabezado y el pie de página del bloque no coinciden. Si el daño no es muy amplio, puede a menudo repara fácilmente con bloque de recuperación de medios.

Preservación de Datos
Conservación de datos se relaciona con la protección de datos, pero tiene un propósito diferente. Por ejemplo, puede que tenga que conservar una copia de una base de datos tal como existía al final de la cuarta parte del negocio. Esta copia de seguridad no es parte de la estrategia de recuperación de desastres. Los medios a los que estas copias de seguridad se escriben a menudo disponible después de la copia de seguridad. Usted puede enviar la cinta en almacenamiento incendio o enviar un disco duro portátil a un centro de pruebas. RMAN proporciona una manera conveniente para crear una copia de seguridad y eximirla de su política de retención de copia de seguridad. Este tipo de copia de seguridad se conoce como una copia de seguridad de archivo.

Transferencia de Datos
En algunas situaciones, es posible que tenga que tomar una copia de seguridad de una base de datos o base de datos de componentes y moverlo a otra ubicación. Por ejemplo, puede utilizar el Administrador de recuperación (RMAN) para crear una copia de base de datos, cree una copia de tabla que se puede importar en otra base de datos, o mover una base de datos completa de una plataforma a otra. Estas tareas no son, estrictamente hablando, parte de una estrategia de backup y recuperación, pero requieren el uso de copias de seguridad de bases de datos, por lo que pueden incluirse en las tareas de un administrador de copia de seguridad.

Recuperación de Comandos
Ustedes son responsables de determinar todos los aspectos de cuándo y cómo las copias de seguridad y la recuperación se hacen.

Estas soluciones están respaldadas por Oracle y se documentan, pero RMAN es la mejor solución para copia de seguridad y recuperación de bases de datos. RMAN proporciona una interfaz común para las tareas de copia de seguridad a través de diferentes sistemas operativos host, y ofrece varias técnicas de copia de seguridad que no están disponibles a través de métodos administrados por usuarios.

La mayor parte de este manual se centra en la copia de seguridad y recuperación de RMAN basado. Técnicas de copia de seguridad y recuperación gestionadas por el usuario se tratan en Realización de usuario-Managed Backup and Recovery. Las más destacables son los siguientes:
  •  Copias de Seguridades Incrementales
Una copia de seguridad incremental almacena sólo los bloques modificados desde la última copia de seguridad. Por lo tanto, proporcionan copias de seguridad más compacta y una recuperación más rápida, lo que reduce la necesidad de aplicar de rehacer en archivo de datos de recuperación de los medios de comunicación. Si se habilita el seguimiento de cambios de bloque, entonces usted puede mejorar el rendimiento al evitar escaneos completos de todos los archivos de datos de entrada. Utilice el comando Copia de seguridad incremental para realizar copias de seguridad incrementales.
  •  Bloquear los Medios de Recuperación
Usted puede reparar un archivo de datos con sólo un pequeño número de bloques de datos corruptos sin tomarlo fuera de línea o la restauración desde copia de seguridad. Utilice el comando BLOQUE RECOVER para realizar la recuperación del bloque de comunicación.
  •  Compresión Binaria
Un mecanismo de compresión binaria integrado en base de datos Oracle reduce el tamaño de las copias de seguridad.
  •  Copias de Seguridad Encriptadas
RMAN utiliza las capacidades de cifrado de copia de seguridad integrados en bases de datos Oracle para almacenar conjuntos de copia de seguridad en un formato codificado. Para crear copias de seguridad cifradas en el disco, la base de datos debe utilizar la opción de seguridad avanzada. Para crear copias de seguridad encriptadas directamente en cinta, RMAN debe utilizar la copia de seguridad de Oracle Secure interfaz SBT, pero no requiere la opción de seguridad avanzada.
  •  Duplicación de la Base de Datos Automatizada
Crea fácilmente una copia de su base de datos, el apoyo a diversas configuraciones de almacenamiento, incluida la duplicación directa entre las bases de datos de ASM.
  • Conversión de Datos entre Plataformas
Ya sea que utilice RMAN o métodos administrados por usuarios, puede complementar las copias de seguridad físicas con copias de seguridad lógicas de objetos de esquema realizados con la utilidad Export Data Pump. Más tarde, puede utilizar Data Pump Import para volver a crear los datos después de la restauración y la recuperación. Copias de seguridad lógicas son en su mayoría más allá del alcance de la copia de seguridad y de recuperación de documentación.

4.3 - Comandos de activación de los modos de operación
Para ser uso de los diferentes comandos para un modo de operación debemos estar como administrador o asuma un rol que incluya el perfil de derechos Service Management.

Comando STARTUP
Para el arranque de una base de datos hay tres fases de arranque, para realizar estas fases podemos utilizar startup más un comando, las tres fases son las siguientes:

Fase de no Montaje: Aquí leen los parámetros del sistema, se inician las estructuras de memoria y los procesos de segundo plano. La instancia se arranca sin asociarla a la base de datos. Normalmente se utiliza cuando se modifica o se necesita crear el archivo de control:
startup nomount ;

Fase de Montaje: Es aquella que asocia la instancia con la base de datos. Se usa el archivo de parámetros para localizar los archivos de control, que contienen el nombre de los archivos de datos y los registros rehacer. Los archivos de datos y los registros de rehacer no están abiertos, así que no son accesibles por usuarios finales para tareas normales. Para realizar esta fase se pueden utilizar dos comandos:

startup mount;
alter database mount;

Fase de Apertura: Es la que se encarga de abrir los archivos de datos y los registros a rehacer. La base de datos queda disponible para las operaciones normales. Es necesario que existan registros rehacer de lo contrario si no hay registros usamos el comando resetlogs, que crea registros nuevos. Para esta fase se pueden usar dos comandos:

startup open;
alter database open;

Si es necesario utilizar resetlogs:

startup open resetlogs;
alter database open resetlogs;
startup restrict (sólo permite la conexión de usuarios con el privilegio restricted sesion).
startup force (hace shutdown abort y arranca la BD).

Comando SHUTDOWN
El comando SHUTDOWN lo utilizamos  parar una base de datos la cual consiste en varias cláusulas.

Shutdown Normal: Este es el valor por defecto, durante el proceso de parada no admite nuevas conexiones y espera que las conexiones actuales finalicen. En el próximo arranque la base datos no requiere procedimientos de recuperación.

Shutdown Immediate: Se produce una parada inmediata de la base de datos, durante el proceso de parada no permite nuevas conexiones y las actuales la desconecta, las transacciones que no estén commit se hara roolback de ellas. En el próximo arranque la base datos no requiere procedimientos de recuperación.

Shutdown Transactional: Se produce una parada hasta que hayan terminado las transacciones activas, no admite nuevas conexiones y tampoco nuevas transacciones, una vez que las transacciones activas van terminando va desconectando a los usuarios. En el próximo arranque la base datos no requiere procedimientos de recuperación.

Shutdown Abort: Aborta todos los procesos de una base de datos, durante el proceso de parada no permite nuevas conexiones y las actuales la desconecta, las transacciones que no estén commit se hará roolback de ellas. En el próximo arranque la base datos puede requerir procedimientos de recuperación.

Comando Describe
Este comando permite conocer la estructura de una tabla, las columnas que la forman y su tipo y restricciones.  
DESCRIBE f1;

Comando SHOW TABLES y SHOW CREATE TABLE
El comando SHOW TABLES muestra las tablas dentro de una base de datos y SHOW CREATE TABLES muestra la estructura de creación de la tabla.

Modificación
Para realizar una modificación utilizamos el comando ALTER TABLE. Para usar ALTER TABLE, necesita permisos ALTER, INSERT y CREATE para la tabla. 

4.4.- Manejo de Índices

El índice de una base de datos es una estructura alternativa de los datos en una tabla. El propósito de los índices es acelerar el acceso a los datos mediante operaciones físicas más rápidas y efectivas. En pocas palabras, se mejoran las operaciones gracias a un aumento de la velocidad, permitiendo un rápido acceso a los registros de una tabla en una base de datos. Al aumentar drásticamente la velocidad de acceso, se suelen usar sobre aquellos campos sobre los cuáles se hacen búsquedas frecuentes.

4.4.1 Tipos de Índices

Qué son los Í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 8567 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.

Supongamos que un ingeniero civil tiene un estante de cajas de cartón. Las carpetas contienen planos y diversos catalogos de conceptos insertados aleatoriamente de las diferentes obras en las que ha trabajado. La carpeta Plaza Recreativa (ID 350) es de 60 carpetas desde el fondo de la caja 1, mientras que la carpeta Departamento (ID 200) se encuentra en el inferior de la caja 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 sus proyectos con su ubicación de la carpeta:
  • ID 200: Box 3, position 1 (bottom)
  • ID 201: Box 7, position 8
  • ID 350: Box 1, position 60
Del mismo modo, el administrador podría crear índices separados para los últimos proyectos, 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.

Los í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 para 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 a 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 Únicos
Los índices pueden ser únicos o no únicos. Í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.

Los índices no únicos 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).

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 índice pueden recuperar los datos ordenados por las columnas de índice. Índices B-tree tienen los siguientes subtipos:
  • Índice de Tablas Organizadas
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.
  • Índices Descendentes
Este tipo de índice almacena los datos en una columna o columnas de concreto en orden descendente.
  • Í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.
  • 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".
  •  Í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.
  • Í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ísico 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".
  • Í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.

4.4.2 Reorganización de Índices.

Un factor clave para conseguir una E/S de disco mínima para todas las consultas de bases de datos es asegurarse de que se creen y se mantengan buenos índices. Una vez creados los índices, se debe procurar mantenerlos para asegurarse que sigan trabajando en forma óptima. A medida que se agregan, modifican o borran datos se produce fragmentación. 

Fragmentación de los Índices
La fragmentación es consecuencia de los procesos de modificación de los datos (instrucciones INSERT, UPDATE y DELETE) efectuados en la tabla y en los índices definidos en la tabla. Como dichas modificaciones no suelen estar distribuidas de forma equilibrada entre las filas de la tabla y los índices, el llenado de cada página puede variar con el paso del tiempo. Para las consultas que recorren parcial o totalmente los índices de una tabla, este tipo de fragmentación puede producir lecturas de páginas adicionales. Esto impide el recorrido paralelo de los datos. Existen dos tipos de fragmentación:
  1. Interna: Fragmentación dentro de páginas individuales de datos e índices con espacios libres que generan la necesidad de más operaciones de E/S y más memoria para su lectura. Este hecho disminuye el rendimiento en ambientes de lectura, pero en algunos casos puede beneficiar las inserciones, que no requieren una división de páginas con tanta frecuencia.
  2. Externa: Cuando el orden lógico de las páginas no es correcto, porque las páginas no son contiguas. El acceso a los datos es mucho más lento por la necesidad de búsqueda de los datos.
La fragmentación de índices se puede reparar reorganizando un índice o reconstruyéndolo. Para los índices fraccionados que fueron construidos en una estructura partida se puede usar cualquiera de estos métodos o bien en un índice completo o bien en un único fragmento del índice.

Detección de Fragmentación
El primer paso para decidir qué método de desfragmentación se va a utilizar consiste en analizar el índice para determinar el nivel de fragmentación. Si se usa la función del sistema sys.dm_db_index_physical_stats, se puede detectar la fragmentación de los índices de la base de datos thuban-homologada.

SELECT DISTINCT
A.INDEX_ID 'IDIndice';
sys.TABLES.name 'Tabla',
b.name 'Indice',
avg_fragmentation_in_percentr '% Fragmentación',
fragment_count 'Cantidad de Fragmentos',
avg_fragment_size_in_pages 'Promedio de fragmentos por página',
FROM
sys.dm_db_index_physical_stats (
DB_ID ()N'thuban-himologada'),
OBJECT_ID (N'dbo.*'),
NULL,
NULL,
NULL) AS  a JOIN sys.indexes AS b ON a.object_id = b.object_id AND a.index_id = b.index_id,
sys.TABLES
WHERE
sys.TABLES.object_id = b.object_id
ORDER BY
avg_fragmentation_in_percent DESC

Los resultados emitidos por la anterior sentencia se incluye las siguientes columnas:


4.4.3 Reconstrucción de Índices

Se debe examinar y determinar periódicamente qué índices son susceptibles de ser reconstruidos. Cuando un índice está descompensado puede ser porque algunas partes de éste han sido accedidas con mayor frecuencia que otras. Como resultado de este suceso podemos obtener problemas de contención de disco o cuellos de botella en el sistema. Normalmente reconstruimos un índice con el comando ALTER INDEX.

Es importante tener actualizadas las estadísticas de la base de datos. Para saber si las estadísticas se están lanzando correctamente podemos hacer una consulta sobre la tabla dba_indexes y ver el campo last_analyzed para observar cuando se ejecutaron sobre ese índice las estadísticas.

Blevel (branch level) es parte del formato del B-tree del índice e indica el número de veces que Oracle ha tenido que reducir la búsqueda en ese índice. Si este valor está por encima de 4 el índice deberá de ser reconstruido.

ALTER INDEX <index_name> REBUILD;

Para reconstruir una partición de un índice podríamos hacer los siguiente:

ALTER INDEX <index_name> REBUILD PARTITION <nb_partition> NOLOGGING;


Exposiciones - Lenguajes de interfaz

Equipo # 1 - Programación del puerto paralelo Un puerto paralelo es una interfaz entre un computador y un periférico, cuya principal carac...