Universidad de Los Andes Escuela de Ingeniería de Sistemas ... · Lenguaje de consulta de objetos...

Universidad de Los Andes

Escuela de Ingeniería de Sistemas

Departamento de Computación

Tema 3. Bases de datos orientadas por objetos

Tema 3. Bases de datos orientadas

por objetos

2020EISULA. Dpto. De Computación. Isabel Besembel C. Base de Datos. Sem. U-192

Contenido:

Modelo estándar del grupo ODMG 3.0.

Jerarquía de tipos.

Lenguajes de definición (LDO) y manipulación de objetos (LMO). Ejemplos en OQL

Objetivo:

Desarrollar habilidades en el modelado de bases de datos orientado por objetos

Actividades:

Leer: ODMG 3.0, Elmasri y Navathe, cap. 21 y Cattell y Barry, cap. 2, 3 y 4

Realizar los ejercicios de este documento

Realizar el ejercicio 3

Lenguaje de consulta de objetos (OQL)


Relacionado con el modelo de objetos de ODMG

Es un lenguaje funcional donde los operadores se

pueden componer libremente siempre que se respete

la jerarquía de tipos

Compatible con SQL-92

No es computacionalmente completo

No provee un operador de actualización, ella se realiza

a través de invocaciones a las operaciones definidas en

los objetos que tengan tal responsabilidad

Provee acceso declarativo a los objetos

Consultas: a través del nombre del objeto denotable

OQL


Sintaxis de la consulta

Jerarquía de los operadores

Tomado de Cattell & Barry, 2000

ODL


Class Persona (extent Personas keys(nombre, apellido))

{ attribute string nombre;

attribute string apellido;

attribute date fechaDeNac;

attribute string dir;

attribute string ciudad;

attribute list<string> tels;

attribute enum sexo{‘F’, ‘M’};

attribute short edad;

short calculaEdad();

};

Class Empleado extends Persona(extent Empleados key(CI))

{ attribute string CI[10];

attribute currency salario;

relationship Empleado jefe inverse Empleado::subordinados;

relationship set<Empleado> subordinados inverse Empleado::jefe;

void contratar(in Persona p, in string ci, in currency sal);

void retirar(in string ci) raises(Retirado);

};

class c13oql

Empleado

- cedula[10]: string

- salario: currency

+ contratar(Persona, string, currency): void

+ retirar(string): void

Persona

- apellido: string

- ciudad: string

- dir: string

- edad: short

- fechaDeNac: date

- nombre: string

- sexo {'F', 'M'}: enum

- tels: list<string>

+ calculaEdad(): short

-jefe 0..1 -subordinados *

«extends»

OQL


select distinct x.edad from x in Personas wherex.nombre=”Manuel”

Regresa un literal del tipo Set <short>

select distinct struct(a: x.edad, s: x.sexo)

from x in Personas

where x.nombre=”Manuel”

select dictinct struct(nombre: x.nombre, su: (select y from y in x.subordinados where y.salario > 15.000,00))

from x in Empleadosregresa un literal del tipo Set<Struct> así set<struct(nombre:String, su:Bag<Empleado>)>

OQL


select struct(a: x.edad, s: x.sexo)

from x in (select y from y in Empleados where y.salario >15.000,00)

where x.nombre=”Manuel”

no siempre hay que usar la cláusula select, por lo tantoPersonas

regresa el conjunto de todas las personas

Para crear un objeto con identidad (mutable)Persona(nombre:”Manuel”, apellido: “Fuente”, fechaDeNac:”12/4/62”, Sexo:”M”, dir:”Av.5 Nro.21-14”, ciudad:“Mérida”, tel:”2445455”)

Para crear un objeto sin identidad (literal)struct(a:10, b:Carlos)

OQL


Descripción del lenguaje:

Una consulta se compone de un colección, posiblemente vacío y no recursivo, de definiciones de consultas seguido por una expresión

Ejemplo:

define Mora as select distinct x from x in Empleados wherex.apellido=”Mora”;

select distinct x.cedula from x in Mora

Define el conjunto de empleados Mora con cédula

Definición de expresiones de consultas o vistas:

define q as e

define una vista cuyo nombre es q según la expresión e, si se usa distinct es un set

OQL


Expresiones elementales:

si x es una variable, entonces x es una expresión

Si a es un átomo, entonces a es una expresión, que define al

átomo mismo

Si e es un objeto con nombre, entonces e es una expresión

Si q es el nombre de una consulta ya definida, entonces q es una

expresión

Ejm: 45 regresa 45

Nil regresa el objeto nil (no existe)

Empleados regresa el conjunto de empleados, extensión de la clase Empleado

Mora regresa el conjunto de empleados con apellido “Mora”

OQL


Construcción de expresiones:

Objetos: Si t es un tipo con p1, p2, …, pn propiedades y e1, e2, …, en son

expresiones, entonces t(p1:e1,…, pn:en) es una expresión. Los tipos deben ser compatibles

Si t es un tipo colección y e es una colección inmutable, entonces t (e)es un objeto colección

Ejemplos: Empleado(apellido:”Rivas”,jefe:”Mendez”)

conjuntoEnt(set(2,4,6))

Estructuras:Si p1,…, pn son propiedades y e1,…, en son expresiones entonces struct(p1:e1,…, pn:en) es una expresión

Ejm: struct(nombre:”Manuel”, edad:28)

Conjuntos:si e1,…, en son expresiones, entonces set(e1,…, en) es una expresión

Ejm: set(2,4,6,8)

OQL


Listas:si e1,…, en son expresiones, entonces list(e1,…, en ) una expresión

Ejm: list(1,1,2,5,9)

Bags:si e1,…, en son expresiones, entonces bag(e1,…, en ) una expresión

Ejm: bag(1,1,2,5,5,9)

Arreglos:si e1,…, en son expresiones, entonces array(e1,…, en ) una expresión

Ejm: array(1,2,5,9)

Expresiones aritméticas: Unitarias: Si e es una expresión y op un operador unario, entonces op

es una expresión.Ejm: not(true) Binarias: Si e1 y e2 son expresiones y op es un operador binario,

entonces e1 op e2 es una expresión.Ejm: count(Empleados) - count(Preparadores)

OQL


Expresiones colección:

Cuantificación universal: Si x es una variable, e1 y e2 son expresiones donde e1 denota una colección y e2 un predicado, entonces for all x in e1 : e2 es una expresión que regresa verdadero si todos los elementos de la colección e1 satisfacen el predicado e2, de lo contrario regresa falso

Cuantificación existencial: Si x es una variable, e1 y e2 son expresiones donde e1 denota una colección y e2 un predicado, entonces exists x in e1 : e2 es una expresión que regresa verdadero si hay al menos un elemento de la colección e1 que satisface el predicado e2, de lo contrario regresa falso

Prueba de membresía: Si e1 y e2 son expresiones donde e2 es una colección y e1 tiene el tipo de sus elementos, entonces e1 in e2 es una expresión que regresa verdadero si el pertenece a la colección e2

OQL


Select-from-where: Si e, e’, e1,…, en son expresiones y x1,…, xn

son variables, entonces

select[distinct] e from x1 in e1, x2 in e2,…,xn in en where e’

es una expresión

El resultado de la consulta es un conjunto si se usa distinct y una bag si no

Si la si e1,…, en son conjuntos o bags, entonces el resultado se obtiene aplicando el producto cartesiano de los conjuntos y filtrando el resultado con e’, luego se aplica e a cada uno de los elementos del conjunto filtrado y se obtiene el resultado

Si alguna de las colecciones tiene iterador, primero se convierten todas las colecciones a conjuntos y luego se aplica lo anterior

OQL


Uso del operador sort-by: si e, e1,…, en son expresiones y x una variable libre, entonces sort x in e by e1,…, en es una expresión que regresa la lista de los elementos de e ordenados lexicográficamente por las funciones e1,…, en

desc para orden descendente

asc para orden ascendente

El primer sort-by usa asc por omisión, el resto usa por omisión el último utilizado

Ejm: sort x in Personas by x.edad desc, x.nombre

Conjunto de operadores unario: si e es una expresión que denota una colección y op es un operador en {min,max,count,sum,avg}, entonces op e es una expresión

Ejm: max(select x.salario from x in Empleados)

OQL


Uso del operador group-by: si e es una expresión que denota una colección, p1,…, pn son propiedades, e1,…, en son expresiones con una variable libre x, p’1,…, p’n son propiedades y e’1,…, e’n son expresiones con una variable libre partición, entonces group x in e by(p1:e1,…, pn:en) es una expresión y

group x in e by(p1:e1,…, pn:en) with (p’1:e’1,…,p’n:e’n) es una expresión

Ejemplo:group x in Empleados

by ( bajo:x.salario < 5.500,

medio: x.salario>=5.500 and x.salario < 16.000,

alto: x.salario >=16.000)

group x in Empleados

by (dpto:x.nroDpto) with (salProm: avg(select w.salario from w in partition))

OQL


Colecciones con iterador: obtener el i-ésimo elemento de

la colección: si e1 y e2 son expresiones, e1 es una lista o un

arreglo y e2 es un entero, entonces e1 [e2] es una expresión.

El subíndice inicia en 0

Ejm: list(a,b,c,d)[1] regresa b

Extraer una sub-colección de una colección: si e1, e2 y

e3 son expresiones, e1 es una lista o un arreglo, e2 y e3 son

enteros, entonces e1[e2:e3] es una expresión que extrae la

sub-colección de e1 que se inicia en e2 y termina en e3

Ejm: list(a,b,c,d)[1:3] regresa la lista list(b,c,d)

OQL


element(select x from x in Empleados

where x.apellido=”Mora”).subordinado[0:2]

Regresa los tres primeros subordinados de Mora

Concatenar dos colecciones con iterador o indexadas:

si e1 y e2 son expresiones y e1 y e2 son listas o arreglos,

entonces e1 + e2 es una expresión

Ejm:

list(1,2)+list(2,3) regresa list(1,2,2,3)

array(67, 5, 71) + array(3, -2) regresa array(67, 5, 71, 3, -2)

OQL


Expresiones de conjunto:

Si e1 y e2 son expresiones, si op es una operador de {union, except, intersect}, si e1 y e2 son conjuntos o bags, entonces e1 ope2 es una expresión

Cuando los tipos son diferentes, set y bag, el conjunto se convierte a bag y el resultado es bag

Ejm:

Empleados except Preparadores regresa los empleados que no

son preparadores

bag(2,2,3,3,3,3) union bag(2,3,4) regresa bag(2,2,2,3,3,3,3,3,4)

Expresiones para estructuras: si e es una expresión y p es una propiedad, entonces e->, p y e.p son expresiones. Si la propiedad no existe o ha sido eliminada se regresa nulo

Ejm: Mora->telefono!=ni1 regresa el teléfono si existe

OQL


Conversión de expresiones:

Extrayendo un elemento: Si e es una expresión de valores de

colección, element (e) es una expresión

Ejm:

element(select x from x in Empleados where

x.cargo=”analista”)

Pase de lista a conjunto: si e es una expresión lista,

listtoset(e) es una expresión

Ejm: listtoset(list(1,2,3,2))

regresa el conjunto {1,2,3}

OQL


Conversión de colecciones de colecciones a colección: Si e es una expresión de valores de colección, flatten(e) es una

expresión que convierte la colección de colecciones de t en una colección de t

Solo opera en el primer nivel

Col1<col2<t>> Si col2 es un set (bag), la unión de todas las col2<t> es un

set<t> (bag<t>)

Si col2 es una lista (arreglo) y col1 es una lista (arreglo), se concatenan todas las col2<t> siguiendo el orden en col1 y el resultado es col2<t>. Se mantienen los duplicados

Si col2 es una lista (arreglo) y col1 es un set (bag), las listas o arreglos se convierten a conjuntos y se calcula la unión de los conjuntos resultados set<t>

Ejm: flatten(list(set(1,2,3),set(3,4,5,6),set(7)))regresa{1,2,3,4,5,6,7}

OQL


Afirmando el tipo de una expresión: Si e es una expresión y c su tipo, entonces (c)e es una expresión

Es una aserción sobre el tipo de e

Si no es verdad se obtiene una excepción

Expresiones de objetos: Si e, e1,…, en son expresiones y fes un nombre de operación, entonces e->f (e1,…, en) y e.f(e1,…, en) son expresiones que aplican la operación f con los parámetros e1,…, en al objeto e

Ejemplo:

Empleados.retirar(“14992884”)

Funciones especiales:

is_defined(e) regresa falso si e está indefinida

is_undefined(e) regresa falso si e está definida

Autoevaluación


1. ¿Cuáles son las características del OQL?

2. ¿Cómo es la jerarquía de los operadores del OQL?

3. ¿Cómo es la sintaxis de las consultas del OQL?

4. ¿Cómo se crean objetos mutables y literales en

OQL?

5. ¿Cómo son las expresiones en OQL?

6. ¿Cuáles son las funciones del OQL?

7. ¿Cómo se insertan, modifican y eliminan objetos en

OQL?

8. ¿Cómo se ordenan y agrupan objetos en OQL?

9. ¿Cómo se convierten colecciones en OQL?

Ejercicio


Modelo y esquema en LDO para representar el pensum de

la carrera de Ingeniería de Sistemas de la clase anteriorEstudiante

- CI: D1-TipoCIoRIF- nombre: D2-TipoNombre- apellido: D2-TipoNombre

+ inscribirEst(): bool+ listarEst(): Estudiante+ cambiarEst(): bool+ retirarEst(): bool

«dataType»D1-TipoCIoRIF

constraints{Cadena(10) en {V, P, E, -, digitos}}

«dataType»D2-TipoNombre

constraints{Cadena(32) en {letras, ', }}

«dataType»D3-TipoCodigo

constraints{Cadena(4) en {digitos}}

Asignatura

- codAsig: D3-TipoCodigo- nomAsig: D2-TipoNombre

+ abrirAsig(): bool+ cambiarAsig(): bool+ listarAsig(): Asignatura+ listarPrelaA(): list<Asignatura>+ listarPrelaciones(): list<Asignatura>+ cerrarAsig(): bool

Seccion

- nro: D4-TipoEntero+- sem: D5-TipoSemestre

+ abrirSecAsig(): bool+ cambiarSecAsig(): bool+ cerrarSecAsig(): bool+ listarSecAsig(): Seccion+ listarSeccionesAsig(): list<Seccion>

«dataType»D4-TipoEntero+

constraints{Entero >= 0}

«dataType»D5-TipoSemestre

constraints{Cadena(4) en {A, B, U, -, digitos}}

Nota

- notas: D6-TipoNota [1..20] {ordered}- pesos: D7-TipoPeso [1..20] {ordered}- definitiva: D6-TipoNota

+ asignarNota(D6-TipoNota, D1-TipoCIoRIF): bool+ listarNotasXestudiante(D1-TipoCIoRIF): Nota+ listarNotasXseccion(D4-TipoEntero+, D5-TipoSemestre): list<Nota>+ listarNotasXseccionYestudiante(D1-TipoCIoRIF, D4-TipoEntero+, D5-TipoSemestre): Nota

Profesor

- CI: D1-TipoCIoRIF- nomProf: D2-TipoNombre- feContratacion: D2-TipoNombre

«abstract»Educador

«dataType»D6-TipoNota

constraints{0 <= float <= 20}

«dataType»D7-TipoPeso

constraints{0 <= float <= 100}

-prelaA *

prelacion

-preladaPor *

«extends»

-cursadaPor

5..50

-cursa

1..*

-asigna *

-prof 1

Ejercicio


Para el esquema en ODL de la base de datos anterior, responda en OQL las consultas siguientes:

1. ¿Cuáles son las asignaturas dictadas por el profesor YoshiExplico en este semestre?

2. ¿Cuáles son las asignaturas cursadas por el estudiante YohnoAsisto en este semestre?

3. ¿Cuáles son las prelaciones de la materia Control 1?

4. Genere la lista de estudiantes de todas las secciones de la asignatura Control 1 en este semestre

5. Liste las asignaturas que aun no ha cursado el estudiante YocashiEstudio

6. ¿Cuál es el promedio de notas de este semestre de la estudiante Zoyla Estrella?

7. Actualice los promedios de las notas de los estudiantes que están cursando la asignatura Sistemas 2 en este semestre

8. Ingrese una sección adicional para la asignatura Programacion 3 en el semestre siguiente

Universidad de Los Andes Escuela de Ingeniería de Sistemas ... · Lenguaje de consulta de objetos...

Documents

Transcript of Universidad de Los Andes Escuela de Ingeniería de Sistemas ... · Lenguaje de consulta de objetos...