base de datos iii
DESCRIPTION
Portafolio de evidenciasTRANSCRIPT
Hecho Por: VíctorIbarra.
BASE DEDATOS III.
PORTAFOLIO DE EVIDENCIAS BASE DEDATOS III.NOMBRE: VICTOR HUGO IBARRA ORTIZ.MATRICULA: 25113172.MAESTRO: JOSE BENITO FRANCOURREA.GRUPO: LISC-5.AULA: CENTRO DE COMPUTO.HORA: 1-3 PM.UNIDAD: CENTRO.CD. OBREGON, SONORA A FEBRERO 13DE 2013.
INDICE.
• INTRODUCCION.• EXPECTATIVAS DEL CURSO.• INFORMACION INSTITUCIONAL.• PERFIL DESCRIPTIVO.• TAREAS EN CLASE.• TAREAS EXTRA CLASE.• MATERIAL DE APOYO.• INSTRUMENTOS DE EVALUACION.• BIBLIOGRAFIA.• REFLEXION.• CONCLUSION.• FIN.
INTRODUCCION.
EN EL SIGUIENTE TRABAJO SEPRESENTARA LAS EXPECTATIVAS QUE TUVEEN LA MATERIA DE BASE DE DATOS III,TAMBIÉN LA DESCRIPCIÓN DE LA MISMA.SE INCLUYE TAMBIÉN LA MISIÓN, VALORESY ACTITUDES DE LA UNIVERSIDAD.SE MOSTRARA LOS TRABAJOS HECHOS ENCLASE, EXTRA CLASE, INSTRUMENTOS DEEVALUACIÓN, MATERIAL DE APOYO, ESDECIR, TODO LO QUE SE TRABAJO EN ESTEMODULO.POR ULTIMO SE INCLUYE LASBIBLIOGRAFÍAS, CONCLUSIÓN Y UNAREFLEXIÓN DE LA MATERIA.
EXPECTATIVAS.
LO QUE ESPERO DE LA MATERIA DEBASE DE DATOS II ES QUE SEADINÁMICA, PRACTICA, ENTENDIBLEPARA PODER ASÍ APRENDER ALMÁXIMO TODO LO QUE EN ELLA SEIMPARTA. YA QUE LA MATERIA DE BASEDE DATOS II ES UNA PARTE IMPORTANTEDE NUESTRA CARRERA Y ASÍ PODERSORTEAR LOS PROBLEMAS DE MANERAMAS SENCILLA.POR MI PARTE PONDRÉ TODO DE MIESFUERZO PARA LOGRAR SACARADELANTE NO SOLO ESTA MATERIA SINO TODAS LAS QUE APLICA CUMPLIR MIMETA.
INFORMACIONINSTITUCIONAL.
Misión
La misión de UNIDEP es formar profesionales de éxito que cuenten con las actitudes,habilidades y conocimientos que demanda el sector productivo de la región.
Visión
La Universidad del Desarrollo Profesional es una institución de educación superior decalidad, que ofrece programas presenciales y semipresenciales de bachillerato,profesional asociado, licenciatura, posgrado, diplomados y cursos en México y en elextranjero.
Se distingue por facilitar a sus egresados la incorporación al mercado de trabajo,apoyada en una estrecha vinculación con el sector productivo y en planes de estudiopertinentes y dinámicos.
Es reconocida por su modelo educativo profesionalizante, por la flexibilidad de suoferta académica impartida en ciclos continuos y por horarios y cuotas accesibles,acordes a la disponibilidad de tiempo y recursos económicos del alumno.
Cuenta con profesores de amplia experiencia profesional y educativa. Sus instalacionesdentro de la ciudad permiten el fácil acceso.
Cuenta con un modelo de administración sistematizado, participativo, operado porpersonal que es recompensado por su desempeño efectivo que le permite maximizarlas aportaciones de sus socios y mantener finanzas sanas.
INFORMACIONINSTITUCIONAL.
LealtadLos Integrantes de la comunidad Universitaria consideramos la fidelidadcomo un valor excelso que enaltecemos en nuestro quehacer diario.
JusticiaLos integrantes de la comunidad Universitaria actuamos con la constante yperpetua voluntad de dar a cada cual lo que le corresponde conforme a susméritos o actos.
HonestidadLos integrantes de la comunidad universitaria actuamos con sinceridad yhonradez en nuestras tareas y en congruencia entre los pensamientos,palabras y acciones.
ResponsabilidadLos integrantes de la comunidad universitaria llevamos a cabo nuestrasactividades con integridad, con sentido del propósito y apegados a losobjetivos institucionales.
EsfuerzoLos integrantes de la comunidad universitaria usamos nuestra máximaenergía para cumplir con los objetivos trazados.
CreatividadLos integrantes de la comunidad universitaria resolvemos los problemascon imaginación, conocimientos y con un espíritu de mejora continua
PERFIL DESCRIPTIVO.
• PERFIL DESCRIPTIVO.
UNIVERSIDAD DEL DESARROLLO PROFESIONAL
Perfil Descriptivo de Clase
Materia: BASE DE DATOS III Ciclo: 201325
Maestro: M.C. JOSÉ BENITO FRANCO URREA Horario: 13:00-15:00 pm
Objetivo del
Curso:
Conocerá y utilizará el lenguaje SQL, para organizar, administrar y consultar datos almacenados en una computadora.
Será capaz de planear y administrar una base de datos. Será capaz de resolver problemas que tengan que ver con el uso de PL/SQL y
MySQL
Tendrá herramientas para una mejor organización y control de sus recursos.
Bibliografía: TIPO TITULO AUTOR EDITORIAL/REVISTA AÑO
.
LIBRO FUNDAMENTOS DE
BASE DE DATOS Abraham Silberschatz Bell Laboratories Henry F. Korth Bell Laboratories S. Sudarshan Instituto Indio de
Tecnología, Bombay.
McGRAW-HILL 2002
LIBRO DISEÑO Y
ADMINISTRACIÓN DE
BASE DE DATOS.
Gary W. Hansen
James V. Hansen
Prentice- Hall 2003
LIBRO SISTEMA DE BASE
DE DATOS.
RAMEZ ELMASRI/NAVATH
E
ADDISON 2001
criterios para
la Evaluación
CALIFICACIÓN ORDINARIA (PONDERACIÓN)
Actividades semanales
30% Examen primer parcial. 15%
Portafolio reaprendizaje
10% Examen segundo parcial. 25%
Trabajos independientes
20% T O T A L 100%
Reglas
1. El alumno es responsable de enterarse de su número de faltas y retardos.
2. El alumno debe contar con un mínimo del 80% de asistencia para tener derecho a su calificación final.
3. El alumno que se sorprenda incurriendo en actos desleales en la elaboración de exámenes, tareas o trabajos,
obtendrá cero (0) de calificación en el trabajo, tarea y/o examen
4. Es responsabilidad del estudiante hablar inmediatamente con el maestro cuando tenga problemas con el
material de clase, sus calificaciones, etc. De esta manera evitaremos problemas en el fin del ciclo.
5. Sólo se justifican inasistencias si son autorizadas por la coordinación académica bajo el procedimiento
correspondiente
6. Se tomara asistencia al iniciar la clase.
7. Prohibido utilizar teléfonos celulares y/o aparatos electrónicos dentro del aula.
8. La clase es de 100 minutos efectivos.
9. La clase inicia a la hora en punto
10. No se permiten alimentos ni bebidas dentro del aula.
11. Deberá presentar su Carnet de Pago, expedido por su coordinador administrativo, para la autorización de recepción de trabajos finales
y la aplicación de exámenes en la última semana del módulo.
Calendarización
Sesión Fecha Tema
1 14/01/2013
Presentación del programa, Introducción al tema, Integración de equipos, Asignación de proyecto final. Revisión de herramientas disponibles en laboratorio de cómputo, diagnóstico de conocimientos del grupo.
2 15/01/2013
1. Programación pl/sql , declaración de variables. 1.1 Estructura de un bloque PL/SQL. 1.2 Tipos de Bloques. 1.3 Uso de variables. 1.4 Manejo de variables PL/SQL. 1.5 Tipos de Variables. 1.6 Declaración de Variables. 1.7 Asignación. Inicialización de Variables y palabras claves. 1.8 Referenciando variables que no son de PL/SQL. 1.9 Ejercicios Prácticos. Avance del proyecto Final
3 16/01/2013
2. Escribiendo comandos ejecutables 2.1 Líneas maestras para escribir un bloque PL/SQL. 2.2 Comentarios. 2.3 Funciones SQL en PL/SQL: Conversión de tipos, Mezclando bloques y ámbito de variables, Operadores en PL/SQL. 2.4 Ejercicios Prácticos. Avance del proyecto
4 17/01/2013
Revisión de los ejercicios de Prácticas y dudas de los temas. Exposición del equipo #1: RESTRICCIONES DE INTEGRIDAD EN LAS BASES DE
DATOS.
Entrega del reporte de lectura del tema investigado en internet.
5 21/01/2013
3. Interactuando con Oracle server 3.1 Comando SQL en PL/SQL. 3.2 Recuperación de datos en PL/SQL. 3.3 Insertando datos en PL/SQL. Borrando datos en PL/SQL. 3.4 Actualizando datos en PL/SQL. 3.5 COMMIT Y ROLLBACK. 3.6 Cursores. 3.7 Ejercicios Prácticos. Avance del proyecto final.
6 22/01/2013
4. Estructuras de control. 4.1 Comando IF. 4.2 Comando IF-THEN-ELSE.
4.3 Comando IF-THEN-ELSIF. 4.4 Condiciones Booleanas. 4.5 Bucles: LOOP, WHILE, FOR. 4.6 Ejercicios prácticos.
7 23/01/2013
Revisión de los ejercicios de Prácticas y dudas de los temas.
Exposición del equipo #2: seguridad de Base de Datos.
Entrega del reporte de lectura del tema investigado en internet.
8 24/01/2013 Revisión de avance del proyecto final y la información del portafolio.
9 28/01/2013
5. Cursores. 5.1 Tipos de Cursores. 5.2 Declaración. 5.3 Operaciones con cursores. 5.4 Variables aplicables. 5.5 Ejercicios Prácticos. Avance del proyecto final
10 29/01/2013
6. Cursores explícitos avanzados. 6.1 Cursores con parámetros. 6.2 Cláusula FOR UPDATE. 6.3 Cláusula WHERE CURRENT OF. 6.4 Cursor con Subconsultas. 6.5 Ejercicios Prácticos. Avances del proyecto final
11 30/01/2013
Revisión de los ejercicios de Prácticas y dudas de los temas. Exposición del equipo #3: Base de Datos distribuida y Arquitectura cliente servidor.
Entrega del reporte de lectura del tema investigado en internet.
12 31/01/2013 EXAMEN PRIMER PARCIAL
13 04/02/2013
7. Sql avanzado 7.1 OPERADORES DE CONJUNTOS
7.1.1 Tipos. 7.1.2 INTERSET. 7.1.3 UNIÓN/UNIÓN ALL. 7.1.4 MINUS. 7.1.5 Ejercicios Prácticos. Avance proyecto final
14 05/02/2013
1.1 Subconsultas correlacionadas. 1.1.1 Concepto. 1.1.2 Usando Subconsultas Correladas. 1.1.3 EXISTS. NOT EXISTS. 1.1.4 Ejercicios Prácticos.
Avance del proyecto final
15 06/02/2013
8. Bases de datos con MySQL. 8.1 Introducción a MySQL. 8.2 Formas de uso de MySQL.
16 07/02/2013 1.1 Administración de bases de datos en MySQL.
1.2 Optimización de bases de datos en MySQL.
17 11/02/2013
Entregar reporte de lectura del tema de clasificación de los sistemas de gestión de base de datos. Revisión de proyecto Final y portafolio.
18 12/02/2013 Entrega y revisión práctica del proyecto final y portafolio.
19 13/02/2013 EXAMEN SEGUNDO PARCIAL
20 14/02/2013 ENTREGA DE CALIFICACIONES ORDINARIAS
EXAMEN EXTRAORDINARIOS
EJERCICIOS EN CLASE.
• EJERCICIOS EN SQL.
EJEMPLO PROCEDIMIENTO
CREATE OR REPLACE PROCEDURE hola_universo
IS
l_mensaje VARCHAR2(100):='HOLA UNIVERSO';
BEGIN
DBMS_OUTPUT.put_line(l_mensaje);
END hola_universo;
/
EJERCICIO PRÁCTICO:
Crear un procedimiento que permita consultar el sueldo de los empleados pasando como
parámetro su número de empleado, sino existe el empleado mandara un mensaje de
excepción que indique que el empleado no fue encontrado.
SQL) CREATE OR REPLACE PROCEDURE consueldo(num_emp VARCHAR2)
IS
nombre_emp EMPLEADOS.NOMBRE%TYPE;
sueldo_emp EMPLEADOS.SUELDO%TYPE;
BEGIN
DBMS_OUTPUT.put_line('Numero de empleado ingresado: ' || num_emp);
SELECT NOMBRE, SUELDO INTO nombre_emp, sueldo_emp FROM EMPLEADOS
WHERE NUM_EMPLEADOS=num_emp;
DBMS_OUTPUT.put_line('Nombre Empleado: ' || TRIM(nombre_emp));
DBMS_OUTPUT.put_line('Sueldo : ' || sueldo_emp);
EXCEPTION
WHEN NO_DATA_FOUND THEN
DBMS_OUTPUT.put_line('EMPLEADO NO ENCONTRADO!');
END;
Ejecutar el procedimiento “consueldo” pasando como parámetro el número de empleado
“3777”
BEGIN
consueldo('3777');
END;
Resultado:
Numero de empleado ingresado: 3777
Nombre Empleado: JUAN
Sueldo: 10000,0
Ejecutar el procedimiento “consueldo” pasando como parámetro el numero de empleado
“8888”
BEGIN
consueldo('8888');
END;
Resultado:
Numero de empleado ingresado: 8888
EMPLEADO NO ENCONTRADO!
FUNCION PAR IMPAR
CREATE OR REPLACE FUNCTION parimpar(num Numeric)
RETURN VARCHAR2
IS
BEGIN
IF MOD(num,2)=0 THEN RETURN 'PAR';
ELSE RETURN 'IMPAR';
END IF;
END;
/
EJECUTAR LA FUNCION PARIMPAR
DECLARE
res VARCHAR(20);
BEGIN
res:=parimpar(16);
DBMS_OUTPUT.put_line('El numero es : ' || res);
END;
RESULTADO:
El numero es : PAR
CREE UN PROCEDIMIENTO QUE SUME DOS NUMEROS:
CREATE OR REPLACE PROCEDURE SUMAR(X IN NUMBER, Y IN NUMBER)
IS
BEGIN
DBMS_OUTPUT.put_line('LA SUMA ES: ' || TO_CHAR(X+Y));
END;
/
EJECUTAR PROCEDIMIENTO QUE SUMA DOS NUMEROS:
EXECUTE SUMAR(23,56);
SALIDA:
LA SUMA ES: 79
CREA UNA FUNCION QUE DUPLIQUE LA CANTIDAD RECIBIDA COMO PARAMETRO:
CREATE OR REPLACE FUNCTION duplicador(valor NUMBER) RETURN NUMBER IS
BEGIN
RETURN (valor * 2);
END;
/
EJECUTAR PROCEDIMIENTO DUPLICAR NÚMERO:
DECLARE
res NUMBER;
BEGIN
res:=duplicador(22);
DBMS_OUTPUT.put_line('valor devuelto: ' || TO_CHAR(res));
END;
/
SALIDA:
Valor devuelto: 44
SUELDO MAYOR
select max(empleados.sueldo) sueldo_mayor
From empleados;
El gerente necesita saber cuál es el sueldo más alto ya que empleado se le paga en la
empresa veamos cómo se hace:
Select empleados.nombre, empleados.ap_paterno, empleados.sueldo,
empleados.puesto from empleados
where empleados.sueldo=(Select max(empleados.sueldo)from
empleados); Select empleados.nombre, empleados.ap_paterno, empleados.sueldo,
empleados.puesto from empleados
where empleados.sueldo=(Select max(empleados.sueldo)from
empleados);
Resultado:
NOMBRE AP_PATERNO SUELDO PUESTO
--------------- --------------- ---------- --------------------------------------------------
ANDREA MENDOZA 35000 GERENTE
El gerente necesita saber cuál es el sueldo más bajo ya que empleado se le paga en la
empresa veamos cómo se hace:
Select empleados.nombre, empleados.ap_paterno, empleados.sueldo,
empleados.puesto from empleados
where empleados.sueldo=(Select min(empleados.sueldo)from
empleados);
Resultado:
NOMBRE AP_PATERNO SUELDO PUESTO
--------------- --------------- ---------- --------------------------------------------------
INES ARMENTA 3500 RECEPCIONISTA
El gerente necesita saber el sueldo más alto por departamento.
Select n_dpto, max(sueldo) sueldo_mayor
From empleados
Group by n_dpto;
Resultado:
N_DPTO SUELDO_MAYOR
------ ------------
1805 15000
1804 25000
1800 35000
1801 15000
1803 15000
1802 15000
6 filas seleccionadas
Consulta de departamentos del corporativo:
Select * From departamentos;
Resultado:
N_DPTO DESCRIPCION
------ --------------------------------------------------
1800 DIRECCION
1801 RCURSOS FINANCIEROS
1802 INFORMATICA
1803 JURIDICO
1804 RECURSOS HUMANOS
1805 RECURSOS MATERIALES
6 filas seleccionadas
Ingresar un nuevo empleado a la empresa:
INSERT INTO empleados(num_empleado, NOMBRE,AP_PATERNO,
AP_MATERNO, PUESTO, SUELDO, ANTIGUEDAD, N_DPTO)
VALUES ('9223','EDGAR JAVIER','URQUIJO','RASCON','JEFE DE OFICINA','20000','10','1802');
Resultado:
1 filas insertadas.
Eliminar fila:
DELETE FROM EMPLEADOS WHERE NUM_EMPLEADO='9223';
Resultado:
1 filas eliminado.
Se requiere verificar si el empelado 9223 tiene un sueldo mayor a $10,000.00 si es verdad
entonces enviara el mensaje de que es un funcionario pero si es falso enviara un mensaje que
es un empleado.
DECLARE
v_sueldo NUMBER(8,2);
BEGIN
SELECT SUELDO INTO v_sueldo FROM empleados WHERE NUM_EMPLEADO='9223';
IF v_sueldo > 10000 THEN
DBMS_OUTPUT.put_line('El empleado gana mas de $10,000.00' || 'Es un funcionario con un
sueldo de '|| TO_CHAR(v_sueldo));
END IF;
END;
Resultado:
El empleado gana mas de $10,000.00Es un funcionario con un sueldo de 20000
Se requiere verifica si el empleado 5232 tiene un sueldo mayor a $10,000.00 pesos, si es
verdadero entonces enviara un mensaje de que es un funcionario, pero si es falso enviara un
mensaje que es un empleado.
DECLARE
v_sueldo NUMBER(8,2);
BEGIN
SELECT SUELDO INTO v_sueldo FROM empleados WHERE NUM_EMPLEADO='5232';
IF v_sueldo > 10000 THEN
DBMS_OUTPUT.put_line('El empleado gana mas de $10,000.00:'||'Es un FUNCIONARIO
EJECUTIVO con sueldo de '||TO_CHAR(v_sueldo));
ELSE
DBMS_OUTPUT.put_line('El empleado gana MENOS de $10,000.00:'||'Es un EMPLEADO DE
OFICINA con sueldo de '||TO_CHAR(v_sueldo));
END IF;
END;
Resultado:
El empleado gana MENOS de $10,000.00:Es un EMPLEADO DE OFICINA con sueldo de 8000.
Se requiere verifica con el numero de empleado tomado como base el sueldo de la siguiente
forma: 25000 es un director, 15000 es un jefe de departamento, si su sueldo no cumple con
los parámetros anteriores entonces es un empleado de oficina.
DECLARE
v_sueldo NUMBER(8,2);
BEGIN
SELECT SUELDO INTO v_sueldo FROM empleados WHERE NUM_EMPLEADO='5232';
IF v_sueldo >= 25000 THEN
DBMS_OUTPUT.put_line('Es un DIRECTOR con un sueldo de ' || TO_CHAR(v_sueldo));
ELSE IF v_sueldo >= 15000 THEN
DBMS_OUTPUT.put_line('Es un JEFE DE DEPARTAMENTO con un sueldo
de:'||TO_CHAR(v_sueldo));
ELSE
DBMS_OUTPUT.put_line('Es un EMPLEADO DE OFICINA con un sueldo
de:'||TO_CHAR(v_sueldo));
END IF;
END IF;
END;
Resultado:
Es un EMPLEADO DE OFICINA con un sueldo de: 8000
Ejemplo bucle LOOP
DECLARE
v_dato VARCHAR2(2):='&anum';
v_contador NUMBER(2):=0;
v_num NUMBER(2):=TO_NUMBER(v_dato);
BEGIN
LOOP
v_contador:=v_contador+1;
DBMS_OUTPUT.put_line('Numeros contador:'||TO_CHAR(v_contador));
EXIT WHEN v_contador>v_num;
END LOOP;
DBMS_OUTPUT.put_line('Numero Acumulado:'||TO_CHAR(v_contador));
END;
Resultado:
Numeros contador:1
Numeros contador:2
Numeros contador:3
Numeros contador:4
Numeros contador:5
Numeros contador:6
Numeros contador:7
Numeros contador:8
Numeros contador:9
Numeros contador:10
Numeros contador:11
Numero Acumulado:11
Ejemplo de bucle FOR:
ACCEPT anum PROMPT 'DIGITA UN NUMERO'
DECLARE
v_dato VARCHAR2(2):='&anum';
v_contador NUMBER(2):=0;
v_num NUMBER(2):=TO_NUMBER(v_dato);
v_acum NUMBER(2):=0;
BEGIN
FOR v_contador IN 1..v_num LOOP
v_acum:=v_acum+1;
DBMS_OUTPUT.put_line('Numeros contador:'||TO_CHAR(v_contador));
END LOOP;
DBMS_OUTPUT.put_line('Numero Acumulado:'||TO_CHAR(v_acum));
END;
Resultado:
Numeros contador: 1
Numeros contador: 2
Numeros contador: 3
Numeros contador: 4
Numeros contador: 5
Numeros contador: 6
Numeros contador: 7
Numeros contador: 8
Numeros contador: 9
Numeros contador: 10
Numero Acumulado: 10
FOR IN REVERSE
ACCEPT anum PROMPT 'DIGITA UN NUMERO'
DECLARE
v_dato VARCHAR2(2):='&anum';
v_contador NUMBER(2):=0;
v_num NUMBER(2):=TO_NUMBER(v_dato);
v_acum NUMBER(2):=0;
BEGIN
FOR v_contador IN REVERSE 1..v_num LOOP
v_acum:=v_acum+1;
DBMS_OUTPUT.put_line('Numeros contador:'||TO_CHAR(v_contador));
END LOOP;
DBMS_OUTPUT.put_line('Numero Acumulado:'||TO_CHAR(v_acum));
END;
Resultado:
Numeros contador: 10
Numeros contador: 9
Numeros contador: 8
Numeros contador: 7
Numeros contador: 6
Numeros contador: 5
Numeros contador: 4
Numeros contador: 3
Numeros contador: 2
Numeros contador: 1
Numero Acumulado: 10
CURSORES
Declarar un cursor implícito de nombre cpuestos y seleccionar los campos departamento,
puesto y sueldo.
DECLARE
CURSOR cpuestos IS
SELECT N_DPTO, PUESTO, TO_CHAR(SUELDO) FROM EMPLEADOS;
v_ndpto VARCHAR2(5);
v_puesto VARCHAR2(40);
v_sueldo VARCHAR2(15);
BEGIN
OPEN cpuestos;
LOOP
FETCH cpuestos INTO v_ndpto, v_puesto, v_sueldo;
EXIT WHEN cpuestos%NOTFOUND;
DBMS_OUTPUT.put_line(v_ndpto||' '||TO_CHAR(v_sueldo)||' '||v_puesto);
END LOOP;
CLOSE cpuestos;
END;
TAREA 4
SELECT ALUMNOS.MATRICULA,ALUMNOS.NOMBRE,CARRERAS.DESCRIPCION FROM
ALUMNOS,CARRERAS WHERE ALUMNOS.CVE_CARRERA = CARRERAS.CVE_CARRERA;
RESULTADO:
MATRICULA NOMBRE DESCRIPCION
--------- -------------------- --------------------------------------------------
4201 MANUEL GESTION DE LAS TECNOLOGIAS DE LA INFORMACION
4202 PEDRO GESTION DE LAS TECNOLOGIAS DE LA INFORMACION
4203 JUAN GESTION DE LAS TECNOLOGIAS DE LA INFORMACION
4204 ARIEL GESTION DE LAS TECNOLOGIAS DE LA INFORMACION
CURSORES EXPLICITOS AVANZADOS
ACCEPT eldepa PROMPT 'DIGITE EL NUMERO DE DEPTO: 1800-1805'
DECLARE
v_ndepa VARCHAR2(4):=TO_CHAR('&eldepa');
CURSOR cpuestos(v_departamento IN VARCHAR2) IS
SELECT N_DPTO,NOMBRE,AP_PATERNO,PUESTO,TO_CHAR(SUELDO)
FROM EMPLEADOS WHERE N_DPTO=v_departamento;
v_ndpto VARCHAR2(5);
v_nombre VARCHAR2(20);
v_paterno VARCHAR2(20);
v_puesto VARCHAR2(40);
v_sueldo VARCHAR2(15);
BEGIN
OPEN cpuestos (v_ndepa);
LOOP
FETCH cpuestos INTO v_ndpto,v_nombre,v_paterno,v_puesto,v_sueldo;
EXIT WHEN cpuestos%NOTFOUND;
DBMS_OUTPUT.put_line(v_ndpto||' '||TO_CHAR(v_sueldo)||' '||v_nombre||'
'||v_paterno||' '||v_puesto);
END LOOP;
CLOSE cpuestos;
END;
ACCEPT eldepa PROMPT 'DIGITE EL NUMERO DE DEPARTAMENTO'
DECLARE
v_ndepa VARCHAR2(4):=TO_CHAR('&eldepa');
CURSOR cpuestos(v_departamento IN VARCHAR2)IS
SELECT NUM_EMPLEADO, N_DPTO, NOMBRE, AP_PATERNO, PUESTO, TO_CHAR(SUELDO)
FROM
EMPLEADOS WHERE N_DPTO = v_departamento FOR UPDATE;
v_numemp VARCHAR2(4);
v_ndpto VARCHAR2(5);
v_nombre VARCHAR2(20);
v_paterno VARCHAR2(20);
v_puesto VARCHAR2(40);
v_aumento NUMBER(7,2);
v_sueldo VARCHAR2(15);
BEGIN
OPEN cpuestos (v_ndepa);
LOOP
FETCH cpuestos INTO v_numemp, v_ndpto, v_nombre, v_paterno, v_puesto, v_sueldo;
v_aumento := 0;
v_aumento := v_sueldo+1000;
UPDATE empleados SET sueldo=v_aumento WHERE NUM_EMPLEADO=v_numemp;
EXIT WHEN cpuestos%NOTFOUND;
DBMS_OUTPUT.put_line(v_ndpto||' '||TO_CHAR(v_sueldo)||' '||v_nombre||'
'||v_paterno||' '||v_puesto);
END LOOP;
CLOSE cpuestos;
END;
CLAUSULA WHERE CURRENT OF
Esta clausula se utiliza en la instrucción SELECT cuando se acompaña de la clausula FOR
UPDATE en un cursor de actualización, el cual hace que solo se modifiquen los registros
actuales del cursor.
ACCEPT eldepa PROMPT 'DIGITE EL NÙMERO DE DEPARTAMENTO'
DECLARE
v_ndepa VARCHAR2(4):=TO_CHAR('&eldepa');
CURSOR cpuestos(v_departamento IN VARCHAR2) IS
SELECT N_DPTO, NOMBRE, AP_PATERNO, PUESTO, TO_CHAR(SUELDO)
FROM EMPLEADOS WHERE N_DPTO=v_departamento FOR UPDATE;
v_ndpto VARCHAR(5);
v_nombre VARCHAR2(20);
v_paterno VARCHAR2(20);
v_puesto VARCHAR2(40);
v_sueldo VARCHAR2(15);
v_aumento NUMBER(7,2);
BEGIN
OPEN cpuestos (v_ndepa);
LOOP
FETCH cpuestos INTO v_ndpto, v_nombre, v_paterno, v_puesto, v_sueldo;
EXIT WHEN cpuestos%NOTFOUND;
UPDATE empleados SET sueldo= v_sueldo+1000 WHERE CURRENT OF
cpuestos;
DBMS_OUTPUT.put_line(v_ndpto ||' '||TO_CHAR(v_sueldo)||' '||v_nombre||'
'||v_paterno||' '||v_puesto);
END LOOP;
CLOSE cpuestos;
END;
Resultado:
1802 21000 CARLOS AGUILAR JEFE DE INFORMATICA
1802 16000 JUAN LOPEZ CAPTURISTA
1802 10500 ANTONIO LUGO OPERADOR DE SISTEMAS
1802 14500 ROBERTO OCHOA PROGRAMADOR A
1802 12500 GABRIEL TORRES ANALISTA DE SISTEMAS
1802 7000 VICTOR IBARRA ORTIZ PATRON DEL MAL
CURSOR CON SUBCONSULTAS
Selecciona al empleado con máximo sueldo en la nomina.
DECLARE
CURSOR cpuestos IS
SELECT N_DPTO, NOMBRE, AP_PATERNO, PUESTO, TO_CHAR(SUELDO)
FROM EMPLEADOS WHERE empleados.sueldo = (Select max(empleados.sueldo) from
empleados);
v_ndpto VARCHAR2(5);
v_nombre VARCHAR2(20);
v_paterno VARCHAR2(20);
v_puesto VARCHAR2(40);
v_sueldo VARCHAR2(15);
BEGIN
OPEN cpuestos;
LOOP
FETCH cpuestos INTO v_ndpto, v_nombre, v_paterno, v_puesto, v_sueldo;
EXIT WHEN cpuestos%NOTFOUND;
DBMS_OUTPUT.put_line(v_ndpto ||' '||TO_CHAR(v_sueldo)||' '||v_nombre||'
'||v_paterno||' '||v_puesto);
END LOOP;
CLOSE cpuestos;
END;
Resultado:
1800 35000 ANDREA MENDOZA GERENTE
Instrucción UNION devuelve las suma de dos o más conjuntos de resultados
SELECT NOMBRE,AP_PATERNO,AP_MATERNO FROM ALUMNOS UNION
SELECT NOMBRE, AP_PATERNO,AP_MATERNO FROM EMPLEADOS;
Resultado
NOMBRE AP_PATERNO AP_MATERNO
-------------------- --------------- ---------------
ALBERTO CASAS HERNANDEZ
ALICIA PEREZ CASTELO
ANDREA MENDOZA DIAZ
ANGELICA ESPINOZA PINEDO
ANGELICA PINEDO GONZALEZ
ANTONIO LUGO ORTEGA
ARIEL VALENZUELA NUÑEZ
CARLOS AGUILAR LOZANO
DANNYA BELTRAN ALVAREZ
VICTOR IBARRA ORTIZ
VICTOR IBARRA ORTIZ
ELVIA CID GARCIA
GABRIEL TORRES FREGOSO
INES ARMENTA CRUZ
JUAN ALCANTAR LIZARRAGA
JUAN LOPEZ RUIZ
LIZETH CASTRO ROBLES
LUCIA RIOS LARA
LUIS PABLOS CALDERON
MAGDA IBARRA MARTINEZ
MANUEL RAMIREZ PARRA
NOE PEREZ GARCIA
PEDRO BENITEZ RUIZ
RAUL GARCIA GUERRERO
ROBERTO OCHOA FERNANDEZ
ROCIO RUIZ FRANCO
SERGIO ROBLES DIAZ
27 filas seleccionadas
SELECT NOMBRE,AP_PATERNO,AP_MATERNO FROM ALUMNOS INTERSECT
SELECT NOMBRE, AP_PATERNO,AP_MATERNO FROM EMPLEADOS;
RESULTADO:
NOMBRE AP_PATERNO AP_MATERNO
VICTOR IBARRA ORTIZ
SELECT NOMBRE,AP_PATERNO,AP_MATERNO FROM ALUMNOS MINUS
SELECT NOMBRE, AP_PATERNO,AP_MATERNO FROM EMPLEADOS;
RESULTADO:
NOMBRE AP_PATERNO AP_MATERNO
-------------------- --------------- ---------------
ALICIA PEREZ CASTELO
ARIEL VALENZUELA NUÑEZ
DANNYA BELTRAN ALVAREZ
VICTOR IBARRA ORTIZ
JUAN ALCANTAR LIZARRAGA
LUCIA RIOS LARA
LUIS PABLOS CALDERON
MAGDA IBARRA MARTINEZ
MANUEL RAMIREZ PARRA
PEDRO BENITEZ RUIZ
ROCIO RUIZ FRANCO
SERGIO ROBLES DIAZ
12 filas seleccionadas
TAREAS EXTRACLASE.
• FUNCIONES DE CONVERSION.• RESTRICCIONES DE INTEGRIDAD EN LAS BD.• SEGURIDAD EN BASE DE DATOS.• LECTURA SEGURIDAD EN BASE DE DATOS.• BASE DE DATOS DISTRIBUIDA Y
ARQUITECTURA CLIENTE SERVIDOR.• LECTURA BASE DE DATOS DISTRIBUIDA Y
ARQUITECTURA CLIENTE SERVIDOR.
Alter table
Sirve para cambiar la definición de una tabla. Podemos cambiar tanto columnas como
restricciones (ver CONSTRAINTS).
La sintaxis es:
ALTER TABLE [esquema.]tabla {ADD|MODIFY|DROP}...
Añadir una columna a una tabla:
ALTER TABLE T_PEDIDOS ADD TEXTOPEDIDO Varchar2(35);
Cambiar el tamaño de una columna en una tabla:
ALTER TABLE T_PEDIDOS MODIFY TEXTOPEDIDO Varchar2(135);
Hacer NOT NULL una columna en una tabla:
ALTER TABLE T_PEDIDOS MODIFY (TEXTOPEDIDO NOT NULL);
Eliminar una columna a una tabla:
ALTER TABLE T_PEDIDOS DROP COLUMN TEXTOPEDIDO;
Valor por defecto de una columna:
ALTER TABLE T_PEDIDOS MODIFY TEXTOPEDIDO Varchar2(135) DEFAULT 'ABC...';
Añade dos columnas:
ALTER TABLE T_PEDIDOS
ADD (SO_PEDIDOS_ID INT, TEXTOPEDIDO Varchar2(135));
Comment
Pone un comentario en el diccionario de datos.
Sintaxis para tablas y vistas:
COMMENT ON TABLE [esquema.]tabla IS 'comentario';
COMMENT ON TABLE [esquema.]vista IS 'comentario';
COMMENT ON TABLE [esquema.]vista_materilizada IS 'comentario';
Sintaxis para columnas:
COMMENT ON COLUMN [esquema.]tabla.columna IS 'comentario';
COMMENT ON COLUMN [esquema.]vista.columna IS 'comentario';
COMMENT ON COLUMN [esquema.]vista_materilizada.columna IS 'comentario';
Ejemplo de tabla y columna:
COMMENT ON TABLE T_PRODUCTOS IS 'Tabla de productos';
COMMENT ON COLUMN T_PRODUCTOS.numproduct IS 'Codigo de 6 digitos del producto';
COMMENT ON COLUMN T_PRODUCTOS.desproduct IS 'Descripcion del producto';
Para borrar un comentario hay que ponerle la cadena vacía ''.
COMMENT ON TABLE T_PRODUCTOS IS '';
COMMENT ON COLUMN T_PRODUCTOS.numproduct IS '';
Constraints
Para cambiar las restricciones y la clave primaria de una tabla debemos usar ALTER
TABLE.
Crear una clave primaria (primary key):
ALTER TABLE T_PEDIDOS ADD CONSTRAINT PK_PEDIDOS
PRIMARY KEY (numpedido,lineapedido);
Crear una clave externa, para integridad referencial (foreign key):
ALTER TABLE T_PEDIDOS ADD CONSTRAINT FK_PEDIDOS_CLIENTES
FOREIGN KEY (codcliente) REFERENCES T_CLIENTES (codcliente));
Crear un control de valores (check constraint):
ALTER TABLE T_PEDIDOS ADD CONSTRAINT CK_ESTADO
CHECK (estado IN (1,2,3));
Crear una restricción UNIQUE:
ALTER TABLE T_PEDIDOS ADD CONSTRAINT UK_ESTADO
UNIQUE (correosid);
Normalmente una restricción de este tipo se implementa mediante un indice único
(ver CREATE INDEX).
Borrar una restricción:
ALTER TABLE T_PEDIDOS DROP CONSTRAINT CON1_PEDIDOS;
Deshabilita una restricción:
ALTER TABLE T_PEDIDOS DISABLE CONSTRAINT CON1_PEDIDOS;
Habilita una restricción:
ALTER TABLE T_PEDIDOS ENABLE CONSTRAINT CON1_PEDIDOS;
La sintaxis ALTER TABLE para restricciones es:
ALTER TABLE [esquema.]tabla
constraint_clause,...
[ENABLE enable_clause | DISABLE disable_clause]
[{ENABLE|DISABLE} TABLE LOCK]
[{ENABLE|DISABLE} ALL TRIGGERS];
Donde constraint_clause puede ser alguna de las siguientes entradas:
ADD out_of_line_constraint(s)
ADD out_of_line_referential_constraint
DROP PRIMARY KEY [CASCADE] [{KEEP|DROP} INDEX]
DROP UNIQUE (column,...) [{KEEP|DROP} INDEX]
DROP CONSTRAINT constraint [CASCADE]
MODIFY CONSTRAINT constraint constrnt_state
MODIFY PRIMARY KEY constrnt_state
MODIFY UNIQUE (column,...) constrnt_state
RENAME CONSTRAINT constraint TO new_name
Donde a su vez constrnt_state puede ser:
[[NOT] DEFERRABLE] [INITIALLY {IMMEDIATE|DEFERRED}]
[RELY | NORELY] [USING INDEX using_index_clause]
[ENABLE|DISABLE] [VALIDATE|NOVALIDATE]
[EXCEPTIONS INTO [schema.]table]
Borrar una restricción:
ALTER TABLE T_PEDIDOS DROP CONSTRAINT CON1_PEDIDOS;
Create Database
Sirve para crea una base de datos.
Desde el punto de vista físico, una base de datos es, para oracle, un conjunto de
ficheros, a saber:
datafiles, ficheros de datos, definidos en la creación de la base de datos.
log files, ficheros de log, definidos también en la creación de la base de datos.
init.ora, fichero de texto que contiene los parámetros de configuración de la base de
datos.
control files, ficheros de control, definidos en el init.ora
password file, fichero con la password del BDA y los operadores (todos los demás
usuarios están definidos en tablas).
Así para crear una base de datos, una vez instalado oracle, debemos seguir los siguientes pasos:
1) Definir ORACLE_SID
ORACLE_HOME = E:\Oracle\Product\10.0.0
ORACLE_SID = GESTION
2) Crear el fichero INIT.ORA
C:\>ORACLE_HOME\database\initGESTION.ora
control_files =
(/path/to/control1.ctl,/path/to/control2.ctl,/path/to/control3.ctl)
undo_management = AUTO
undo_tablespace = UNDOTBS1
db_name = GESTION
db_block_size = 8192
sga_max_size = 1073741824
sga_target = 1073741824
3) Definir fichero de passwords
$ORACLE_HOME\bin\orapwd file=ORACLE_HOME\database\pwdGESTION.ora
password=oracle entries=10
Podemos generar los pasos 2) y 3) con una sola instrucción:
oradim -new -sid GESTION -intpwd -maxusers 20 -startmode auto
-pfile E:\Oracle\Product\10.0.0\Database\initGESTION.ora
4) Arrancar la instancia
C:\>sqlplus / as sysdba
sql> startup nomount
5) Crea la base de datos con el nombre(o SID) GESTION y el char set WE8ISO8859P1
CREATE DATABASE GESTION
LOGFILE 'E:\OraData\GESTION\LOG1GESTION.ORA' SIZE 2M,
'E:\OraData\GESTION\LOG2GESTION.ORA' SIZE 2M,
'E:\OraData\GESTION\LOG3GESTION.ORA' SIZE 2M,
'E:\OraData\GESTION\LOG4GESTION.ORA' SIZE 2M,
'E:\OraData\GESTION\LOG5GESTION.ORA' SIZE 2M
EXTENT MANAGEMENT LOCAL
MAXDATAFILES 100
DATAFILE 'E:\OraData\GESTION\SYS1GESTION.ORA' SIZE 50 M
DEFAULT TEMPORARY TABLESPACE temp TEMPFILE 'E:\OraData\GESTION\TEMP.ORA' SIZE
50 M
UNDO TABLESPACE undo DATAFILE 'E:\OraData\GESTION\UNDO.ORA' SIZE 50 M
NOARCHIVELOG
CHARACTER SET WE8ISO8859P1;
6) Ejecutar sql de creación: catalog.sql y catproc.sql
Sintaxis completa:
CREATE DATABASE nombreDB opciones
Donde las opciones:
DATAFILE filespec AUTOEXTEND OFF
DATAFILE filespec AUTOEXTEND ON [NEXT int K | M] [MAXSIZE int K | M]
MAXDATAFILES int
EXTENT MANAGEMENT LOCAL
DEFAULT TEMPORARY TABLESPACE tablespace [TEMPFILE filespec]
[EXTENT MANAGEMENT LOCAL] [UNIFORM [SIZE
int K | M]]
UNDO TABLESPACE tablespace [DATAFILE filespec]
LOGFILE [GROUP int] filespec
MAXLOGFILES int
MAXLOGMEMBERS int
MAXLOGHISTORY int
MAXINSTANCES int
ARCHIVELOG | NOARCHIVELOG
CONTROLFILE REUSE
CHARACTER SET charset
NATIONAL CHARACTER SET charset
SET TIMEZONE = 'time_zone_region'
SET TIMEZONE = '{+|-} hh:mm'
FORCE LOGGING
USER SYS IDENTIFIED BY password
USER SYSTEM IDENTIFIED BY password
Se puede poner más de un DATAFILE o LOGFILE separando los nombres de fichero con
comas DATAFILE filespec1, filespec2, filespec3
Si no se especifican claves, Oracle establece "change_on_install" para SYS y "manager" para SYSTEM.
Después de crear la base de datos podemos cambiar entre los modos ARCHIVELOG,
NOARCHIVELOG con la sentencia ALTER DATABASE.
Global Temporary Tables
Crea una tabla temporal personal para cada sesión. Eso significa que los datos no se
comparten entre sesiones y se eliminan al final de la misma.
CREATE GLOBAL TEMPORARY TABLE tabla_temp (
columna datatype [DEFAULT expr] [column_constraint(s)]
[,columna datatype [,...]]
) {ON COMMIT DELETE ROWS | ON COMMIT PRESERVE ROWS};
Con la opcion ON COMMIT DELETE ROWS se borran los datos cada vez que se hace COMMIT en la sesión.
Con la opción ON PRESERVE DELETE ROWS los datos no se borran hasta el final de la
sesión.
Create Index
Los índices se usan para mejorar el rendimiento de las operaciones sobre una tabla.
En general mejoran el rendimiento las SELECT y empeoran (mínimamente) el
rendimiento de los INSERTy los DELETE.
Una vez creados no es necesario nada más, oracle los usa cuando es posible (ver EXPLAIN PLAN).
En oracle existen tres tipos de índices:
1)Table Index:
CREATE [UNIQUE|BITMAP] INDEX [esquema.]index_name
ON [esquema.]table_name [tbl_alias]
(col [ASC | DESC]) index_clause index_attribs
2)Bitmap Join Index:
CREATE [UNIQUE|BITMAP] INDEX [esquema.]index_name
ON [esquema.]table_name [tbl_alias]
(col_expression [ASC | DESC])
FROM [esquema.]table_name [tbl_alias]
WHERE condition [index_clause] index_attribs
3)Cluster Index:
CREATE [UNIQUE|BITMAP] INDEX [esquema.]index_name
ON CLUSTER [esquema.]cluster_name index_attribs
las index_clauses posibles son:
LOCAL STORE IN (tablespace)
LOCAL STORE IN (tablespace)
(PARTITION [partition
[LOGGING|NOLOGGING]
[TABLESPACE {tablespace|DEFAULT}]
[PCTFREE int]
[PCTUSED int]
[INITRANS int]
[MAXTRANS int]
[STORAGE storage_clause]
[STORE IN {tablespace_name|DEFAULT]
[SUBPARTITION [subpartition [TABLESPACE tablespace]]]])
LOCAL (PARTITION [partition
[LOGGING|NOLOGGING]
[TABLESPACE {tablespace|DEFAULT}]
[PCTFREE int]
[PCTUSED int]
[INITRANS int]
[MAXTRANS int]
[STORAGE storage_clause]
[STORE IN {tablespace_name|DEFAULT]
[SUBPARTITION [subpartition [TABLESPACE tablespace]]]])
GLOBAL PARTITION BY RANGE (col_list)
( PARTITION partition VALUES LESS THAN (value_list)
[LOGGING|NOLOGGING]
[TABLESPACE {tablespace|DEFAULT}]
[PCTFREE int]
[PCTUSED int]
[INITRANS int]
[MAXTRANS int]
[STORAGE storage_clause] )
INDEXTYPE IS indextype [PARALLEL int|NOPARALLEL] [PARAMETERS ('ODCI_Params')]
{Esto es solo para table index, no para bitmap join Index}
Y además index_attribs puede ser cualquier combinación de los siguientes:
NOSORT|SORT
REVERSE
COMPRESS int
NOCOMPRESS
COMPUTE STATISTICS
[NO]LOGGING
ONLINE
TABLESPACE {tablespace|DEFAULT}
PCTFREE int
PCTUSED int
INITRANS int
MAXTRANS int
STORAGE storage_clause
PARALLEL parallel_clause
Si usamos la opción PARALLEL esta debe estar al final.
create index es una de las pocas sentencias que pueden usar nologging option.
create index requiere un segmento temporal si no hay espacio en memoria suficiente.
Crear indices basados en funciones requiere que query_rewrite_enabled este a true y
query_rewrite_integrity este a trusted.
Un ejemplo de índices basados en funciones para búsquedas en mayúsculas:
CREATE INDEX idx_case_ins ON my_table(UPPER(empname));
SELECT * FROM my_table WHERE UPPER(empname) = 'KARL';
Función DECODE
Traduce una expresión a un valor de retorno. Si expr es igual a value1, la función
devuelve Return1. Si expr es igual a value2, la función devuelve Return2. Y asi sucesivamente. Si expr no es igual a ningun valor la función devuelve el valor por
defecto.
DECODE(expr, value1 [, return1, value2, return2....,] default )
Si ejecutamos:
SELECT DECODE(ESTADO,0,'bien',1,'regular','mal') FROM T_PEDIDOS;
Devuelve:
bien
bien
regular
mal
...
Funcion TO_CHAR
Convierte una fecha a una cadena o un número con el formato especificado.
TO_CHAR(date1 [,fmt]);
TO_CHAR(number1 [,fmt])
Si ejecutamos:
SELECT TO_CHAR(sysdate) FROM DUAL;
Devuelve:
15-JUN-01
Si ejecutamos:
SELECT TO_CHAR(sysdate, 'dd/mm/yyyy') FROM DUAL;
Devuelve:
15/06/2001
Si ejecutamos:
SELECT TO_CHAR(sysdate,'Mon') FROM DUAL;
Devuelve el nombre corto del mes:
Jun
Si ejecutamos:
SELECT TO_CHAR(sysdate, 'Month') FROM DUAL;
Devuelve el nombre largo del mes:
Junio
Si ejecutamos:
SELECT TO_CHAR(sysdate, 'DDD') FROM DUAL;
Devuelve los 3 digitos del día del año:
058
Si ejecutamos:
SELECT TO_CHAR(123.456, '09999') FROM DUAL;
Devuelve:
00123
Si ejecutamos:
SELECT TO_CHAR(123.456, '09999.9') FROM DUAL;
Devuelve:
00123.5
Si ejecutamos:
SELECT TO_CHAR(123456, 'FM999,999,999') FROM DUAL;
Devuelve:
123,456
Función TO_DATE
Convierte una cadena en un valor de tipo DATE. Ver en TO_CHAR ejemplos de
formato.
TO_DATE(char [,fmt])
Si ejecutamos:
SELECT TO_DATE('31/10/2007','DD/MM/YYYY') FROM DUAL;
Devuelve:
31/10/2007
Sentencia SELECT
La selección sobre una tabla consiste en elegir un subconjunto de filas que cumplan (o no)
algunas condiciones determinadas. La sintaxis de una sentencia de este tipo es la siguiente:
SELECT */ columna1, columna2,....
FROM nombre-tabla
[WHERE condición]
[GROUP BY columna1, columna2.... ]
[HAVING condición-selección-grupos ]
[ORDER BY columna1 [DESC], columna2 [DESC]... ]
Si ejecutamos:
SELECT * FROM T_PEDIDOS;
Nos da la salida:
COD_PEDIDO NOMBRE ESTADO
-------------------------------------------------
1 JUAN 0
2 ANTONIO 1
3 PEPE 0
...
Grant (dar permisos)
Esta sentencia sirve para dar permisos (o privilegios) a un usuario o a un rol.
Un permiso, en oracle, es un derecho a ejecutar un sentencia (system privileges) o a
acceder a un objeto de otro usuario (object privileges).
El conjunto de permisos es fijo, esto quiere decir que no se pueden crear nuevos tipos
de permisos.
Si un permiso se asigna a rol especial PUBLIC significa que puede ser ejecutado por
todos los usuarios.
Permisos para acceder a la base de datos (permiso de sistema):
GRANT CREATE SESSION TO miusuario;
Permisos para usuario de modificación de datos (permiso sobre objeto):
GRANT SELECT, INSERT, UPDATE, DELETE ON T_PEDIDOS TO miusuario;
Permisos de solo lectura para todos:
GRANT SELECT ON T_PEDIDOS TO PUBLIC;
Sentencia INSERT
Añade filas a una tabla.
Para guardar los datos insertados hay que ejecutar COMMIT;
Para cancelar la inserción podemos hacer ROLLBACK;
Un formato posible es:
INSERT INTO nombre-tabla
VALUES (serie de valores)
El orden en el que se asignen los valores en la cláusula VALUES tiene que coincidir con el orden en que se definieron las columnas en la creación del objeto tabla, dado que
los valores se asignan por posicionamiento relativo.
Por ejemplo:
INSERT INTO T_PEDIDOS
VALUES (125,2,'PEPE');
Otra forma de usar la sentencia INSERT es:
INSERT INTO nombre-tabla (columna1, columna2.....)
VALUES (valor1, valor2....)
En este caso los valores se asignarán a cada una de las columnas mencionadas por posicionamiento relativo.
Es necesario que por lo menos se asignen valores a todas aquellas columnas que no
admiten valores nulos en la tabla (NOT NULL).
Por ejemplo:
INSERT INTO T_PEDIDOS (CODPEDIDO,ESTADO)
VALUES (125,2);
Sentencia INSERT de múltiples filas
Para insertar un subconjunto de filas de una tabla en otra se escribe una sentencia
INSERT con una SUBSELECT interna. Los formatos posibles son:
INSERT INTO nombre-tabla (columna1, columna2.....)
SELECT ([sentencia Select])
Asigna a las columnas los valores recuperados en la sentencia Select. Inserta en la
tabla todas las filas que se recuperen en la Select.
Por ejemplo:
INSERT INTO T_PEDIDOS (CODPEDIDO,ESTADO,NOMBRE)
SELECT CODPEDIDO+100,ESTADO,NOMBRE FROM T_PEDIDOS WHERE CODPEDIDO IN (1,2,3);
Otra forma es:
INSERT INTO nombre-tabla SELECT * FROM nombre-tabla-fuente
En este caso las estructuras de las tablas tienen que ser iguales.
Este ejemplo copia hasta el pedido 100 en otra tabla:
INSERT INTO T_PEDIDOS_BAK
SELECT * FROM T_PEDIDOS WHERE CODPEDIDO<100;
Ambas tablas son iguales.
Tunning (optimización)
El objetivo de tunning es la puesta a punto (optimización) de las sentencias SQL,
desde el punto de vista del tiempo de ejecución y consumo de recursos.
Podemos examinar el comportamiento de una sentencia SQL analizando su plan de ejecución: 1. con la sentencia EXPLAIN PLAN
2. con trazas TRACE Para optimizar las sentencias SQL podemos:
1. Crear índices adecuados y fomentar su uso (CREATE INDEX).
2. Aplicar HINTS para modificar o influenciar las decisiones del optimizador. 3. Actualizar estadísticas periódicamente (ANALYZE).
4. Usar clausulas STORAGE adecuada en la creación de tablas (CREATE TABLE).
5. Usar EXPORT IMPORT.
6. Cuidar la programación.
En particular debemos prestar atención la sentencias SELECT que son más dadas a la
complejidad.
Sentencia UPDATE
Actualiza valores de una o más columnas para un subconjunto de filas de una tabla.
Para guardar cambios hay que ejecutar COMMIT;
Para cancelar la modificación podemos hacer ROLLBACK;
UPDATE nombre-tabla
SET columna1 = valor1 [, columna2 = valor2 ...]
[WHERE condición]
Actualiza los campos correspondientes junto con los valores que se le asignen, en el
subconjunto de filas que cumplan la condición de selección.
Si no se pone condición de selección, la actualización se da en todas las filas de la
tabla.
Si se desea actualizar a nulos, se asignará el valor NULL.
En este ejemplo cambiamos el nombre y estado de un pedido:
UPDATE T_PEDIDOS
SET NOMBRE='JUAN',ESTADO=1
WHERE CODPEDIDO=125;
En este ejemplo cambiamos el estado de todos los pedidos:
UPDATE T_PEDIDOS
SET ESTADO=1;
En este ejemplo ponemos a nulo el nombre de un pedido:
UPDATE T_PEDIDOS
SET NOMBRE=NULL
WHERE CODPEDIDO=125;
Create User
Esta sentencia sirve para crear un usuario oracle.
Un usuario es un nombre de acceso a la base de datos oracle. Normalmente va
asociado a una clave (password).
Lo que puede hacer un usuario una vez ha accedido a la base de datos depende de los
permisos que tenga asignados ya sea directamente (GRANT) como sobre algun rol que tenga asignado (CREATE ROLE).
El perfil que tenga asignado influye en los recursos del sistema de los que dispone un
usuario a la hora de ejecutar oracle (CREATE PROFILE).
La sintaxis es:
CREATE USER username
IDENTIFIED {BY password | EXTERNALLY | GLOBALLY AS 'external_name'}
options;
Donde options:
DEFAULT TABLESPACE tablespace
TEMPORARY TABLESPACE tablespace
QUOTA int {K | M} ON tablespace
QUOTA UNLIMITED ON tablespace
PROFILE profile_name
PASSWORD EXPIRE
ACCOUNT {LOCK|UNLOCK}
Crea un usuario sin derecho a guardar datos o crear objetos:
CREATE USER usuariolimitado IDENTIFIED BY miclavesecreta;
Crea un usuario con todos los derechos para guardar datos o crear objetos:
DROP USER miusuario CASCADE;
CREATE USER miusuario IDENTIFIED BY miclavesecreta
DEFAULT TABLESPACE data
TEMPORARY TABLESPACE temp
QUOTA UNLIMITED ON data;
CREATE ROLE programador;
GRANT CREATE session, CREATE table, CREATE view,
CREATE procedure,CREATE synonym,
ALTER table, ALTER view, ALTER procedure,ALTER synonym,
DROP table, DROP view, DROP procedure,DROP synonym,
TO conn;
GRANT programador TO miusuario;
Es necesario crear el usuario antes de asignar permisos con GRANT o un ROLE por defecto.
Tarea.
Funciones de conversión en Oracle.
Víctor Hugo Ibarra Ortiz.
Cd. Obregón, Sonora a 17 de Enero de 2013.
RESTRICCIONES DE INTEGRIDAD EN LAS BASES DE DATOS.
JESUS ISIDRO ESPINOZA.
VICTOR HUGO IBARRA.
RESTRICCIONES DE INTEGRIDAD EN
LAS BASES DE DATOS.
Según [Korth y Silberschatz ]
La integridad Proporciona un medio de asegurar que los
cambios que se hacen en la base de datos por usuarios
autorizados no resultan en una pérdida de consistencia de
los datos.
Según [ David M. Kroenke]
Un conjunto de datos tiene integridad si son consistentes,
si se ensamblan entre sí. Con frecuencia, en los sistemas
de procesamiento de archivos se aprecia una pobre
integridad de los datos.
En Resumen: La integridad Proporciona un medio de
asegurar que los cambios que se hacen en la base de
datos por usuarios autorizados no resultan en una pérdida
de consistencia de los datos.
RESTRICCIONES
BÁSICAS.
• RESTRICCIONES DE
DOMINIO.
• RESTRICCIÓN DE VALORES
NULOS.
• RESTRICCIÓN DE CLAVE.
• RESTRICCIÓN DE
ASERCIÓN.
RESTRICCIONES DE
DOMINIO.
Los límites de dominios son la forma más elemental de
restricciones de integridad. Son fáciles de probar por el
sistema siempre que se introduce un nuevo dato en la
base de datos.
Es posible que varios atributos tengan el mismo dominio.
Por ejemplo, los atributos nombre-cliente y nombre
empleado podrían tener el mismo dominio, el conjunto de
todos los nombres de personas. Sin embargo los dominios
de saldo y nombre-sucursal, por supuesto, deben ser
distintos. En el nivel de implementación, los nombres de
cliente y los nombres de sucursal son cadenas de
caracteres. Podemos ver que una definición adecuada de
restricciones de dominio no sólo nos permite probar
valores insertados en la base de datos sino que también
nos permite probar consultas para asegurar que la
comparación que se hace tiene sentido.
RESUMEN.
Las restricciones de dominio especifican que el valor de cada atributo A debe ser un valor atómico del dominio dom(A) para ese atributo. Los tipos de datos asociados a los dominios por lo general incluyen los tipos de datos numéricos estándar de los números enteros (como entero- corto, entero, entero-largo) y reales (flotante y flotante de doble precisión). También disponemos de caracteres, cadenas de longitud fija y cadenas de longitud variable, así como tipos de datos de fecha, hora, marca de tiempo y dinero. Otros dominios posibles se pueden describir mediante un intervalo de valores de un tipo de datos o como un tipo de datos enumerado en el que se listan explícitamente todos los valores posibles.
Regresar
RESTRICCIONES DE
VALORES NULOS.
Para determinado atributos, los valores nulos pueden ser inapropiados. Considérese una tupla en la relación cliente la que nombre-cliente es un valor vació. Una tupla de este tipo da una calle y una ciudad para un cliente anónimo y, por tanto, no contiene información útil. En casos como éste, deseamos prohibir los valores nulos, restringiendo el dominio de ciudad-cliente para que excluya los valores nulos.
El SQL estándar permite que la declaración del dominio de un atributo incluya la especificación not null . Esto prohíbe la inserción de un valor nulo para este atributo. Cualquier modificación de la base de datos que causara que se insertase un valor nulo en un dominio not null genera un diagnóstico de error.
Hay muchas situaciones en las que la prohibición de valores nulos es deseable. Un caso particular en el que es esencial prohibir los valores nulos es en la clave primaria de un esquema de relación.
RESUMEN.
Si muchos de los tributos no se aplican a todas las tuplas de la relación, se acabará con un gran número de nulos en esas tuplas. Esto puede originar un considerable desperdicio en el nivel de almacenamiento y posiblemente dificultar el entendimiento del significado de los atributos y la especificación de operaciones de Reunión con en el nivel lógico. Otro problema con los nulos es cómo manejarlos cuando se aplican funciones agregadas como COUNT o SUM. Además, los nulos pueden tener múltiples interpretaciones, como los siguientes:
• El atributo no se aplica a esta tupla
• Se desconoce el valor del atributo para esta tupla.
• El valor se conoce pero está ausente; esto es, todavía no se ha registrado.
Tener la misma representación para todos los nulos puede hacer que se confundan los diferentes significados que podrían tener. Por tanto, hasta donde sea posible, evite incluir en una relación base atributos cuyos valores puedan ser nulos. Si no es posible evitar los nulos, asegúrese de que se apliquen sólo en casos excepcionales.
Regresar
RESTRICCIÓN DE CLAVE.
Todos los elementos de un conjunto son distintos; por tanto, todas las tuplas de una relación deben ser distintas. Esto significa que no puede haber dos tuplas que tengan la misma combinación de valores para todos sus atributos.
La restricción de clave es una de las restricciones estándar que con frecuencia aparecen en las aplicaciones de bases de datos. Estas restricciones se manejan de formas ligeramente distintas en los diversos modelos de datos. En el modelo E-R, una clave es un atributo de un tipo de entidades que debe tener un valor único para cada entidad que pertenezca a dicho tipo en cualquier momento específico. Así el valor del atributo clave puede servir para identificar de manera única cada entidad. Los atributos claves deben ser mono valuados, pero pueden ser simples o compuestos.
En general, un esquema de relación pude tener más de una clave. En tal caso, cada una de ellas se denominan clave candidata. Por ejemplo en una relación COCHE tiene dos claves candidatas: NumMatrícula y NumSerieMotor. Es común designar a una de las claves candidata como clave primaria de la relación. Ésta es la clave candidata cuyos valores sirven para identificar las tuplas en la relación.
RESUMEN.
Es una de las restricciones estándar que con frecuencia aparecen en las aplicaciones de bases de datos. Estas restricciones se manejan de formas ligeramente distintas en los diversos modelos de datos. En el modelo E-R, una clave es un atributo de un tipo de entidades que debe tener un valor único para cada entidad que pertenezca a dicho tipo en cualquier momento específico. Así el valor del atributo clave puede servir para identificar de manera única cada entidad. Los atributos claves deben ser monovaluados, pero pueden ser simples o compuestos.
Un tipo de entidades normal puede tener una o más claves; un tipo de entidades débil no tiene clave, pero casi siempre tiene una clave parcial cuyos valores identifican de manera única las entidades débiles que están relacionadas a la misma entidad propietario a través de un vínculo identificador.
En general, un esquema de relación pude tener más de una clave. En tal caso, cada una de ellas se denominan clave candidata. Por ejemplo en una relación COCHE tiene dos claves candidatas: NumMatrícula y NumSerieMotor. Es común designar a una de las claves candidata como clave primaria de la relación. Ésta es la clave candidata cuyos valores sirven para identificar las tuplas en la relación.
Regresar
RESTRICCIÓN DE
ASERCIÓN.
Una Técnica más formal para representar restricciones explícitas es con un lenguaje de especificación de restricciones , que suele basarse en alguna variación del cálculo relacional. Este enfoque declarativo establece una separación clara entre la base de restricciones (en la que las restricciones se almacenan en una forma codificada apropiada) y el subsistema de control de integridad del SGBD (que tiene acceso a la base de restricciones para aplicar estas últimas correctamente a las transacciones afectadas).
Cuando se usa esta técnica, las restricciones suelen llamarse aserciones . Se ha sugerido el uso de esta estrategia con SGBD relaciónales. El subsistema de control de integridad compila las aserciones, que entonces se almacenan en el catalogo del SGBD, donde el subsistema de control de integridad puede consultarlas e imponerlas automáticamente. Esta estrategia es muy atractiva desde el punto de vista de los
usuarios y programadores por su flexibilidad.
RESUMEN.
Una Técnica más formal para representar restricciones explícitas es con un lenguaje de especificación de restricciones , que suele basarse en alguna variación del cálculo relacional. Este enfoque declarativo establece una separación clara entre la base de restricciones (en la que las restricciones se almacenan en una forma codificada apropiada) y el subsistema de control de integridad del SGBD (que tiene acceso a la base de restricciones para aplicar estas últimas correctamente a las transacciones afectadas).
Cuando se usa esta técnica, las restricciones suelen llamarse aserciones. Se ha sugerido el uso de esta estrategia con SGBD relaciónales. El subsistema de control de integridad compila las aserciones, que entonces se almacenan en el catalogo del SGBD, donde el subsistema de control de integridad puede consultarlas e imponerlas automáticamente. Esta estrategia es muy atractiva desde el punto de vista de los usuarios y programadores por su flexibilidad.
Regresar
FIN.
… GRACIAS POR SU
ATENCION.
SEGURIDAD EN BASE DE
DATOS
EDGAR JAVIER URQUIJO RASCÓN
AGUSTIN DUARTE PRECIADO
23 ENERO 2013
SEGURIDAD EN BASE DE DATOS
Gran parte de los errores en cuanto a la
seguridad en base de datos aun con el avance
tecnológico suele producirse por la falta de
preocupación de los procedimientos sencillos
que a la larga se convierten en graves
inconvenientes que afecta en lo concerniente a
la seguridad, todo tiene que quedar de acuerdo
con lo planeado sin ninguna omisión por mas
mínima que sea, así como en la instalación en el
diseño o en el desarrollo, cualquier punto que se
deje sin la preocupación debida que no pude
afectar en nada puede ser la entrada para los
atacantes.
USUARIOS DBA (ADMINISTRADOR DE BASE DE
DATOS)
son los encargados de establecer usuarios
conceder permisos, puede crear borrar modificar
objetos creados por ellos, según el caso que se
presente, también puede dar permisos a otros
usuarios sobre estos objetos creados.
MEDIDAS DE SEGURIDAD
FÍSICAS: Comprende el control de quienes acceden
al equipo.
PERSONAL: Determinación del personal que tiene
el acceso autorizado.
SO: Técnicas que se establecen para proteger la
seguridad del Sistema Operativo.
SGBD: Utilización de las herramientas que facilita el
SGBD
(Sistema de gestión de base de datos)
LA SEGURIDAD (FIABILIDAD) DEL SISTEMA
Es necesario proteger a los sistemas de los
ataques externos.
Controlar los fallos o caídas del software o equipo.
Controlar el manejo del administrador frente a
errores que se pueden cometer.
DONDE ESTÁN LOS INTRUSOS
Existen ataques externos que son detectados y
controlados por el firewall, pero aquí no termina el
problema, de igual forma existen ataques internos,
donde se le permite al usuario acceder libremente
a la base de datos sin ningún tipo de protección
suponiendo que el usuario no actuara con malas
intenciones sobre el contenido almacenado y de
esta forma comienzan un laberinto de problemas.
DIFERENTES TIPOS DE ATAQUES:
ATAQUES QUE NO REQUIEREN AUTENTICACIÓN:
Son los más comunes ya que no se necesita de
ninguna contraseña o clave
ATAQUES QUE REQUIERN AUTENTICACIÓN:
Este tipo de ataques son lanzados por personas que
tienen las claves de acceso obtenidas de formas
generalmente ilícitas
METODOLOGÍA:
Adquisición
Fingerprinting/Sondeo/Descubrimiento
Obtención de acceso
Estalación de privilegios
Compromiso total del host
TAREAS QUE SE DEBEN TOMAR EN CUENTA AL
REALIZAR UNA AUDITORIA DETALLADA
Seguridad física
Políticas y procedimiento
Seguridad a nivel de file system
Seguridad de entorno
Stored procedures
Passwords
SERVICIOS DE SEGURIDAD
Autenticación
Sistema de archivos encriptado
Seguridad IP
Servicios de seguridad Windows
Tarjetas inteligentes
FICHA DE ANÁLISIS DE LECTURA
NOMBRE DEL ALUMNO: Víctor H. Ibarra Ortiz. ________________
UNIDEP 22 de Enero de 2013.
LECTURA: Seguridad de Base de Datos. PÁGINAS: AUTOR: Abraham Silberschatz, Henry F. Korth.
TEMA DE LA LECTURA
La seguridad de las bases de datos se refiere a la protección frente a accesos malintencionados. No es posible la protección absoluta de la base de datos contra el uso malintencionado, pero se puede elevar lo suficiente el coste para quien lo comete como para disuadir la mayor parte, si no la totalidad, de los intentos de tener acceso a la base de datos sin la autorización adecuada. Para proteger la base de datos hay que adoptar medidas de seguridad en varios niveles: Sistema de bases de datos: Puede que algunos usuarios del sistema de bases de datos sólo estén autorizados a tener acceso a una parte limitada de la base de datos. Puede que otros usuarios estén autorizados a formular consultas pero tengan prohibido modificar los datos. Es responsabilidad del sistema de bases de datos asegurarse de que no se violen estas restricciones de autorización. Sistema operativo: Independientemente de lo seguro que pueda ser el sistema de bases de datos, la debilidad de la seguridad del sistema operativo puede servir como medio para el acceso no autorizado a la base de datos. Red: Dado que casi todos los sistemas de bases de datos permiten el acceso remoto mediante terminales o redes, la seguridad en el nivel del software de la red es tan importante como la seguridad física, tanto en Internet como en las redes privadas de las empresas. Físico: Los sitios que contienen los sistemas informáticos deben estar protegidos físicamente contra la entrada de intrusos. Humano: Los usuarios deben ser autorizados cuidadosamente para reducir la posibilidad de que alguno de ellos dé acceso a intrusos a cambio de sobornos u otros favores. Debe conservarse la seguridad en todos estos niveles si hay que asegurar la seguridad de la base de datos. La debilidad de los niveles bajos de seguridad (físico o humano) permite burlar las medidas de seguridad estrictas de niveles superiores (base de datos). En el resto de este apartado se aborda la seguridad en el nivel del sistema de bases de datos. La seguridad en los niveles físico y humano, aunque importante, cae fuera del alcance de este texto.
INTEGRIDAD Y SEGURIDAD.
IDEA (S) CENTRAL (ES)
Los datos guardados en la base de datos deben
estar protegidos contra los accesos no autorizados,
de la destrucción o alteración malintencionadas
además de la introducción accidental de
inconsistencias que evitan las restricciones de
integridad.
Comprender que la seguridad en la base de datos
es de vital importancia para proteger de la misma
de ataques maliciosos ya sean externos o internos.
OBJETIVO DE LA LECTURA CON RESPECTO A NOSOTROS O DEL CURSO
SINTESIS:
José Juan
Garcia
Luis Molina
Oscar
Amavizca
La tecnología y prototipo de los
sistemas de gestión de bases de
datos distribuidas se han
desarrollado de uno a otro y
cada sistema adopta una
arquitectura particular propia.
El diseñó de una BDD
involucra 4 pasos:
1. Diseño del esquema
conceptual donde se describe
la BD integral.
2. Diseño de fragmentación.
3. Diseño de la asignación de
los fragmentos.
4. Diseño de la BD física
(transformar los esquemas
locales en áreas de
almacenamiento y determinar
métodos de acceso
apropiados).
La fragmentación y asignación de los datos caracterizan el diseño de BDD. La fragmentación se ocupa fundamentalmente de los criterios lógicos que motivan la división de relaciones globales en fragmentos, mientras que la asignación se ocupa de los aspectos físicos de su ubicación y réplicas en sitios; aunque hay una diferencia entre ambos procesos, su interrelación es importante para obtener un diseño óptimo.
En caso que también se distribuyan las aplicaciones debemos tener en cuenta el diseño de los esquemas, los requerimientos más importantes de las aplicaciones tenemos las siguientes:
1. Sitio que comparte una aplicación.
2. Frecuencia de activación de la aplicación
3. Cantidad, tipo y distribución estadística de los accesos de cada aplicación a cada dato requerido.
En el diseño de un sistema de bases de datos distribuidas debemos tener en cuenta algunas estrategias y objetivos y se deben en paralelo tomar decisiones sobre cómo hay que distribuir los datos entre los sitios de la red.
A los problemas que presentamos en el diseño de las Bases de Datos Centralizadas (BDC) se le añaden otros nuevos cuando diseñamos Bases de Datos Distribuidas (BDD) entre los cuales se destacan la distribución óptima de datos y de las aplicaciones en los diferentes sitios.
Cuando pensamos en el diseño de las bases de datos distribuidas debemos tener en cuenta la ubicación de los programas que accederán a las bases de datos y sobre los propios datos que constituyen la base de datos, en diferentes puntos de una red.
Sobre la ubicación de los programas supondremos que tenemos una copia de ellos en cada maquina donde se necesite acceder a la base de datos. Sin embargo el problema radica en como ubicaremos los datos en la red, existen diferentes formas de repartir los datos: En solo una maquina que almacene todos los datos y se encargue de responder a todas las consultas del resto de la red (sistema centralizado), ubicaríamos la base de dato en cada maquina donde se utilice, o pensaríamos en repartir las relaciones por toda la red.
La organización de los sistemas de bases de datos distribuidos se ha clasificado tradicionalmente sobre el nivel de compartición, características de acceso y nivel de conocimiento de los datos:
1. Inexistencia.
Los datos y programas se ejecutan en un ordenador sin que exista comunicación entre ellos.
2. Se comparten datos y no programas.
Existe una réplica de los programas de aplicación en cada máquina y los datos viajan a través de la red.
3. Se comparten datos y programas.
Los datos y programas se reparten por los diferentes sitios de la red, dado un programa ubicado en un determinado sitio puede acceder a un servicio a otro programa de segundo sitio solicitando acceder a los datos ubicados en un tercero.
Esta arquitectura consiste básicamente en un cliente que realiza peticiones a otro programa (el servidor) que le da respuesta. En esta arquitectura la capacidad de proceso está repartida entre los clientes y los servidores, aunque son más importantes las ventajas de tipo organizativo debidas a la centralización de la gestión de la información y la separación de responsabilidades, lo que facilita y clarifica el diseño del sistema.
Es el que inicia un requerimiento de servicio. El requerimiento inicial puede convertirse en múltiples requerimientos de trabajo a través de redes LAN o WAN. La ubicación de los datos o de las aplicaciones es totalmente transparente para el cliente.
El remitente de una solicitud es conocido como cliente. Sus características son:
Es quien inicia solicitudes o peticiones, tienen por tanto un papel activo en la comunicación (dispositivo maestro o amo).
Espera y recibe las respuestas del servidor.
Por lo general, puede conectarse a varios servidores a la vez.
Normalmente interactúa directamente con los usuarios finales mediante una interfaz gráfica de usuario.
Al contratar un servicio de redes , se tiene que tener en la velocidad de conexión que le otorga al cliente y el tipo de cable que utiliza , por ejemplo : cable de cobre ronda entre 1 ms y 50 ms.
Es cualquier recurso de cómputo dedicado a
responder a los requerimientos del cliente. Los
servidores pueden estar conectados a los
clientes a través de redes LANs o WANs, para
proveer de múltiples servicios a los clientes y
ciudadanos tales como impresión, acceso a
bases de datos, fax, procesamiento de
imágenes, etc.
Al receptor de la solicitud enviada por cliente se
conoce como servidor. Sus características
son:
Al iniciarse esperan a que lleguen las
solicitudes de los clientes, desempeñan
entonces un papel pasivo en la comunicación
(dispositivo esclavo).
Tras la recepción de una solicitud, la procesan
y luego envían la respuesta al cliente.
Por lo general, aceptan conexiones desde un
gran número de clientes (en ciertos casos el
número máximo de peticiones puede estar
limitado).
No es frecuente que interactúen directamente
con los usuarios finales.
FICHA DE ANÁLISIS DE LECTURA
NOMBRE DEL ALUMNO: Víctor Hugo Ibarra Ortiz. ________________
UNIDEP 29 de enero de 2013
LECTURA Base de Datos distribuida y
Arquitectura cliente servidor.
PÁGINAS: AUTOR: Abraham Silberschatz, Henry F. Korth.
TEMA DE LA LECTURA
Cada sitio puede participar en la ejecución de transacciones que tienen acceso a los datos de uno o varios de los sitios. La diferencia principal entre los sistemas de bases de datos centralizados y los distribuidos es que, en los primeros, los datos residen en una única ubicación, mientras que en los segundos los datos residen en varias ubicaciones. La distribución de los datos es causa de muchas dificultades en el procesamiento de las transacciones y de las consultas. Los sistemas de bases de datos que se ejecutan en cada sitio tengan un grado sustancial de independencia mutua. Las bases de datos distribuidas pueden ser homogéneas, en las que todos los sitios tienen un esquema y un código de sistemas de bases de datos comunes, o heterogéneas, en las que los esquemas y los códigos de los sistemas pueden ser diferentes. La red cliente-servidor es aquella red de comunicaciones en la que todos los clientes están conectados a un servidor, en el que se centralizan los diversos recursos y aplicaciones con que se cuenta; y que los pone a disposición de los clientes cada vez que estos son solicitados. Esto significa que todas las gestiones que se realizan se concentran en el servidor, de manera que en él se disponen los requerimientos provenientes de los clientes que tienen prioridad, los archivos que son de uso público y los que son de uso restringido, los archivos que son de sólo lectura y los que, por el contrario, pueden ser modificados, etc. Este tipo de red puede utilizarse conjuntamente en caso de que se esté utilizando en una red mixta.
Base de Datos distribuida y
Arquitectura cliente servidor.
IDEA (S) CENTRAL (ES)
Los sistemas distribuidos de bases de datos
consisten en un conjunto de sitios, cada uno de los
cuales mantiene un sistema local de bases de datos.
Cada sitio puede procesar las transacciones locales:
las transacciones que sólo tienen acceso a datos de
ese sitio.
Cada sitio puede participar en la ejecución de
transacciones globales, las transacciones que
tienen acceso a los datos de varios sitios. La
ejecución de las transacciones globales necesita
que haya comunicación entre los sitios.
OBJETIVO DE LA LECTURA CON RESPECTO A NOSOTROS O DEL CURSO
SINTESIS:
MATERIAL DE APOYO.
• PROGRAMACION PL/SQLMODULO I.
• PROGRAMACION PL/SQLMODULO II.
• PROGRAMACION PL/SQLMODULO III.
M.C. JOSÉ BENITO FRANCO URREA
1. Programación PL/SQL, declaración de variables.
Objetivos: • Reconocer las bases del bloque PL/SQL y sus secciones. • Describir el significado de las variables en PL/SQL • Distinguir entre variables PL/SQL y no PL/SQL. • Declarar variables PL/SQL • Ejecutar un bloque PL/SQL PL/SQL proviene de Procedural Language (lenguaje procedural)/ Structured Query Language (Lenguaje de consulta estructurado). PL/SQL ofrece un conjunto de comandos procedurales (sentencias IF, bucles, asignaciones), organizado dentro de bloques (como se explica más adelante), que complementan y amplían el alcance de SQL. • SQL*PLUS: es una herramienta de programación y consulta que permite a los usuarios la manipulación directa de la información de la base de datos usando el lenguaje SQL.
Privilegios de Sistema y de Objetos
En Oracle existen dos tipos de privilegios de usuario.
4.1 System: Que permite al usuario hacer ciertas tareas sobre la BD, como por ejemplo crear un Tablespace. Estos permisos son otorgados por el administrador o por alguien que haya recibido el permiso para administrar ese tipo de privilegio.
En general los permisos de sistema, permiten ejecutar comandos del tipo DDL (Data definition Language), como CREATE, ALTER y DROP.
Entre todos los privilegios de sistema que existen, hay dos que son los importantes: SYSDBA y SYSOPER. Estos son dados a otros usuarios que serán administradores de base de datos.
M.C. JOSÉ BENITO FRANCO URREA
Para otorgar varios permisos a la vez, se hace de la siguiente manera:
SQL> GRANT CREATE USER, ALTER USER, DROP USER TO bfranco;
4.2 Object: Este tipo de permiso le permite al usuario realizar ciertas acciones en objetos de la BD, como una Tabla, Vista, un Procedure o Función, etc. Si a un usuario no se le dan estos permisos sólo puede acceder a sus propios objetos (véase USER_OBJECTS). Este tipo de permisos los da el owner o dueño del objeto, el administrador o alguien que haya recibido este permiso explícitamente (con Grant Option).
Create Tablespace
Sirve para crear un tablespace.
Un tablespace es una unidad lógica de almacenamiento dentro de una base de datos oracle.
Es un puente entre el sistema de ficheros del sistema operativo y la base de datos.
Cada tablespace se compone de, al menos, un datafile y un datafile solo puede pertenecer a un tablespace.
Cada tabla o indice de oracle pertenece a un tablespace, es decir cuando se crea una tabla o indice se crea en un tablespace determinado.
Sintaxis:
CREATE [UNDO] TABLESPACE tablespace_name
DATAFILE Datafile_Options Storage_Options ;
Datafile_Options:
'filespec' [AUTOEXTEND OFF]
'filespec' [AUTOEXTEND ON [NEXT int K | M] [MAXSIZE int K | M]]
La opción Autoextend Maxsize es por defecto UNLIMITED si no se especifica valor.
Storage_Options:
DEFAULT [COMPRESS|NOCOMPRESS] STORAGE storage_clause MINIMUM EXTENT int {K|M}
M.C. JOSÉ BENITO FRANCO URREA
BLOCKSIZE int K LOGGING | NOLOGGING FORCE LOGGING ONLINE | OFFLINE PERMANENT | TEMPORARY EXTENT MANAGEMENT {DICTIONARY | LOCAL {AUTOALLOCATE | UNIFORM [SIZE int K | M]} } SEGMENT SPACE MANAGEMENT {MANUAL | AUTO}
Explicación de la sintaxis utilizada para los comandos: Las palabras en mayúsculas son comandos de oracle. Las palabras en minúsculas son opiones modificables Las partes enmarcadas con [] son opcionales Las partes enmarcadas con {} son alternativas (una u otra). El simbolo | indica OR Ejercicio práctico: Objetivo: con la finalidad de ir construyendo el proyecto final y el laboratorio para realizar las practicas, crearemos un Tablespace:
1. Crear en el C: una carpeta con nombre: C:\bd 2. Entrar al RUN SQL LINE 3. Conectarse a la base de datos system:
SQL> connect system Password: (en blanco, dar enter) si conoce la contraseña digítela.
4.
Nuestra instrucción CREATE TABLESPACE creará
el tablespace ts_corporativo con el datafile ts_corp.dbf de 64MB y
dejaremos que Oracle se encargue de gestionar automáticamente los extents de los objetos que se creer en el tablespace.
5. Mediante esta sentencia asignamos un usuario a un tablespace, este será
su tablespace por defecto cuando creamos un usuario. SQL>CREATE USER jfranco IDENTIFIED BY admin DEFAULT TABLESPACE Users;
M.C. JOSÉ BENITO FRANCO URREA
6. Mediante esta sentencia, en caso de tener creado ya el usuario le asignamos un tablespace.
SQL > ALTER USER jfranco DEFAULT TABLESPACE ts_corporativo;
7. Otorgar el privilegio “CREATE SESSION” al usuario jfranco SQL > GRANT CREATE SESSION TO jfranco;
8. Asignar un role predefinido al usuario.
SQL > GRANT DBA TO jfranco;
CONNECT CREATE SESSION, CREATE TABLE, CREATE
VIEW, CREATE SYNONYM, CREATE SEQUENCE,
CREATE DATABASE LINK, CREATE CLUSTER,
ALTER SESSION
RESOURCE CREATE TABLE, CREATE PROCEDURE,
CREATE SEQUENCE, CREATE TRIGGER,
CREATE TYPE, CREATE CLUSTER, CREATE
INDEXTYPE, CREATE OPERATOR
SCHEDULER_
ADMIN
CREATE ANY JOB, CREATE JOB, EXECUTE
ANY CLASS, EXECUTE ANY PROGRAM,
MANAGE SCHEDULER
DBA Tiene la mayoría de los privilegios, no asignar a los que no son
administradores.
SELECT_CATALOG_ROLE No tiene privilegios de sistema, pero tiene cerca de 1600 privilegios de
objeto.
9. Ejecutar la herramienta SQL Developer
Oracle SQL Developer es una herramienta gráfica gratis que mejora la
productividad y simplifica las tareas de desarrollo para base de datos Oracle.
Usando Oracle SQL Developer, podrás navegar, editar y crear objetos de base de
datos Oracle, ejecutar sentencias SQL, editar y depurar PL SQL, construcción de
PL SQL de pruebas unitarias, ejecutar informes y colocar archivos bajo control de
versiones.
M.C. JOSÉ BENITO FRANCO URREA
NOTA: debemos tener instalada la versión de Java SDK JDK 1.6.11 o
superior.
CONECTARNOS CON LA BASE DE DATOS TS_CORP.DBF
Seleccionar del Menu Archivo - Nuevo
M.C. JOSÉ BENITO FRANCO URREA
Nos presenta la siguiente pantalla:
Seleccionamos Conexión a Base de Datos y seleccionamos el botón
Aceptar.
Nos muestra la siguiente pantalla:
M.C. JOSÉ BENITO FRANCO URREA
Vamos a llenar los campos con la siguiente información:
Presionamos el Botón Probar
Si el resultado fue Estado: Correcto la conexión será exitosa.
Si es correcto el estado, presionar el Botón Conectar
M.C. JOSÉ BENITO FRANCO URREA
Se presentará la conexión al lado izquierdo de la Base de datos.
La siguiente actividad es importar datos de un archivo en Excel de nombre
BDAlumnos.xls
Seleccionar Tablas, presionar el botón derecho del mouse y seleccionar
Importar Datos
M.C. JOSÉ BENITO FRANCO URREA
Seleccionar y abrir de la carpeta Archivos Excel el archivo
BDALUMNOS.XLSX
Aparece un asistente de importación de Datos, Paso 1 de 5.
M.C. JOSÉ BENITO FRANCO URREA
Paso 2 de 5: Nombre de la tabla será ALUMNOS
Paso 3 de 5:
M.C. JOSÉ BENITO FRANCO URREA
Paso 4 de 5
Paso 5 de 5:
M.C. JOSÉ BENITO FRANCO URREA
Si seleccionamos la tabla se vería los siguientes datos:
Crear una nueva tabla de nombre CARRERAS
Campos de la Tabla
CVE_CARRERA DESCRIPCION
GTI GESTION DE LAS TECNOLOGIAS DE LA INFORMACION
LAT LICENCIADO EN ADMINISTRACION Y TURISMO
LA LICENCIADO EN ADMINISTRACION
M.C. JOSÉ BENITO FRANCO URREA
Seleccionar Tablas y presionar el botón derecho del mouse, del menú
seleccione Nueva Tabla.
Se puede agregar campos con esta pantalla básica.
M.C. JOSÉ BENITO FRANCO URREA
También se puede utilizar en modo Avanzado:
M.C. JOSÉ BENITO FRANCO URREA
1.1. Estructura de un bloque PL/SQL. Construyendo bloques de programas PL/SQL PL/SQL es un lenguaje de bloques estructurados. Un bloque PL/SQL está definido por las palabras clave DECLARE, BEGIN, EXCEPTION, y END, las que separan el bloque en tres secciones:
1. Declarativa (DECLARE): sentencias que declaran las variables, constantes y otros elementos de código, los que pueden ser utilizados dentro de ese bloque.
2. Ejecutables (BEGIN): las sentencias que se ejecutan cuando el bloque se corre.
M.C. JOSÉ BENITO FRANCO URREA
3. El manejo de excepciones (EXCEPTION): una sección especialmente estructurada que puede utilizar para "capturar" o atrapar, cualquier excepción que se produce cuando se corre la sección ejecutable.
ExcepciónVariables para control de errores. BEGIN Código. [EXCEPTION] Control y tratamiento de errores. Es el punto al que se transfiere el control del programa siempre que exista un problema. Los indicadores de excepción pueden ser definidos por el usuario o por el sistema, como es por ejemplo la excepción ZERO_DIVIDE. Las excepciones se activan automáticamente al ocurrir un error, existiendo la definición de la excepción OTHERS que considera aquellos errores no definidos y que siempre se ubica al final de todas las excepciones. END [nombre del bloque]; Fin del Bloque. Sólo la sección ejecutable es requerida. Usted puede no declarar nada en un bloque, y no tiene que capturar las excepciones producidas en ese bloque. Un bloque en sí mismo es una instrucción ejecutable, por lo que los bloques se pueden anidar dentro de otros bloques.
1.2. Tipos de Bloques.
:
1. Anónimos. Vamos a comenzar por el tipo de bloque más sencillo que existe, éste tipo de bloque no contiene sección de encabezado por lo tanto no tiene un nombre asignado, por eso se llama bloque anónimo. Este tipo de bloque no puede ser llamado por otro código debido a que no tiene un handler ó manejador por el cual se identifique al programa, básicamente los bloques
M.C. JOSÉ BENITO FRANCO URREA
anónimos sirven de contenedores para ejecutar pequeños scripts o hacer llamadas a otros bloques PL/SQL como procedures o funciones.
Nota: Al quedar los bloques anónimos almacenados en el buffer, a no ser que se guardasen en ficheros, se perderían al limpiar el buffer, cosa que no ocurre con los procedimientos y funciones, que se almacenan en la propia base de datos.
2. Procedimientos o funciones. Una vez que tenemos escrito un bloque de código, podemos guardarlo en un fichero .sql para su posterior uso, o bien guardarlo en base de datos para que pueda ser ejecutado por cualquier aplicación. El segundo caso se realiza mediante procedimientos almacenados (Stored Procedure).
A la hora de guardar un bloque de código hay que tener en cuenta ciertas normas:
La palabra reservada DECLARE desaparece. Podremos crear procedimientos y funciones. Los procedimientos no podrán
retornar ningún valor sobre su nombre, mientras que las funciones deben retornar un valor de un tipo de dato básico.
Procedimientos:
Un procedimiento [almacenado] es un subprograma que ejecuta una acción específica y que no devuelve ningún valor por sí mismo, como sucede con las funciones. Un procedimiento tiene un nombre, un conjunto de parámetros (opcional) y un bloque de código. Para crear un procedimiento (stored procedure: procedimiento almacenado) usaremos la siguiente sintaxis:
M.C. JOSÉ BENITO FRANCO URREA
Cuando se crea un procedimiento, éste se compila en primer lugar y queda almacenado en la base de datos de forma compilada. El código compilado puede ser posteriormente utilizado por cualquier bloque PL/SQL. Para modificar un procedimiento creado debemos reemplazarlo por el nuevo volviendo a compilarlo añadiendo las palabras clave OR REPLACE. Podemos eliminar un procedimiento mediante la orden DROP PROCEDURE <nombre>
Función: Las funciones son iguales que los procedimientos pero además devuelven un valor, por lo que la llamada a una función debe realizarse dentro de una expresión. La orden RETURN dentro de una función devuelve el valor que la función debe devolver, el cual se convierte al tipo especificado en la cabecera de la función. Puede haber más de una instrucción RETURN, pero solo se ejecutará la primera que se encuentre dentro de la lógica del programa.
Para crear una función usaremos la siguiente sintaxis:
Restricciones en Funciones
No se permiten comandos INSERT, UPDATE o DELETE.
La función no puede llamar a otro subprograma que rompa una de las restricciones arriba indicadas.
M.C. JOSÉ BENITO FRANCO URREA
1.3. Uso de variables.
Las variables se pueden emplear para:
Almacenamiento temporal de datos.
Manipulación de valores almacenados.
Reusabilidad.
Fácil Mantenimiento.
1.4. Manejo de variables PL/SQL.
PL/SQL permite declarar constantes y variables para ser utilizadas en cualquier expresión
dentro de un programa. La única condición exigida por PL/SQL es que cada variable (o
constante) debe estar declarada antes de ser utilizada en una expresión.
Reglas para nombres de variables: Dos variables pueden tener el mismo nombre, si están en bloques
diferentes.
El nombre de la variable (identificador) no debería ser el mismo que el de una columna de una tabla utilizada en el bloque.
Por defecto, todas las variables se inicializan a NULL.
1.5. Tipos de Variables.
ESCALARES
BOOLEANAS
COMPUESTAS
LOB
DE ENLACE (BIND)
Variables Escalares
VARCHAR2 (longitud_máxima)
NUMBER [(precisión, escala)]
DATE
CHAR [(longitud_máxima)]
M.C. JOSÉ BENITO FRANCO URREA
LONG
LONG RAW
BOOLEAN
BINARY_INTEGER
Variables BOOLEANAS
A una variable Boolean sólo se le pueden asignar los valores: TRUE, FALSE o NULL.
Estas variables están conectadas por los operadores lógicos AND, OR y NOT
Variables del Tipo de Datos Compuestos
Tipos:
o REGISTROS PL/SQL
o TABLAS PL/SQL
Contienen componentes internos
PL/SQL Creación de un Registro
Sintaxis:
Donde declaración_campo significa:
PL/SQL
Ejemplo de Registro PL/SQL
Declarar un registro para almacenar el número de empleado, nombre, trabajo y sueldo de un nuevo empleado:
Los componentes individuales del registro se referenciarán de forma cualificada; en este ejemplo:
M.C. JOSÉ BENITO FRANCO URREA
Variables LOB Permiten almacenar bloques de datos no estructurados, como pantallas de texto,
imágenes gráficas, vídeo clips, y sonido, de hasta 4 Gb. de tamaño.
CLOB Character Large Object. Se utiliza para almacenar bloques grandes de datos de caracteres.
BLOB Binary Large Object. Se utiliza para almacenar objetos binarios grandes en la B.D.
BFILE Binary File. Se utiliza para almacenar objetos binarios grandes en archivos del sistema operativo, fuera de la B.D.
NCLOB National Language Character Large Object. Se utiliza para almacenar en la B.D. bloques grandes de datos NCHAR de un byte único o multi-bytes de ancho fijo.
Variables de Enlace (Bind)
Son variables de SQL*Plus. Las pueden referenciar bloques de PL/SQL mediante el uso del ampersand (&). Ejemplo:
Atributo %TYPE
Permite declarar una variable basada en:
o Otras variables previamente declaradas
o La definición de una columna de la base de datos
Preceder de %TYPE por:
o La tabla y la columna de la base de datos
o El nombre de la variable definida con anterioridad
Ejemplo: v_ename emp.ename%TYPE;
M.C. JOSÉ BENITO FRANCO URREA
TIPOS DE DATOS ALFANUMÉRICOS
Tipo de dato CHAR(n): Almacena cadenas de caracteres de longitud fija. Su rango está entre 1 y 2.000 bytes de ocupación.
Tipo de dato VARCHAR2(n): Almacena cadenas de caracteres de longitud variable.
Tipo de dato VARCHAR(n): En Oracle8 es equivalente a VARCHAR2.
Tipo de dato NCHAR(n): Almacena un valor alfanumérico de longitud fija. Puede almacenar caracteres ASCII, EBCDIC, UNICODE.
Tipo de dato NVARCHAR2(n): Almacena un valor alfanumérico de longitud variable. Puede almacenar caracteres ASCII, EBCDIC,UNICODE
TIPOS DE DATOS NUMÉRICOS
Tipo de dato NUMBER(p, s): Almacena valores numéricos en punto flotante que pueden estar entre 1.0 x 10-130 y 9.9…(38 nueves)… 9 x 10125.
Tipo de dato FLOAT(N): Almacena un número en punto decimal sin restricción de dígitos decimales, donde n indica la precisión binaria máxima que puede moverse en el rango 1 a 126.
TIPOS DE DATOS FECHA
Tipo de dato DATE: Almacena un valor de fecha y hora. Para un tipo de dato DATE, Oracle almacena internamente los siguientes datos:
Siglo
Año
Mes
Día
Hora
Minuto
Segundo
M.C. JOSÉ BENITO FRANCO URREA
El formato por defecto de las fechas es: 'DD-MON-YYYY'
TIPO DE DATOS BINARIOS
Tipos de datos binarios: Permiten almacenar información en formato "crudo", valores binarios tal y como se almacenan en el disco duro o como residen en memoria.
Tipo de dato LONG: Almacena caracteres de longitud variable hasta 2 Gb. En Oracle8 y siguientes versiones se deben usar los tipos de datos CLOB y NLOB para almacenar grandes cantidades de datos alfanuméricos.
OTROS TIPOS DE DATOS
Tipo de dato ROWID: Representa una dirección de la base de datos, ocupada por una única fila. Este tipo de dato sirve para guardar punteros a filas concretas.
1.6. Declaración de Variables La sintaxis para declarar variables es la siguiente:
donde: tipo_dato: es el tipo de dato que va a poder almacenar la variable, este
puede ser cualquiera de los tipos soportandos por ORACLE, es decir NUMBER , DATE , CHAR , VARCHAR, VARCHAR2, BOOLEAN ... Además para algunos tipos de datos (NUMBER y VARCHAR) podemos especificar la longitud.
La cláusula CONSTANT indica la definición de una constante cuyo valor no puede ser modificado. Se debe incluir la inicialización de la constante en su declaración.
La cláusula NOT NULL impide que a una variable se le asigne el valor nulo, y por tanto debe inicializarse a un valor diferente de NULL.
Las variables que no son inicializadas toman el valor inicial NULL. La inicialización puede incluir cualquier expresión legal de PL/SQL, que
lógicamente debe corresponder con el tipo del identificador definido. Los tipos escalares incluyen los definidos en SQL más los tipos VARCHAR
y BOOLEAN. Este último puede tomar los valores TRUE, FALSE y NULL, y
M.C. JOSÉ BENITO FRANCO URREA
se suele utilizar para almacenar el resultado de alguna operación lógica. VARCHAR es un sinónimo de CHAR.
También es posible definir el tipo de una variable o constante, dependiendo del tipo de otro identificador, mediante la utilización de las cláusulas %TYPE y %ROWTYPE. Mediante la primera opción se define una variable o constante escalar, y con la segunda se define una variable fila, donde identificador puede ser otra variable fila o una tabla. Habitualmente se utiliza %TYPEpara definir la variable del mismo tipo que tenga definido un campo en una tabla de la base de datos, mientras que%ROWTYPE se utiliza para declarar varibales utilizando cursores.
1.7. Asignación. Inicialización de Variables y palabras claves.
Set de Caracteres y Unidades Léxicas
Las instrucciones del lenguaje deben ser escritas utilizando un grupo de
caracteres válidos. PL/SQL no es sensible a mayúsculas o minúsculas. El grupo
de caracteres incluye los siguientes:
M.C. JOSÉ BENITO FRANCO URREA
Letras mayúsculas y minúsculas de la A a la Z
Números del 0 al 9
Los símbolos ( ) + - * / < > = ! ~ ^ ; . ‘ @ % , “ # $ & _ | { } ? [ ]
Tabuladores, espacios y saltos de carro
Por ejemplo en la instrucción:
bono := salario * 0.10; -- cálculo del bono
Se observan las siguientes unidades léxicas:
Los identificadores bono y salario
El símbolo compuesto :=
Los símbolos simples * ;
El literal numérico 0.10
El comentario “cálculo del bono”
Delimitadores e Identificadores
Un delimitador es un símbolo simple o compuesto que tiene un significado
especial dentro de PL/SQL. Por ejemplo, es posible utilizar delimitadores para
representar operaciones aritméticas, por ejemplo:
Símbolo Significado
+ operador de suma
% indicador de atributo
‘ delimitador de caracteres
. selector de componente
/ operador de división
M.C. JOSÉ BENITO FRANCO URREA
( expresión o delimitador de lista
) expresión o delimitador de lista
: indicador de variable host
, separador de ítems
* operador de multiplicación
“ delimitador de un identificador entre comillas
= operador relacional
< operador relacional
> operador relacional
@ indicador de acceso remoto
; terminador de sentencias
- negación u operador de substracción
Los delimitadores compuestos consisten de dos caracteres, como por ejemplo:
Símbolo Significado
:= operador de asignación
=> operador de asociación
|| operador de concatenación
** operador de exponenciación
<< comienzo de un rótulo
M.C. JOSÉ BENITO FRANCO URREA
>> fin de un rótulo
/* comienzo de un comentario de varias líneas
*/ fin de un comentario de varias líneas
.. operador de rango
<> operador relacional
!= operador relacional
^= operador relacional
<= operador relacional
>= operador relacional
-- comentario en una línea
Los identificadores incluyen constantes, variables, excepciones, cursores,
subprogramas y paquetes.
La longitud de un identificador no puede exceder los 30 caracteres. Se recomienda
que los nombres de los identificadores utilizados sean descriptivos.
Algunos identificadores especiales, llamados palabras reservadas, tienen un
especial significado sintáctico en PL/SQL y no pueden ser redefinidos. Son
palabras reservadas, por ejemplo, BEGIN, END, ROLLBACK, etc.
Es posible asignar valores a las variables de dos formas:
La primera utiliza el operador “:=”. La variable se ubica al lado izquierdo y la
expresión al lado derecho del símbolo.
Por ejemplo:
M.C. JOSÉ BENITO FRANCO URREA
impuesto:= precio * iva;
bono := Salario_actual * 0.10 ;
Monto:= TO_NUMBER(SUBSTR(‘750 dólares’, 1, 3)) ;
Valido:= False ;
La segunda forma de asignar valores a variables es obtener valores
directamente desde la base de datos, como en:
SELECT salario * 0.10 INTO bonus FROM emp WHERE empno = emp_id ;
Declaración de Constantes
En la declaración de una constante (muy similar a la de una variable), se debe
incorporar la palabra reservada “constant” e inmediatamente asignar el valor
deseado. En adelante, no se permitirán reasignaciones de valores para aquella
constante que ya ha sido definida.
Ejemplo: credit_limit CONSTANT real := 5000.00 ;
1.8. Referenciando variables que no son de PL/SQL.
Almacenar el salario anual en una variable global de SQL*Plus. :g_monthly_sal := v_sal / 12;
M.C. JOSÉ BENITO FRANCO URREA
• Referenciar variables no-PL/SQL como variables Host.
• Preceder las referencias con dos puntos (:)
1.9. Ejercicios Prácticos. IMPORTAR LOS DATOS DEL ARHIVO DE TRABAJO DE EXCEL BDCORPORATIVO.XLSX HOJAS: EMPLEADOS-DEPARTAMENTOS EJEMPLO DE BLOQUE ANÓNIMO: Declaración de Variables y constantes con valor inicial: SQL> SET SERVEROUTPUT ON;
Calcular un bono de 0.10 % del sueldo para el empleado número: 5232 de la Tabla EMPLEADOS
M.C. JOSÉ BENITO FRANCO URREA
Ejemplo de operaciones.
Ejemplo usando variables de sustitución
M.C. JOSÉ BENITO FRANCO URREA
2. Escribiendo comandos ejecutables
Objetivo: Reconocer el significado de la sección ejecutable
Escribir sentencias en la sección ejecutable
Describir las reglas de bloques anidados
Ejecutar y comprobar un bloque PL/SQL
2.1. Línea maestra para escribir un bloque PL/SQL
Oracle permite acceder y manipular información de la base de datos definiendo objetos procedurales (subprogramas) que se almacenan en la base de datos. Estos objetos procedurales son unidades de programa PL/SQL: Funciones y Procedimientos almacenados
1. Declarativa (DECLARE): sentencias que declaran las variables, constantes y otros elementos de código, los que pueden ser utilizados dentro de ese bloque.
2. Ejecutables (BEGIN): las sentencias que se ejecutan cuando el bloque se corre. 3. El manejo de excepciones (EXCEPTION): una sección especialmente
estructurada que puede utilizar para "capturar" o atrapar, cualquier excepción que se produce cuando se corre la sección ejecutable.
M.C. JOSÉ BENITO FRANCO URREA
ExcepciónVariables para control de errores. BEGIN Código. [EXCEPTION] Control y tratamiento de errores. Es el punto al que se transfiere el control del programa siempre que exista un problema. Los indicadores de excepción pueden ser definidos por el usuario o por el sistema, como es por ejemplo la excepción ZERO_DIVIDE. Las excepciones se activan automáticamente al ocurrir un error, existiendo la definición de la excepción OTHERS que considera aquellos errores no definidos y que siempre se ubica al final de todas las excepciones. END [nombre del bloque]; Fin del Bloque.
PROCEDIMIENTOS: Un procedimiento es un subprograma que ejecuta una acción específica y que no devuelve ningún valor. Un procedimiento tiene un nombre, un conjunto de parámetros (opcional) y un bloque de código. CREATE [OR REPLACE PROCEDURE [esquema].nombre-procedimiento (nombre-parámetro {IN | OUT | IN OUT} tipo de dato, ..) {IS | AS} Declaración de variables; Declaración de constantes; Declaración de cursores; BEGIN Cuerpo del subprograma PL/SQL; EXCEPTION Bloque de excepciones PL/SQL; END;
Descripción de la sintaxis: • Nombre-parámetro: es el nombre que queramos dar al parámetro. Podemos utilizar múltiples parámetros. En caso de no necesitarlos, podemos omitir los paréntesis. • IN: especifica que el parámetro es de entrada y que por tanto dicho parámetro tiene que tener un valor en el momento de llamar a la función o procedimiento. Si no se especifica nada, los parámetros son por defecto de tipo entrada.
M.C. JOSÉ BENITO FRANCO URREA
• OUT: especifica que se trata de un parámetro de salida. Son parámetros cuyo valor es devuelto después de la ejecución el procedimiento al bloque PL/SQL que lo llamó. Las funciones PLSQL no admiten parámetros de salida. • IN OUT: Son parámetros de entrada y salida a la vez. • Tipo-de-dato: Indica el tipo de dato PLSQL que corresponde al parámetro (NUMBER, VARCHAR2, etc).
El uso de OR REPLACE permite sobreescribir un procedimiento existente. Si se omite, y el procedimiento existe, se producirá, un error. La sintaxis es muy parecida a la de un bloque anónimo, salvo porque se reemplaza la sección DECLARE por la secuencia PROCEDURE . IS en la especificación del procedimiento. Debemos especificar el tipo de datos de cada parámetro. Al especificar el tipo de dato del parámetro no debemos especificar la longitud del tipo. Los parámetros pueden ser de entrada (IN), de salida (OUT) o de entrada salida (IN OUT). El valor por defecto es IN, y se toma ese valor en caso de que no especifiquemos nada. Cuando se crea un procedimiento o función, Oracle automáticamente compila el código fuente, guarda el código objeto en un área compartida de la SGA (System Global Area) y almacena tanto el código fuente como el código objeto en catálogos del diccionario de datos. El código objeto permanece en la SGA, por tanto, los procedimientos o funciones se ejecutan más rápidamente y lo pueden compartir muchos usuarios. SET SERVEROUTPUT ON
M.C. JOSÉ BENITO FRANCO URREA
EJERCICIO PRÁCTICO: Crear un procedimiento que permita consultar el sueldo de los empleados pasando como parámetro su número de empleado, si no existe el empleado mandará un mensaje de excepción que indique que el empelado no fue encontrado. SET SERVEROUTPUT ON
Ejecutamos el procedimiento:
Ejecutar el procedimiento con el número de empleado 8888 para ejecutar la EXCEPTION
M.C. JOSÉ BENITO FRANCO URREA
2.2. Comentarios. • Monolínea.- Comienzan con dos guiones y continua hasta el final de la línea. -- Esto es un comentario • Multilínea.- Comienzan con el delimitador /* y terminan con el delimitador */. /* Esto es otro comentario, que puede abarcar varias líneas */
1.1. Funciones SQL en PL/SQL: Conversión de tipos, Mezclando
Función: Las funciones son iguales que los procedimientos pero además devuelven un valor, por lo que la llamada a una función debe realizarse dentro de una expresión. La orden RETURN dentro de una función devuelve el valor que la función debe devolver, el cual se convierte al tipo especificado en la cabecera de la función. Puede haber más de una instrucción RETURN, pero solo se ejecutará la primera que se encuentre dentro de la lógica del programa.
Para crear una función usaremos la siguiente sintaxis:
M.C. JOSÉ BENITO FRANCO URREA
Restricciones en Funciones
No se permiten comandos INSERT, UPDATE o DELETE.
La función no puede llamar a otro subprograma que rompa una de las restricciones arriba indicadas.
Ejercicio PRÁCTICO:
MOD
Devuelve el resto de la división entera entre dos números.
MOD(<dividendo>, <divisor> )
SELECT MOD(20,15) -- Devuelve el modulo de dividir 20/15
FROM DUAL
PARA CONSULTAR LAS FUNCIONES INTEGRADAS EN PL/SQL VISITE TE LINK. http://www.devjoker.com/contenidos/catss/67/Funciones-integradas-de-PLSQL.aspx
M.C. JOSÉ BENITO FRANCO URREA
1.2. bloques anidados y ámbito de variables, Operadores en PL/SQL.
Bloques Anidados y Ámbito de la Variable:
Operadores en PL/SQL
La siguiente tabla ilustra los operadores de PL/SQL.
Tipo de operador Operadores
Operador de asignación
:= (dos puntos + igual)
Operadores aritméticos
+ (suma) - (resta) * (multiplicación) / (división)
M.C. JOSÉ BENITO FRANCO URREA
** (exponente)
Operadores relacionales o de comparación
= (igual a) <> (distinto de) < (menor que) > (mayor que) >= (mayor o igual a) <= (menor o igual a)
Operadores lógicos
AND (y lógico) NOT (negacion) OR (o lógico)
Operador de concatenación
||
1.3. Ejercicios Prácticos.
Crear un procedimiento que sume dos números:
Crear una función pl/sql que duplica la cantidad recibida como parámetro:
EJECUTAMOS LA FUNCIÓN
M.C. JOSÉ BENITO FRANCO URREA
M.C. JOSÉ BENITO FRANCO URREA
3. Interactuando con Oracle server
3.1. Comando SQL en PL/SQL.
El SQL es un lenguaje unificado, lo utilizan todo tipo de usuarios, desde el administrador de la base de datos, hasta el usuario final, permite la realización de cualquier consulta de datos.
Las sentencias de SQL se clasifican como parte del DDL o del DML.
DDL(Data Definition Language) Lenguaje de Definición de Datos: Son las sentencias SQL que permiten definir los objetos de la Base de Datos. ALTER DATABASE, CREATE TABLE, DROP SEQUENCE, GRANT.
DML(Data Manipulation Language) Lenguaje de manipulación de datos: Son las sentencias SQL que permiten manejar la base de datos. DELETE, INSERT, SELECT, UPDATE.
Siempre que se realiza alguna operación en la base de datos, no se realiza directamente sobre la tabla sino sobre una copia local de esta. De tal manera que si queremos que los resultados de estas operaciones se trasladen a la base de datos, hay que confirmar dicha operación con el comando commit. Si no queremos que estos resultados modifiquen la base de datos (Deshacer) se utiliza el comando rollback, aunque hay que hacer la claridad que algunas sentencias SQL no pueden volverse atrás.
RESTRICCIONES
Las restricciones se utilizan para garantizar que los datos cumplan unas condiciones específicas. SQL maneja las siguientes.
NOT NULL Obliga a que la columna tenga un valor no nulo. Los valores nulos son diferentes de 0 y el espacio en blanco.
UNIQUE Evita valores repetidos en una columna, admitiendo valores nulos.
CHECK Verifica que se cumpla una condición especifica DEFAULT Estable un valor por defecto para esta columna, si no
se le asigna ninguno.
M.C. JOSÉ BENITO FRANCO URREA
PRIMARY KEY Establece columna o conjunto de columnas que hacen parte de la clave primaria. Solo puede existir una clave primaria por tabla. Puede ser referenciada como clave foránea por otras tablas.
FOREIGN KEY Establece que el contenido de esta columna será uno de los valores contenidos en una columna de otra tabla o de la misma. Se puede obligar que cuando una fila de la tabla maestra sea borrada, todas las filas de la tabla detalle cuya clave foránea coincida con la clave borrada se borren también.
3.2. Recuperación de datos en PL/SQL.
El comando SELECT básicamente te permite obtener o seleccionar las filas de una o varias tablas que están almacenadas en tu Base de Datos Oracle. Puedes consultar los datos directamente desde la línea de comandos o a través de los PL-SQL Procedures en Oraclepara poder procesar los registros obtenidos. Para obtener los datos que deseas procesar en tus PL-SQL Procedures en Oracle, el comando SELECT te provee de una serie de cláusulas que te permiten seleccionar las tablas, filtrar la información, agrupar los datos, ordenar el resultado, unir consultas, etc. Revisemos como se define la sintaxis básica del comando SELECT: /* PL-SQL Procedures en Oracle */ SELECT [distinct | All] {* | expresión} [c_alias] FROM [tabla, vista] [t_alias] [WHERE condición] [GROUP BY expresión [Having condición] ] [ORDER BY {expresion | posición} [Asc | Desc]] Donde: SELECT= Permite seleccionar las columnas o expresiones que se quieren mostrar en la consulta de tus PL-SQL Procedures en Oracle. Distinct= Permite obtener solo las filas que son distintas, omitiendo las filas duplicadas. All= Permite obtener todas las filas obteniendo incluso las duplicadas, valor por defecto. * = Permite seleccionar todas las columnas de las tablas o vistas listadas en la cláusula FROM. Expresión= Corresponde al nombre de una columna de las tablas o vistas listadas en la cláusula FROM, también puede contener funciones, subconsultas u otros valores. C_alias= Permite asignar un nombre a cada columna del Select. FROM= Permite identificar las tablas o vistas de las cuales se quieren obtener los datos en tus PL-SQL Procedures en Oracle. Tabla= Corresponde al nombre de la o las tablas que se van a consultar.
M.C. JOSÉ BENITO FRANCO URREA
Vista= Corresponde al nombre de la o las vistas que se van a consultar. T_alias= Permite asignar un nombre abreviado para identificar a la tabla o vista. WHERE= Permite identificar las condiciones para filtrar los datos que se quieren obtener en tus PL-SQL Procedures en Oracle. Condición= Corresponde a las definiciones de los filtros que se deben aplicar al conjunto de tablas o vistas listadas en la cláusula FROM. GROUP BY= Permite identificar las expresiones por las cuales se desean agrupar los datos que se quieren obtener en tus PL-SQL Procedures en Oracle. Having= Permite identificar las condiciones para filtrar los datos agrupados dentro de la cláusula GROUP BY. ORDER BY= Permite identificar las expresiones por las cuales se desean ordenar los datos que se quieren obtener en tus PL-SQL Procedures en Oracle. Posición= Corresponde al número de la columna por la cual se quieren ordenar los datos. Asc= Permite ordenar los datos de forma ascendente, valor por defecto. Desc= Permite ordenar los datos de forma descendente. Ejemplo #1: El gerente necesita saber cuál es el sueldo más alto que se paga en la empresa. Veamos cómo se hace: /* PL-SQL Function en Oracle */
Select max(empleados.sueldo) sueldo_mayor From empleados; Resultado: SUELDO_MAYOR ------------ 35000
Ejemplo #2: El gerente necesita saber cuál es el sueldo más alto y a que empleado se le paga en la empresa. Veamos cómo se hace: /* PL-SQL Function en Oracle */
Select empleados.nombre, empleados.ap_paterno, empleados.sueldo, empleados.puesto from empleados where empleados.sueldo = (Select max(empleados.sueldo) from empleados); Resultado: NOMBRE AP_PATERNO SUELDO PUESTO -------- ---------- ---------- ----------------------------- ANDREA MENDOZA 35000 GERENTE
M.C. JOSÉ BENITO FRANCO URREA
Ejemplo #3: El gerente necesita saber cuál es el sueldo más bajo y a que empleado se le paga en la empresa. Veamos cómo se hace: /* PL-SQL Function en Oracle */
Select empleados.nombre, empleados.ap_paterno, empleados.sueldo, empleados.puesto from empleados where empleados.sueldo = (Select min(empleados.sueldo) from empleados); Resultados: NOMBRE AP_PATERNO SUELDO PUESTO -------- ---------- ---------- ----------------------------- INES ARMENTA 3500 RECEPCIONISTA
Ejemplo #4: El gerente necesita saber cuál es el sueldo más alto por departamento. Veamos cómo se hace: /* PL-SQL Function en Oracle */
Select n_dpto, max(sueldo) sueldo_mayor From empleados Group by n_dpto; Resultado: N_DPTO SUELDO_MAYOR ------ ------------ 1805 15000 1804 25000 1800 35000 1801 15000 1803 15000 1802 15000 Ejercicio 5: consultar los departamentos. SELECT * FROM departamentos; Resultados: N_DPTO DESCRIPCION ------ ------------------------------
M.C. JOSÉ BENITO FRANCO URREA
1800 DIRECCION 1801 RCURSOS FINANCIEROS 1802 INFORMATICA 1803 JURIDICO 1804 RECURSOS HUMANOS 1805 RECURSOS MATERIALES 6 filas seleccionadas http://dominatuspackagesenoracle.com/blog/descubre-como-utilizar-la-function-max-en-tus-packages-en-oracle.html
3.3. Insertando datos en PL/SQL. Borrando datos en PL/SQL.
Inserción de Registros El proceso de inserción de registros consiste en añadir a una tabla una o más filas y en cada fila todos o parte de sus campos.
INSERT INTO <nombre_tabla> [(<campo1>[,<campo2>,...])] values (<valor1>,<valor2>,...);
NOTA: Sólo podremos omitir un campo al efectuar una inserción cuando este acepte valores nulos. Ejemplo: Se requiere ingresar un nuevo empleado a la empresa.
INSERT INTO empleados(num_empleado, NOMBRE, AP_PATERNO, AP_MATERNO, PUESTO, SUELDO, ANTIGUEDAD, N_DPTO) VALUES ('9223','JOSE BENITO', 'FRANCO','URREA','JEFE DE OFICINA',20000,'10','1802');
Regla de restricción: el campo num_empleado debe estar declarado como llave primaria para evitar duplicar números de empleados.
3.4. Actualizando datos en PL/SQL.
La instrucción UPDATE SQL le permite actualizar registros de una tabla.
M.C. JOSÉ BENITO FRANCO URREA
Ejercicio 1: Se requiere actualizar el sueldo del nuevo empleado Número: 9223. El sueldo nuevo será de $ 30000.
UPDATE empleados SET sueldo = 30000 WHERE num_empleado = '9223';
TAREA 4: Investigar en internet como se hace una consulta con el comando SELECT de dos tablas. Las tablas a consultar son: ALUMNOS y CARRERAS. NOTA: El campo para unir las dos tablas es CVE_CARRERA y debe de considerarse en la Cláusula WHERE del SELECT EL RESULTADO DEBE DE SER EL SIGUIENTE: MATRICULA NOMBRE DESCRIPCION --------- ------ -------------------------------------------- 4201 MANUEL GESTION DE LAS TECNOLOGIAS DE LA INFORMACION 4202 PEDRO GESTION DE LAS TECNOLOGIAS DE LA INFORMACION 4203 JUAN GESTION DE LAS TECNOLOGIAS DE LA INFORMACION 4204 ARIEL GESTION DE LAS TECNOLOGIAS DE LA INFORMACION 4205 LUCIA LICENCIADO EN ADMINISTRACION Y TURISMO 4206 ALICIA LICENCIADO EN ADMINISTRACION Y TURISMO 4207 MAGDA LICENCIADO EN ADMINISTRACION Y TURISMO 4208 DANNYA LICENCIADO EN ADMINISTRACION 4209 ROCIO LICENCIADO EN ADMINISTRACION 4210 LUIS LICENCIADO EN ADMINISTRACION
3.5. COMMIT Y ROLLBACK. Transacciones Una transacción es un conjunto de operaciones que se ejecutan en una base de datos, y que son tratadas como una única unidad lógica por el SGBD. Es decir, una transacción es una o varias sentencias SQL que se ejecutan en una base de datos como una única operación, confirmandose o deshaciendose en grupo. No todas las operaciones SQL son transaccionales. Sólo son transaccionales las operaciones correspondiente al DML, es decir: sentencias SELECT, INSERT, UPDATE y DELETE Para confirmar una transacción se utiliza la sentencia COMMIT. Cuando realizamos COMMIT los cambios se escriben en la base de datos. Para deshacer una transacción se utiliza la sentencia ROLLBACK. Cuando realizamos ROLLBACK se deshacen todas las modificaciones realizadas por la transacción en la base de datos, quedando la base de datos en el mismo estado que antes de iniciarse la transacción.
M.C. JOSÉ BENITO FRANCO URREA
Un ejemplo clásico de transacción son las transferencias bancarias. Para realizar una transferencia de dinero entre dos cuentas bancarias debemos descontar el dinero de una cuenta, realizar el ingreso en la otra cuenta y grabar las operaciones y movimientos necesarios, actualizar los saldos. Si en alguno de estos puntos se produce un fallo en el sistema podríamos haber descontado el dinero de una de las cuentas y no haberlo ingresado en la otra. Por lo tanto, todas estas operaciones deben ser correctas o fallar todas. En estos casos, al confirmar la transacción (COMMIT) o al deshacerla (ROLLBACK) garantizamos que todos los datos quedan en un estado consistente.
El siguiente ejemplo muestra una supuesta transacción bancaria:
DECLARE
importe NUMBER;
ctaOrigen VARCHAR2(23);
ctaDestino VARCHAR2(23);
BEGIN
importe := 100;
ctaOrigen := '2530 10 2000 1234567890';
ctaDestino := '2532 10 2010 0987654321';
UPDATE CUENTAS SET SALDO = SALDO - importe
WHERE CUENTA = ctaOrigen;
UPDATE CUENTAS SET SALDO = SALDO + importe
WHERE CUENTA = ctaDestino;
INSERT INTO MOVIMIENTOS
(CUENTA_ORIGEN, CUENTA_DESTINO,IMPORTE,
FECHA_MOVIMIENTO)
VALUES
(ctaOrigen, ctaDestino, importe*(-1), SYSDATE);
INSERT INTO MOVIMIENTOS
(CUENTA_ORIGEN, CUENTA_DESTINO,IMPORTE,
FECHA_MOVIMIENTO)
VALUES
(ctaDestino,ctaOrigen, importe, SYSDATE);
COMMIT;
EXCEPTION
WHEN OTHERS THEN
dbms_output.put_line('Error en la
transaccion:'||SQLERRM);
dbms_output.put_line('Se deshacen las modificaciones);
ROLLBACK;
END;
NOTA: ORACLE es completamente transaccional. Siempre debemos especificar si que queremos deshacer o confirmar la transacción.
M.C. JOSÉ BENITO FRANCO URREA
3.6 Borrado de datos.
La sentencia DELETE.
Para borrar datos de una tabla, debemos utilizar la sentencia DELETE.
La sintaxis de la sentencia DELETE es la siguiente:
DELETE FROM <nombre_tabla> [ WHERE <condicion>];
El siguiente ejemplo ilustra el uso de la sentencia DELETE. Es buena idea especificar en la sentencia WHERE los campos que forman la clave primaria de la tabla para evitar borrar datos que no queramos eliminar.
Ejercicio Práctico: Borrar de la base de datos el empleado 9223.
DELETE FROM EMPLEADOS WHERE NUM_EMPLEADO = '9223';
INSTRUMENTOS DEEVALUACION.
• EXAMEN PARCIAL.• EXAMEN FINAL.• PROYECTO FINAL.
PROYECTO FINAL BASE DE DATOS III
LA EMPRESA DISTRIBUIDORA SKY S.A DE C.V. SE DEDICA A LA DUSTRIBUCIÓN DE PRODUCTOS DE
ABARROTES, ENFRENTA DIFERENTES PROBLEMAS DE CONTROL. SU PARQUE VEHICULAR SE HA
INCREMENTADO DERIVADO A LAS NUEVAS RUTAS QUE SE HAN ABIERTO. OTRO PROBLEMA QUE
ENFRENTA ES QUE SU CARTERA DE PRODUCTOS HAN AUMENTADO POR LO QUE REQUIERE UN
NUEVO MODELO DE CONTROL DE INVENTARIO Y VENTA DE PRODUCTOS. TAMBIEN REQUIERE UN
CONTROL DE PROVEEDORES YA QUE NO TODAS LAS FACTURAS LAS PAGA DE CONTADO, ALGUNAS
SON A CRÉDITO, ADEMÁS DE TENER UN CONTROL DE CUAL PROVEEDOR LE SURTE DIFERENTES
PRODUCTOS.
CONTROL VEHICULAR
CONTROL DE INVENTARIO DE PRODUCTOS
CONTROL DE PROVEEDORES
ACTIVIDADES DEL PROYECTO
1.- DEFINIR LOS DATOS QUE SERÁN CONSIDERADOS EN EL PROYECTO
2.- DEFINIR LA ESTRUCTURA DE CADA TABLA DE LA BASE DE DATOS
3.- DEFINIR LOS TIPOS DE DATOS PARA CAMPO DE LAS TABLAS DEFINIDAS
4.- DEFINIR LAS LLAVES PRIMARIAS DE CADA TABLA
5.- DEFINIR LAS LLAVES FORANEAS DE CADA TABLA.
6.- CREAR UN TABLE-SPACE DE NOMBRE SKY_CORP EN LA CARPETA C:\BD
7.- CREAR UN DATAFILE DE NOMBRE SKY.DBF EN EL TABLE-SPACE SKY_CORP
8.- UTILIZAR LA HERRAMIENTA SQL DEVELOPER PARA DISEÑAR LAS TABLAS
9.- EN ESTA MISMA HERRAMIENTA CAPTURAR DATOS.
ACCEPT elpro PROMPT 'DIGITE EL NUMERO DE PRODUCTO: 1000-5000'
DECLARE
v_npro VARCHAR2(50):= TO_CHAR('&elpro');
CURSOR cproductos(v_producto IN VARCHAR2) IS
SELECT CVE_PRODUCTO, NOM_PRODUCTO, CANT_PRODUCTO, COSTO_PRODUCTO
FROM PRODUCTOS WHERE CVE_PRODUCTO = v_npro;
v_cveproducto varchar2(4);
v_nomproducto varchar2(50);
v_cantproducto number(4,0);
v_costoproducto number(7,2);
BEGIN
OPEN cproductos(v_npro);
LOOP
FETCH cproductos INTO v_cveproducto, v_nomproducto, v_cantproducto, v_costoproducto;
EXIT WHEN cproductos%NOTFOUND;
DBMS_OUTPUT.put_line(v_cveproducto ||' '||v_nomproducto||' '||to_char(v_cantproducto)||'
'||TO_CHAR(v_costoproducto));
END LOOP;
CLOSE cproductos;
END;
Resul 5000 TOCINO DE PUERCO 500 29,25
BIBLIOGRAFIA.
REFLEXION.
EN LO PERSONAL LA MATERIA DEBASE DE DATOS III ES UNAHERRAMIENTA DE GRAN UTILIDADPARA PODER ENTENDER LO QUEVIENE SIENDO LA FORMA CORRECTADE CREAR UNA BASE DE DATOS.NO ME QUEDA MAS QUE AGRADECERLA MANERA EN QUE FUE IMPARTIDALA CLASE, YA QUE NOS MOTIVO ADAR LO MEJOR DE NOSOTROS,LOGRANDO ASÍ COMPRENDER QUEES UNA HERRAMIENTA MUY ÚTIL ENNUESTRA CARRERA….
CONCLUSION.
EL OBJETIVO PLANTEADO EN LAINTRODUCCIÓN SE CUMPLIÓ, YA QUE SEPUDO OBSERVAR A LO LARGO DELDESARROLLO LOS DIFERENTES USOS DELAS FUNCIONES EN LA CARRERA DEINGENIERÍA EN SISTEMAS , ALHABER TAMBIÉN ESTUDIADO LAMAYORÍA DE TEMAS NOS QUEDA UNMODELO QUE PODEMOS APLICARFRENTE A CIERTA PROBLEMÁTICA.CREEMOS QUE EL RESULTADO OBTENIDOTRAS ESTE PORTAFOLIO FUE POSITIVO, YAQUE SE CUMPLE LA CONSIGNA ENCUANTO A LA INFORMACIÓN TEÓRICA, YCREEMOS QUE TAMBIÉN ESTE NOS SERÁÚTIL EN LA PRACTICA.
FIN.
… GRACIAS.