Lógica y Bases de Datos Matilde Celma Giménez.

Lógica y Bases de Datos Matilde Celma Giménez

Lógica y Bases de Datos 1. Lógica y Bases de Datos: introducción.
2. Bases de datos deductivas: definición y formalización. 3. Actualización de vistas. 3.1. Introducción al problema 3.2. Estudio avanzado del problema 4. Comprobación de restricciones de integridad en esquemas con vistas 4.1 Introducción al problema 4.2 Estudio avanzado del problema 5. SGBD deductivos. 5.1. Evaluación de consultas 5.2. SQL3

1. Lógica y Bases de Datos: introducción
La idea básica que subyace al uso de la lógica para el estudio de los sistemas de bases de datos es una idea común a todos los campos de la computación lógica: “la semántica por teoría de modelos de la lógica proporciona una base para la representación del conocimiento, y la semántica por teoría de la demostración proporciona una base para la computación” [J.W. Lloyd, en Computational Logic, 1990].

La lógica de primer orden ha sido utilizada en el desarrollo del modelo relacional de datos desde su aparición en 1970. Problemas: formalización definición de lenguajes de consulta estudio del concepto de independencia del dominio actualización de vistas - comprobación y restauración de la integridad. - optimización de consultas - diseño de bases de datos La lógica de primer orden ya había sido utilizada en el desarrollo del modelo relacional de datos [Dat93], [Ull80] desde su aparición en 1970 [Cod70]. Los problemas más relevantes que la lógica ha ayudado a estudiar y algunos de los primeros trabajos en este área se exponen a continuación: - formalización [NG78], [Kow78], [Kow81], [GMN84a], [Rei84]: un estado de una base de datos relacional puede formalizarse en lógica de primer orden como una interpretación de un lenguaje de primer orden o como una teoría de primer orden. - definición de lenguajes de interrogación [Cod72]: cálculo relacional de tuplas y cálculo relacional de dominios. - definición del concepto de independencia del dominio y caracterización de clases de fórmulas que cumplan dicha propiedad: fórmulas de rango separable [Cod72], fórmulas de rango restringido [Nic82], fórmulas seguras [Ull80], ... - formulación y evaluación simplificada de restricciones de integridad: [Nic79], [Nic82], [NY78]. - optimización de consultas: uso de criterios de simplificación sintácticos [ChM76], uso de información estadística [Dem80], uso de criterios de simplificación semánticos [Kin81]. - diseño de bases de datos: especificación formal [VCF81], [BW81], definición y análisis de dependencias funcionales [Fag82]. La idea básica que subyace en el uso de la lógica para el estudio de los sistemas de bases de datos es una idea común a todos los campos de la computación lógica: “la semántica por teoría de modelos de la lógica puede proporcionar una base para la representación del conocimiento, y la semántica por teoría de la demostración puede proporcionar una base para la computación” [Llo90].

Modelo Relacional de Datos Tupla Relación Estructuras de datos Álgebra Relacional Cálculo Relacional de Tuplas/Dominios SQL Operadores (lenguajes) Definición de relaciones Restricciones generales Restricciones (estáticas)

Tupla Relación Estructuras de datos tupla º registro · esquema de tupla: t = {(A1, D1), (A2, D2), …, (An, Dn)} tupla t de esquema {(A1, D1), (A2, D2), …, (An, Dn)}: t = {(A1, v1), (A2, v2), …, (An, vn)}: i ( vi  Di)

Tupla Relación Estructuras de datos Relación: conjunto de tuplas del mismo esquema al que se denomina esquema de la relación. R Definición de una relación R: R (A1: D1, A2: D2 , …, An: Dn ) Extensión de R: { { (A1, v1), (A2, v2), …, (An, vn)}: i ( vi  Di ) } A1 A2 A3 … An R representación del esquema de una relación representación tabular de la extensión de la relación

Valor No Nulo (NOT NULL) Unicidad (UNIQUE) Clave Primaria (PRIMARY KEY) Clave Ajena (FOREING KEY) CHECK CREATE ASSERTION Restricciones de Integridad

Álgebra Relacional Cálculo Relacional de Dominios Cálculo Relacional de Tuplas Lenguajes SQL (estándar) Operadores del Álgebra Relacional: insertar una tupla en una relación borrar una tupla de una relación seleccionar tuplas de una relación que cumplen una condición proyectar los valores de las tuplas de una relación sobre un conjunto de atributos. concatenar relaciones (join) unión, intersección, diferencia, …... actualización consulta

Lenguaje de tipo algebraico Consulta: “Nombre de los ríos que sólo pasan por una provincia” ( ( Pasa_por [rcod] – ( (Pasa_por P1  Pasa_por P2 ) DONDE P1.rcod = P2.rcod AND P1.pcod  P2.pcod) [rcod] ) producto cartesiano diferencia proyección concatenación Río) [nombre] selección

Álgebra Relacional Cálculo Relacional de Dominios Cálculo Relacional de Tuplas Lenguajes SQL (estándar) SQL INSERT (insertar tupals) DELETE (borrar tuplas) actualización consulta SELECT

Lenguaje de tipo lógico Consulta: “Nombre de los ríos que sólo pasan por una provincia” SELECT nombre FROM Río R WHERE EXISTS (SELECT * FROM Pasa_por P1 WHERE P1.rcod = R.rcod AND NOT EXISTS (SELECT * FROM Pasa_por P2 WHERE P2.rcod = R.rcod P1.pcod <> P2.pcod ) ) )

Relación: conjunto de tuplas del mismo esquema. Definición de una relación R: R (A1: D1, A2: D2 , …, An: Dn ) Extensión de R: { { (A1, v1), (A2, v2), …, (An, vn): i ( vi  Di )} } El Álgebra Relacional es un conjunto de operadores definidos para la estructura de datos relación (conjunto de tuplas). El CRT, CRD y SQL son lenguajes lógicos definidos sobre ??? Aproximación algebraica Aproximación lógica

Formalización lógica de una base de datos relacional: Interpretación de un lenguaje de 1er orden (Teoría de Modelos) Teoría de un lenguaje de 1er orden (Teoría de la Demostración)

Esquema S: Enseña (cod_prof: dom_P, cod_curso: dom_C) CP: {cod_prof, cod_curso} CAj: {cod_prof}  Profesor CAj: {cod_curso}  Curso Matriculado (cod_alum: dom_A, cod_curso: dom_C) CP: {cod_alum, cod_curso} CAj: {cod_alum}  Alumno Dominios: dom_P= { A, B, C } dom_A = { a, b, c, d } dom_C = { CS100, CS200, P100, P200 } Relaciones: Profesor (cod_prof: dom_P) CP: {cod_prof} Alumno (cod_alum: dom_A) CP: {cod_alum} Curso (cod_curso: dom_C) CP: {cod_curso} Restricciones: "Todo curso es impartido por algún profesor"

Base de Datos: Ext (S) Ext(Profesor) Ext(Alumno) Ext(Curso) Ext(Matriculado) Ext(Enseña)

Formalización lógica de una base de datos relacional: interpretación de un lenguaje de 1er orden. Esquema S: (L, RI) Un conjunto de símbolos biyectivo con la unión de los dominios de definición de las relaciones del esquema: C = {ci: cidi, di  i (Di), Di es un dominio de S } Constantes C Lenguaje L Predicados P Nombres de relación del esquema: P = { Rn: R (A1: D1, A2: D2 , ..., An: Dn)  S }  {=} Sea D la unión de todos los dominios que aparecen en el esquema de la base de datos entonces, los símbolos de constantes y de predicados del lenguaje son los siguientes: • Constantes: por cada elemento de D, se introduce un símbolo de constante y nada más que uno. Para simplificar, se escogen como símbolos de constantes los símbolos que denotan a los elementos de D. • Predicados: por cada esquema de relación n-aria,, en el esquema de la base de datos, se introduce un símbolo de predicado n-ario. Para simplificar, se escogerán como símbolos de predicado los nombres de las relaciones. Por razones que se justificarán posteriormente, se incluye el predicado =, que se interpretará como la igualdad. En este alfabeto, por simplicidad, no se incluyen los símbolos de función. Los símbolos de variables, las conectivas lógicas, los símbolos especiales y los cuantificadores son los propios de un lenguaje de primer orden. Las fbfs de este lenguaje se construyen de la forma usual. Fórmulas bien formadas (f.b.f) de L RI Restricciones de Integridad (RI)

Formalización lógica de una base de datos relacional: interpretación de un lenguaje de 1er orden. Interpretación I de L : (D, K, E) Unión de los dominios de definición de las relaciones del esquema: D = {di : di  i (Di), Di es un dominio de S} Dominio D Interpretación Asignación (K, E) K : C  D / K = { (c, d): c  C, d  D, c  d} E : P  i:1..n ( 2Di ) / E(pk)  (2Dk), E(pk) = Ext(p) (pk es un predicado de aridad k) E(=) = { (d, d): d  D } En la interpretación, a cada predicado se le asigna su extensión en la base de datos. Si <d1, d2, …, dn> no está en la extensión de p, entonces p(d1, d2, …, dn) es falso. Es decir, en una interpretación se dice, implícitamente, para cualquier predicado n-ario p y para cualquier n-tupla de valores <d1, d2, …, dn> si p(d1, d2, …, dn) es cierto o falso. La evaluación de p(d1, d2, …, dn) se hace por simple observación en la base de datos, si <d1, d2, …, dn> está en la extensión de p, entonces la fórmula es cierta en caso contrario es falsa. La información negativa (qué no es cierto) no se tiene por extensión, se deriva usando la hipótesis del mundo cerrado: si A D entonces A es cierto. Las reglas de evaluación de una fórmula de L en I son comunes a todos los lenguajes de 1er orden. Estas reglas de evaluación permiten asociar a toda fórmula cerrada de L un valor de verdad (cierto, falso) en la interpretación.

Predicados P Nombres de relación del esquema: P = { Rn: R (A1: D1, A2 : D2 , ..., An : Dn)  S }  {=} En la definición del lenguaje L, hemos convertido cada relación n-aria del esquema S en un predicado n-ario, definiendo un orden en el conjunto de atributos del esquema de la relación. De esta forma el concepto de relación coincide con el concepto de relación matemática (subconjunto del producto cartesiano de los dominios): se pierde el concepto de atributo de una relación. Con esta simplificación se pierde el concepto de atributo. Las tuplas pasan a ser listas de valores y la referencia a un atributo es por posición no por el nombre de atributo. Esta simplificación no quita generalidad al estudio teórico de las bases de datos.

Unión de los dominios de definición de las relaciones del esquema: D = {di : di  i (Di), Di es un dominio de S} Dominio D Asignación (K, E) E : P  i:1..n ( 2Di ) / E(pk)  (2Dk), E(pk) = Ext(p) (pk es un predicado de aridad k) E(=) = { (d, d): d  D } En la definición de la interpretación I de L, hemos definido el dominio como la unión de los dominios de definición de las relaciones del esquema. De esta forma se pierde el concepto de dominio de un atributo (lógica homogénea). Esta simplificación no quita generalidad a la formalización, ya que podría trabajarse en una lógica con tipos (lógica heterogénea). Con esta simplificación se pierde el concepto de atributo. Las tuplas pasan a ser listas de valores y la referencia a un atributo es por posición no por el nombre de atributo. Esta simplificación no quita generalidad al estudio teórico de las bases de datos.

Esquema S: (L, RI) : Constantes: dom_P È dom_A È dom_C = {A, B, C, a, b, c, d, CS100, CS200, P100, P200} Predicados: { Profesor(.), Alumno(.), Curso(.), Enseña(.,.), Matriculado(.,.)}  {=} Lenguaje L Variables: { X, Y, Z, …} Cuantificadores: { " , $ } Conectivas lógicas: { Ù, Ú , ® } Símbolos de puntuación: { (, ),’, ... } Restricciones de Integridad: "x ( curso (x) ®  y enseña (y,x) ) RI Fórmula bien formada de L

BD: interpretación de L que es modelo de RI D = {A, B, C, a, b, c, d, CS100, CS200, P100, P200} K(A)=A, K(B)=B, …, K(P200)=P200 E (Profesor) E (Alumno) E (Curso) E (Matriculado) E (Enseña) E(=) = {(d, d): d D}

BD: interpretación de L que es modelo de RI D = {A, B, C, a, b, c, d, CS100, CS200, P100, P200} K(A)=A, K(B)=B, …, K(P200)=P200 E(=) = {(d,d): d D} En esta formalización, L es un lenguaje de definición de datos y de consulta: f.b.f cerrada de L: restricción de integridad (x ( curso (x)   y enseña (y,x) ) f.b.f abierta de L: consulta a la BD (profesor (x)  ¬ enseña (x, CS100) )

Formalización lógica de una base de datos relacional: Interpretación de un lenguaje de 1er orden Teoría de un lenguaje de 1er orden

Formalización lógica de una base de datos relacional: teoría de un lenguaje de 1er orden. Esquema S: (L, RI) BD: Interpretación I de L Esquema S: (L, RI) BD: Teoría T de L |=I F sii T |= F

Formalización lógica de una base de datos relacional: teoría de un lenguaje de 1er orden. Axiomas de información básica en T Por cada predicado n-ario p de L y por cada tupla <d1, ..., dn> en la extensión de p en la base de datos, se incluye en T el átomo p(d1, ..., dn). T = { profesor(A), profesor(B), ..., matriculado(d, P200)}  {x =(x, x)}

Axiomas de compleción en T (información negativa) Existen fórmulas F que no son consecuencia lógica de la teoría T y sin embargo son ciertas en la interpretación I, es decir T |F y |=I F, por ejemplo la fórmula ¬Prof(P100). Para resolverlo se añade a T un axioma que defina explícitamente quienes son los únicos individuos para cada predicado: x1, ..., xn (p(x1, ..., xn)  ((=(x1, d11)  ...  =(xn, d1n))  (<di1, ..., din> es una tupla de p) (=(x1, dm1)  ...  =(xn, dmn)))) T = { profesor(A), profesor(B), ..., matriculado(d, P200), x =(x, x), x (profesor(x)  (=(x, A)  =(x, B)  =(x,C))), x (alumno(x)  (=(x, a)  =(x, b)  =(x,c)  =(x,d))), … } En una teoría el conocimiento viene definido a través de los axiomas, los axiomas de información básica definen la información positiva. Con estos axiomas (átomos base) no se puede derivar información negativa ya que T{A} siempre es satisfacible (siempre puedo encontrar un modelo). Por este motivo hay que incluir axiomas que permitan derivar (demostrar) qué información negativa es cierta. x1, ..., xn (p(x1, ..., xn)  ((=(x1, d11)  ...  =(xn, d1n))  (<di1, ..., din> es una tupla de p) (=(x1, dm1)  ...  =(xn, dmn)))) Si (<ci1, ..., cin> no es una tupla de p, entonces (p(c1, ..., cn)  ( (=(c1, d11)  ...  =(cn, d1n))  (<di1, ..., din> es una tupla de p)  (=(c1, dm1)  ...  =(cn, dmn))))

Axiomas de nombre único en T Existen fórmulas F que no son consecuencia lógica de la teoría T y sin embargo son ciertas en la interpretación I, es decir T |F y |=I F, por ejemplo la fórmula ¬ =(A, B). Para resolverlo se añade a T un axioma que defina explícitamente qué pares de constantes no son iguales: ¬ =(c, c’): c, c’ son dos constantes distintas de C T = { profesor(A), profesor(B), ..., matriculado(d, P200), x =(x, x), x (profesor(x)  ( =(x, A)  =(x, B)  =(x,C))), x (alumno(x)  ( =(x, a)  =(x, b)  =(x,c)  =(x,d))), …, ¬ =(A, B), ¬ =(A, C), ¬ =(A, a), ..., ¬ =(P100, P200) } En el conjunto de axiomas básicos hemos incluido el axioma x =(x,x) que define la extensión del predicado igualdad. Pero como sucede con los otros predicados con este axioma es imposible demostrar qué constantes no son iguales.

Axioma de cierre de dominio en T Existen fórmulas F que no son consecuencia lógica de la teoría T y sin embargo son ciertas en la interpretación I, es decir T |F y |=I F, por ejemplo la fórmula dependiente del dominio, F = x (Prof(x)  Curso(x)  Alumno(x)). Para resolverlo se añade a T un axioma que defina explícitamente el domino: x (=(x, c1)  ...  =(x, cm)): {c1, c2,...cm} son las constantes de C. T = { profesor(A), profesor(B), ..., matriculado(d, P200), x =(x, x), x (profesor(x)  ( =(x, A)  =(x, B)  =(x,C))), x (alumno(x)  ( =(x, a)  =(x, b)  =(x,c)  =(x,d))), …, ¬ =(A, B), ¬ =(A, C), ¬ =(A, a), ..., ¬ =(P100, P200), x (=(x, A)  =(x, B)  ...  =(x, P200)) } Este axioma de cierre de dominio se puede omitir si se tiene la precaución de trabajar con fórmulas independientes del dominio, es decir fórmula que para su evaluación no sea necesario acceder al dominio. En la interpretación el dominio forma parte de la interpretación, en la teoría no hay dominio si no se define explícitamente por medio de un axioma. BDD: rango restringido  segura  independiente del dominio ¿Qué profesor no enseña el curso CS200?: X  enseña(x, CS200): fórmula dependiente del dominio X (profesor(x)  enseña(x, CS200)): fórmula independiente del dominio PL: P: p(x) q(x,y)p(x) ¿Existe algún y tal que q(a,y)? q(a,y) p(a) comp(D) |= y q(a,y) []

Teoría T T = { p(d1, ..., dn): pn  P, y <d1, ..., dn>  Ext(p), x =(x, x), x1, ..., xn (p(x1, ..., xn)  ((=(x1, d11)  ...  =(xn, d1n))  . . . (=(x1, dm1)  ...  =(xn, dmn)))): pn  P y <di1, ..., din>  Ext(p), x1, ..., xn ¬ p(x1, ..., xn ): pn  P y Ext(p) = , ¬ =(c, c’): c y c’ son constantes distintas de C, x (=(x, c1)  =(x, c2)  ...  =(x, cm)): (c1, c2, …, cm) son las constantes de C } Axiomas de información básica Axioma de la igualdad Axiomas de compleción Para definir el predicado =, como la identidad no son suficiente los axiomas incluidos en la teoría T para este predicado. Los axiomas que definen = como la identidad en ausencia de símbolos de función son: 1. c  d para todo par de símbolos de constante c y d distintos. 2. x(x=x). 3. ((x1=y1)...  (xn=yn))  (p(x1,...,xn)  p(y1,...,yn)) para cada símbolo de predicado p Los axiomas 2 y 3 aseguran que la relación asignada al predicado = en una interpretación sea una relación de equivalencia. El dominio de cualquier modelo de comp(D) contiene una copia isomórfica de UD y la relación asignada a =, restringida a UD es la relación identidad. Axiomas de nombre único Axioma de cierre de dominio

Esquema S de la BD Lenguaje de 1er orden L Extensión D de la BD Axiomas de información básica: D = { p(d1, ..., dn): pn  P, y <d1, ..., dn>  Ext(p)} (átomos base) T = comp(D)  {axioma de cierre de dominio} Teoría de primer orden en L La teoría T que hemos construido es la compleción de D (axiomas de información básica). La teoría de la compleción fue introducida por Clark [Cla78] para dar una semántica declarativa a la regla de la negación como fallo utilizada en el lenguaje Prolog y que se enuncia de la forma siguiente: si existe un árbol SLDNF fallado finitamente para D  { A} entonces comp(D)|= A. Esta semántica se basa en la idea de interpretar el conocimiento expresado en la base de datos como completo, es decir el conjunto de sentencias que tienen el mismo símbolo de predicado en la cabeza se interpreta como la definición completa de dicho predicado en D.

Esquema S de la BD Lenguaje de 1er orden L Extensión D de la BD Programa lógico: D = {A: A es un átomo base} Semántica de D {L: L es un literal base, T |= L } T = comp(D)  {axioma de cierre de dominio}

La teoría de la compleción formaliza hipótesis implícitas en la evaluación de consultas en bases de datos relacionales: - hipótesis del mundo cerrado - hipótesis del cierre del dominio - hipótesis de nombre único Hipótesis del mundo cerrado axiomas de compleción Hipótesis del cierre de dominio axioma de cierre de dominio Hipótesis de nombre único axioma de nombre único

Hipótesis del mundo cerrado
1. Lógica y Bases de Datos: introducción Axiomas de compleción para las relaciones del esquema A D Hipótesis del mundo cerrado Ø A D HMC

Lógica y Bases de Datos 1. Lógica y Bases de Datos: introducción.
2. Bases de datos deductivas: definición y formalización. 3. Actualización de vistas. 3.1. Introducción al problema 3.2. Estudio avanzado del problema 4. Comprobación de restricciones de integridad en esquemas con vistas 4.1 Introducción al problema 4.2 Estudio avanzado del problema 5. SGBD deductivos. 5.1. Evaluación de consultas 5.2. SQL3

2. Bases de datos deductivas: definición y formalización
Base de datos relacional Base de datos relacional Conocimiento explícito + Reglas deductivas Reglas deductivas Conocimiento implícito Base de datos deductiva Las Bases de Datos Deductivas extienden la capacidad expresiva de las bases de datos relacionales incluyendo un conjunto de reglas que permiten definir conocimiento implícito

Padre Reglas Deductivas: Antecesor (x, y) ¬ Padre (x, y) Antecesor (x, y) ¬ z (Padre (x, z) Ù Antecesor (z, y) ) Base de datos deductiva Juan es antecesor de Luis Juan es antecesor de María Juan es antecesor de Pedro Luis es antecesor de José

Hechos = {tuplas de relaciones} (información básica) Hechos Sistema de inferencia Información derivada Reglas = {reglas deductivas} (conocimiento implícito) Reglas Sistema de Gestión de Bases de Datos Relacionales Base de datos relacional + + Reglas deductivas Usuario Sistema de Inferencia Base de datos deductiva Sistema de gestión de bases de datos deductivas

Relación derivada Base de datos deductiva Padre Antecesor Reglas Deductivas: Antecesor (x, y) ¬ Padre (x, y) Antecesor (x, y) ¬ z (Padre (x, z) Ù Antecesor (z, y)) Para expresar las reglas deductivas se ha utilizado una notación lógica propia de la Programación Lógica. Las variables se asumen cuantificadas universalmente.

Bases de Datos Relacionales Bases de Datos Deductivas ESQUEMA Relaciones Ri (Ai1: Di1, Ai2: Di2 , ..., Aini: Dini) (1 £ i £ m) (m relaciones) Restricciones de Integridad Wi: Wi es una expresión lógica (1 ≤ i ≤ k) (k restricciones de integridad) ESQUEMA Relaciones básicas: Ri (Ai1: Di1, Ai2: Di2 , ..., Aini: Dini) (1 £ i £ m) (m relaciones básicas) Relaciones derivadas: Si (Ai1: Di1 , Ai2: Di2 , ..., Aini: Dini) (1 £ i £ s) (s relaciones derivadas) Restricciones de Integridad Wi: Wi es una expresión lógica (1 ≤ i ≤ k) (k restricciones de integridad)

Bases de Datos Relacionales Bases de Datos Deductivas Base de datos Base de datos Ri Í (Di1 x Di2 x ... x Dini) (1 £ i £ m) (m relaciones) Ri Í (Di1 x Di2 x ... x Dini ) (1 £ i £ m) (m relaciones básicas) Sij (x1, x2,..., xni ) ¬ Wij (1 £ i £ s) (s relaciones derivadas) (1 £ j £ Ki) (Ki reglas para la relación Si) Ri Con esta simplificación se pierde el concepto de atributo. Las tuplas pasan a ser listas de valores y la referencia a un atributo es por posición no por el nombre de atributo. Esta simplificación no quita generalidad al estudio teórico de las bases de datos.

Bases de Datos Relacionales Bases de Datos Deductivas Base de datos Base de datos Ri Í (Di1 x Di2 x ... x Dini) (1 £ i £ m) (m relaciones) Ri Í (Di1 x Di2 x ... x Dini ) (1 £ i £ m) (m relaciones básicas) Sij (x1, x2,..., xni ) ¬ Wij (1 £ i £ s) (s relaciones derivadas) (1 £ j £ Ki) (Ki reglas para la relación Si) Si definimos un orden en el conjunto de atributos del esquema de la relación, el concepto de relación coincide con el concepto de relación matemática (subconjunto del producto cartesiano de los dominios): se pierde el concepto de atributo de una relación. En la definición de una regla deductiva, S  W: W es una fórmula cuyas únicas variables libres son las variables de S. Con esta simplificación se pierde el concepto de atributo. Las tuplas pasan a ser listas de valores y la referencia a un atributo es por posición no por el nombre de atributo. Esta simplificación no quita generalidad al estudio teórico de las bases de datos.

Relaciones básicas: PIEZA (codpieza: D1, desc: D2, peso: D3) CP = {codpieza} PROV (codprov: D4, nombre: D5, zona: D6) CP = {codprov} PRECIOS (codprov: D4, codpieza: D1, precio: D7) CP = {codprov, codpieza} CAj = {codprov} ® PROV CAj = {codpieza} ® PIEZA COMP (pieza1: D1, pieza2: D1) CP = {pieza1, pieza2} CAj = {pieza1} ® PIEZA CAj = {pieza2} ® PIEZA Esquema

Relaciones derivadas: PRECIOS3 (codprov: D4, codpieza: D1, precio: D7) CP = {codprov, codpieza} CAj = {codprov} ® PROV CAj = {codpieza} ® PIEZA PRECIOS_EXT (codprov: D4, nombre: D5, codpieza: D1, desc: D2, precio: D7) COMPONENTE (pieza1: D1, pieza2: D1) CP = {pieza1, pieza2} CAj = {pieza1} ® PIEZA CAj = {pieza2} ® PIEZA Restricciones de integridad: "x "y ( COMPONENTE (x,y) ® Ø COMPONENTE (y,x) ) Esquema

PIEZA PROV Base de Datos PRECIOS COMP

Reglas deductivas: 1 PRECIOS3 (x, y, z) ¬ w (PROV (x, w, 3)  PRECIOS (x, y, z) ) 2 COMPONENTE (x, y) ¬ z (COMP (x, z) Ù COMPONENTE (z, y) ) 3 COMPONENTE (x, y) ¬ COMP (x, y) 4 PRECIOS_EXT (x, n, y, d, p) ¬ z w (PROV (x, n, z) Ù PIEZA (y, d, w)  PRECIOS (x, y, p) ) Base de Datos Se asume la notación de la Programación Lógica: todas las variables libres en la regla se suponen cuantificadas universalmente.

PROV PIEZA PRECIOS COMP BASE DE DATOS PRECIOS3 PRECIOS_EXT COMPONENTE El usuario desea manipular las relaciones de la BD independientemente de que sean relaciones básicas o derivadas.

Mecanismo de vistas del modelo relacional Definición de información implícita Relación derivada PRECIOS3 VISTA SQL92: CREATE VIEW PRECIOS3 AS SELECT codprov, codpieza, precio FROM PRECIOS, PROV WHERE (PRECIOS.codprov = PROV.codprov AND (PROV.zona=3)

Limitaciones del modelo relacional (SQL92) en la definición de vistas: Relación derivada COMPONENTE VISTA SQL: CREATE VIEW COMPONENTE AS SELECT pieza1, pieza2 FROM COMP UNION FROM COMP, COMPONENTE ¡ En SQL92 no se pueden definir vistas recursivas!

Limitaciones del modelo relacional (SQL92) en la actualización de vistas: opción 1 INSERT INTO PRECIOS3 VALUES (pv12, pz23, 20) INSERT INTO PRECIOS VALUES (pv12,pz23,20) ¿el proveedor existe? ¿la pieza existe? NO SI SI NO INSERT INTO PROV VALUES (pv12,NULL,3) INSERT INTO PIEZA VALUES (pz23,NULL,NULL) ¿el proveedor es de la zona 3? NO SI error c

Limitaciones del modelo relacional (SQL92) en la actualización de vistas: opción 2 INSERT INTO PRECIOS3 VALUES (pv12, pz23, 20) ¿el proveedor pv12 existe y es de la zona 3 y la pieza pz23 existe? SI NO INSERT INTO PRECIOS VALUES (pv12, pz23, 20) error

INSERT INTO PRECIOS3 VALUES (pv12, pz23, 20)
2. Bases de datos deductivas: definición y formalización Limitaciones del modelo relacional (SQL92) en la actualización de vistas: INSERT INTO PRECIOS3 VALUES (pv12, pz23, 20) opción 1 opción 2 ¡Debido a la ambigüedad existente, el SQL92 no permite actualizar vistas definidas a partir de una concatenación de tablas!

Los sistemas de gestión de bases de datos deductivas deben superar las limitaciones de los sistemas relacionales PROBLEMAS: Formalización Actualización de la base de datos Construcción de SGBD deductivos

ESQUEMA Relaciones básicas: Ri (Ai1: Di1, Ai2: Di2 ..., Aini: Dini) (1 £ i £ m) (m relaciones básicas) Relaciones derivadas: Si (Ai1: Di1, Ai2: Di2 , ..., Aini: Dini) (1 £ i £ s) (s relaciones derivadas) notación algebraica BASE DE DATOS Ri Í (Di1 x Di2 x ... x Dini ) (1 £ i £ m) Sij (x1, x2,..., xni ) ¬ Wij (1 £ i £ s) (1 £ j £ Ki) notación lógica 5

Si intentamos representar la información explícita y la información implícita en un mismo lenguaje (lenguaje de 1er orden) obtenemos un programa lógico: pieza (pz1, tornillo, 10) ... prov (pv1, Juan, 1) comp (pz1, pz3) precios3 (x, y, z) ¬ w (prov (x, w, 3) Ù precios (x, y, z) ) componente (x, y) ¬ z ( comp (x, z) Ù componente (z, y) ) componente (x, y) ¬ comp (x, y) precios_ext (x,n,y,d,p)¬ zw (prov (x, n, z) Ù pieza (y, d, w) Ù precios (x, y, p) ) Base de datos deductiva Reglas deductivas Hechos

Lenguaje de definición de reglas
2. Bases de datos deductivas: definición y formalización Lenguaje de definición de reglas Lenguaje de 1er orden Base de datos deductiva Programa lógico Sistema de gestión de bases de datos deductivas Sistema de programación lógica

MARCO FORMAL: Lógica de primer orden (Programación Lógica) Esquema de BDD: (L, RI): - L es un lenguaje de 1er orden - RI es un conjunto de f.b.f de L (restricciones de integridad) BDD: (programa lógico) {A: A es un átomo base} (hechos) È { A ¬ L1 Ù L2 Ù ... Ù Ln : A es un átomo y Li es un literal} (reglas)

BASE DE DATOS BDD (programa lógico) {A: A es un átomo base} È { A ¬ L1 Ù L2 Ù ... Ù Ln: A es un átomo y Li es un literal} Ri Í (Di1 x Di2 x ... x Dini ) (1 £ i £ m) Sij (x1, x2,..., xni ) ¬ Wij (1 £ i £ s) (1 £ j £ Ki) En la formalización como un programa lógico, las reglas se definen como cláusulas (disyunción de literales). Esta simplificación no quita generalidad ya que el algoritmo de Lloyd [LT84] permite transformar una regla general, S W, en un conjunto de cláusulas equivalentes en la semántica de la compleción.

BDD: (programa lógico) {A : A es un átomo base} (hechos) È { A ¬ L1 Ù L2 Ù ... Ù Ln : A es un átomo y Li es un literal} (reglas) BDD definida: sin negación en el cuerpo de las reglas BDD normal: con negación en el cuerpo de las reglas BDD jerárquica: sin recursión BDD estratificada: con recursión (no en términos de negación) 15

Fórmulas bien formadas (f.b.f) de L
2. Bases de datos deductivas: definición y formalización Esquema: (L, RI) : Unión de los dominios de definición de las relaciones del esquema Constantes Lenguaje L Predicados Nombres de relación del esquema Fórmulas bien formadas (f.b.f) de L RI Restricciones de Integridad (RI)

Fórmulas bien formadas de L
2. Bases de datos deductivas: definición y formalización Esquema: (L, RI) : Constantes: D1 È D2 È D3 È D4 È D5 È D6 È D7 = {pz1, pz3, …, tornillo, tuerca, …, pv1, pv5, ..., Juan,…} Predicados: { PIEZA, PROVEEDOR, PRECIOS, PRECIOS_EXT, PRECIOS3, COMP, COMPONENTE} Lenguaje L Variables: { X, Y, Z, …} Cuantificadores: { " , $ } Conectivas lógicas: { Ù, Ú , ® } Símbolos de puntuación: { (, ),’, ... } Restricciones de Integridad: "x "y ( componente (x,y) ® Ø componente (y,x) ) RI Fórmulas bien formadas de L

Fórmulas bien formadas de L
2. Bases de datos deductivas: definición y formalización BDD: { pieza (pz1, tornillo, 10), ..., proveedor (pv1, Juan, 1), ..., precios (pv1, pz3, 100), ..., comp (pz1, pz3), ... } Fórmulas bien formadas de L Hechos È precios3 (x, y,z) ¬ precios (x, y, z) Ù prov (x, w, 3) componente (x, y) ¬ comp (x,z) Ù componente (z, y) componente (x, y) ¬ comp (x, y) precios_ext (x,n,y,d,p) ¬ prov (x, n, z) Ù pieza (y, d, w) Ù precios (x, y, p) Reglas deductivas

Esquema de la BDD Lenguaje de 1er orden L Extensión de la BDD Programa lógico (D)

Semántica de una BDD Programación lógica: semántica operacional: SLDNF semántica declarativa: comp(D) Semántica operacional: procedimiento SLDNF SLDNF: - procedimiento de refutación - reglas de inferencia: resolución negación como fallo Semántica declarativa asociada al SLDNF: compleción de D 16

¿ De qué piezas se compone la pieza pz1?
¬ componente (pz1,w) Procedimiento SLDNF 2 3 ¬ comp (pz1,z) Ù componente (z,w) ¬ comp (pz1,w) hecho z/pz3 hecho w/pz3 componente (pz3,w) 2 3 ¬ comp (pz3,z ‘) Ù componente (z ‘,w) ¬ comp (pz3,w) ¿ De qué piezas se compone la pieza pz1? w/pz8 z’/pz8 hecho hecho ¬ componente ( pz8,w) 2 3 ¬ comp (pz8,z ‘‘) Ù componente (z ‘‘,w) ¬ comp (pz8,w) SLDNF: procedimiento de refutación. Para demostrar A de una teoría T, se incluye A como axioma de la teoría y si aplicando las reglas de inferencia se llega a una contradicción, entonces se deriva A. ¿T A? T {A } []  T A ¿w componente (pz1,w)? Se niega la fórmula a demostrar : w componente(pz1,w) (componente (pz1,w) ), y si se llega a la cláusula vacía (contradición) se demuestra que w componente (pz1,w). w = pz3 w = pz8 2 componente (x, y) ¬ comp (x, z) Ù componente (z, y) 3 componente (x, y) ¬ comp (x, y)

w = pz8 ¬ componente (pz1,w) Procedimiento SLDNF resolución
componente (x,y) ¬ comp (x,z) Ù componente (z,y) resolución regla 2 x/pz1 y/w ¬ comp (pz1,z) Ù componente (z,w) comp (pz1,pz3) hecho z/pz3 resolución ¿ De qué piezas se compone la pieza pz1? ¬ componente (pz3,w) componente (x,y) ¬ comp (x,y) regla 3 respuesta resolución x/pz3 y/w ¬ comp (pz3,w) resolución comp (pz3,pz8) hecho w = pz8 w/pz8 éxito

x/pv1 Procedimiento SLDNF ¬ proveedor (x, y, z) Ù Ø precios (x,pz1,30)
proveedor (pv1,Juan,1) hecho resolución ¿Qué proveedores no suministran la pieza pz1 a 30€? x/pv1, y/Juan, z/1 ¬ Ø precios (pv1, pz1,30) ¬ precios (pv1,pz1,30) negación como fallo respuesta x/pv1 fallo éxito

¿Suministra el proveedor pv1 la pieza pz1 a 30€?
2. Bases de datos deductivas: definición y formalización Semántica declarativa: teoría de la compleción de D (comp(D)) ¬ precios (pv1, pz1, 30) ¿Suministra el proveedor pv1 la pieza pz1 a 30€? no D precios (pv1, pz1, 30) SLDNF no infiere consecuencias lógicas de D SLDNF infiere consecuencias lógicas de comp(D) En un programa jerárquico y definido P, si existe un árbol SLDNF fallado finitamente para P  {p(x)}, se puede afirmar que comp(D) ¬x p(x) D Ø precios (pv1, pz1, 30)

{ precios (pv1, pz3,10), precios (pv1, pz8,20), precios (pv3, pz8, 30), precios (pv5, pz1,50), , } D precios (pv1, pz1, 30) D Ø precios (pv1, pz1, 30) Comp(D): { precios (pv1, pz3,10), precios (pv1, pz8, 20), precios (pv3, pz8, 30), precios (pv5, pz1, 50), "x "y "z ( precios (x, y, z) ® (x=pv1 Ù y=pz3 Ù z=10) Ú (x= pv1 Ù y= pz8 Ù z= 20) Ú (x= pv3 Ù y= pz8 Ù z= 30) Ú (x= pv5 Ù y= pz1 Ù z= 50) ), ... } Comp(D): Ø precios (pv1, pz1, 30)

"x "y "z ( precios (x, y, z) ® (x=pv1 Ù y=pz3 Ù z=10) Ú (x= pv1 Ù y= pz8 Ù z= 20) Ú (x= pv3 Ù y= pz8 Ù z= 30) Ú (x= pv5 Ù y= pz1 Ù z= 50) ) (precios (pv1, pz1,30) ® (pv1=pv1 Ù pz1=pz3 Ù 30=10) Ú (pv1=pv1 Ù pz1=pz8 Ù 30=20) Ú (pv1=pv3 Ù pz1=pz1 Ù 30=30) Ú (pv1=pv5 Ù pz1=pz1 Ù 30=50) ) Ø (pv1=pv1 Ù pz1=pz3 Ù 30=10) Ø (pv1=pv1 Ù pz1=pz1 Ù 30=20) Ø (pv1=pv3 Ù pz1=pz8 Ù 30=30) Ø (pv1= pv5 Ù pz1=pz1 Ù 30=50) Ø precios (pv1, pz1, 30)

comp (D) = {pieza (pz1, tornillo, 10), ..., proveedor (pv1, Juan, 1), ..., precios (pv1, pz3, 100), ..., comp (pz1, pz3), ... } Axiomas de hechos È precios3 (x, y,z) ¬ precios (x, y, z) Ù prov (x, w, 3) componente (x, y) ¬ comp (x,z) Ù componente (z, y) componente (x, y) ¬ comp (x, y) precios_ext (x,n,y,d,p) ¬ prov (x, n, z) Ù pieza (y, d, w) Ù precios (x, y, p) Axiomas de reglas È

È "x "y "z pieza (x, y, z) ® (x= pz1 Ù y= tornillo Ù z=10) Ú
(x= pz3 Ù y= tuerca Ù z=11) (x= pz8 Ù y= arandela Ù z=8) ... "x "y "z precios3 (x, y, z) ® precios (x,y,z) Ù prov (x,w,3) "x "y componente (x,y) ® comp(x,y) $z (comp(x,z) Ù componente (z,y)) Axiomas de compleción

Teoría de la compleción: comp(D) p(t1,.., tn)  L1  L2  ...  Lm  p(x1,..., xn)  y1... yd (x1=t1  ...  xn=tn  L1  L2  ...  Lm) Com(D) = { p(x1,..., xn)  E1 (Ei = y1... yd (x1=t1  ...  xn=tn  L1  L2  ...  Lm) ) p(x1,..., xn)  Ek , x1, ..., xn ( p(x1, ..., xn)  (E1  ...  Ek) ), x1, ..., xn ¬ p(x1, ..., xn): no existen sentencias de p en D x =(x, x), ¬ =(A, B), ¬ =(A, C), ¬ =(A, a), ..., ¬ =(P100, P200) x (=(x, A)  =(x, B)  ...  =(x, P200)) } Axiomas sobre p en D Axiomas de compleción de p Axiomas de la igualdad Esta semántica se basa en la idea de interpretar el conocimiento expresado en la base de datos como completo, es decir el conjunto de sentencias que tienen el mismo símbolo de predicado en la cabeza se interpreta como la definición completa de dicho predicado en D. La compleción de una base de datos se obtiene añadiendo a D los axiomas de compleción para cada predicado de L junto con los axiomas de la teoría de la igualdad (estos últimos son necesarios al aparecer el predicado igualdad en los axiomas anteriores). Axioma de cierre de dominio

BDD PL hechos >>> reglas hechos reglas ~ relaciones de D: - básicas - derivadas predicados de P lenguaje libre de funciones no hechos y reglas son independientes del dominio no tiempo de acceso a los datos tiempo del sistema de inferencia eficiencia º eficiencia º

Bases de Datos Deductivas
1. Lógica y Bases de Datos: introducción. 2. Bases de datos deductivas: definición y formalización. 3. Actualización de vistas. 3.1. Introducción al problema 3.2. Estudio avanzado del problema 4. Comprobación de restricciones de integridad en esquemas con vistas 4.1 Introducción al problema 4.2 Estudio avanzado del problema 5. SGBD deductivos. 5.1. Evaluación de consultas 5.2. SQL3

3. Actualización de vistas
3.1 Introducción al problema. Actualización sobre relación derivada Actualización(es) sobre relación(es) básicas(s) “Dada una base de datos D (D=BDI È BDE) y un requisito de actualización insertar (A) (resp. borrar (A)) donde A es una tupla de una relación derivada, encontrar una transacción T sobre EDB tal que T(D) satisfaga el requerimiento de actualización” Ejemplo: DELETE FROM PRECIOS_EXT WHERE codprov=pv1 24

T1={borrar (PROV (pv1,Juan,1))} T2={borrar (PIEZA (pz3,tuerca,11),
PRECIOS_EXT PRECIOS PROV T1={borrar (PROV (pv1,Juan,1))} T2={borrar (PIEZA (pz3,tuerca,11), borrar (PIEZA (pz8,arandela,8))} T3={borrar (PRECIOS (pv1,pz3,10), borrar (PRECIOS (pv1,pz8,20))} 25

Métodos para la actualización de bases de datos deductivas Utilización de los procedimientos de evaluación de consultas para determinar los posibles caminos de derivación del conocimiento que se desea a actualizar 26

SLDNF: ¬ precios_ext (pv1, x1, x2, x3, x4)
¬ prov (pv1, x1, x5) Ù pieza (x2,x3,x6) Ù precios (pv1,x2,x4) T1 prov(pv1,Juan,1) x1 / Juan ¬ pieza (x2,x3,x6) Ù precios (pv1,x2,x4) pieza(pz3,tuerca,11) pieza(pz8,arandela,8) T2 T2 x2 / pz3, x3 / tuerca x2 / pz8, x3 / arandela ¬ precios (pv1,pz3,x4) ¬ precios (pv1,pz8,x4) precios(pv1,pz3.10) precios(pv1,pz8,20) T3 T3 x4/ 10 x4/ 20

BDD: 1. q(x)  ¬r(x)  p(x) 2. q(x)  s(x) p(a) Act: borrar(q(a)) ¬ q(a) 1 2 resolución ¬ ¬ r(a)  p(a) ¬ s(a) ¬ r(a) NF ¬ p(a) T1 = { insertar (r(a)) } T2 = { borrar (p(a)) } p(a) resolución

Act: insertar(p(a)) BDD: 1. p(x) ¬ ¬q(x) Ù f(x) 2. p(x) ¬ s(x) Ù n(x) 3. s(x) ¬ r(x) 4. s(x) ¬ t(x) Ù ¬m(x) r(a), q(a), m(a)  p(a) 1 2 resolución  ¬q(a)  f(a)  s(a)  n(a) 3 4 resolución  t(a)  ¬m(a)  n(a)  r(a)  n(a) r(a) resolución T1= {insertar (f(a)), borrar (q(a))} T2 = {insertar (t(a)), borrar (m(a)), insertar (n(a))} T3 = {insertar (n(a))}  n(a)

Procedimientos de borrado e inserción de una tupla de una relación derivada: Hipótesis: - reglas deductivas sin recursión (BDD jerárquicas) - procedimiento de evaluación: SLDNF - regla de selección de literales en un paso de derivación: seleccionar primero los literales derivados positivos y sólo seleccionar un literal negativo cuando es base. Características: - sólo actualizan la base de datos explícita - procedimientos recursivos (se llaman mutuamente)

Procedimiento de borrado: Borrado (D, A, )
Entrada: una base de datos D y un requisito de borrado borrar(A) donde A es una tupla de una relación derivada Salida: un conjunto de transacciones  Inicio t:= un árbol SLDNF para D  {  A}  := { [T1, ..., Tn ]: (debe existir un Ti por cada rama de éxito del árbol t) Ti = borrar(C) donde C es un hecho de D utilizado como cláusula de entrada en una rama de éxito de t o Ti = insertar(B) tal que B es básico y ¬B tiene éxito en una rama no fallada de t Ti   tal que ¬B tiene éxito en una rama no fallada de t, B es derivado y  es la salida de la llamada al procedimiento de inserción con argumentos de entrada D y B } Fin

Procedimiento de inserción: Inserción (D, A, )
Entrada: una base de datos D y un requisito de inserción insertar(A) donde A es una tupla de una relación derivada Salida: un conjunto de transacciones  Inicio  := { [T1, ..., Tn ]: r:= una rama (derivación*) SLDNF fallada para D  {  A}  L1  ...  Ln es el objetivo que falla en r, Li (i=1.. n) es base** Ti = insertar (B) si Li = B y B es básico (hecho) y B  D o Ti = borrar(B) si Li = ¬ B y B es básico (hecho) y B  D Ti   si Li = ¬ B y B es derivado y  es la salida de la llamada al procedimiento de borrado con argumentos de entrada D y B } Fin * seleccionar primero los literales derivados positivos y sólo seleccionar un literal negativo cuando es base (los literales se pueden seleccionar en cualquier orden) ** se deben buscar las derivaciones que cumplan esta propiedad porque a partir de ellas se pueden encontrar transacciones

g1= {insertar(t(a))} g2= {borrar(r(a))} ¬¬q(a) Ù f(a) ¬¬m(a) Ù n(a)
¬ p(a) Act: insertar (p(a)) BDD: 1. p(x) ¬ ¬q(x) Ù f(x) 2. p(x) ¬ ¬m(x) Ù n(x) 3. q(x) ¬ r(x) Ù ¬t(x) r(a), m(a) 1 2 resolución ¬¬q(a) Ù f(a) ¬¬m(a) Ù n(a) T1={borrar(m(a)), insertar(n(a))} ¬ q(a) 3 T1 = {borrar (r(a)), insertar (f(a))} T2 = {insertar (t(a)), insertar (f(a))} resolución ¬r(a) Ù ¬t(a) r(a) resolución ¬ ¬t(a) g1= {insertar(t(a))} g2= {borrar(r(a))} borrar(q(a)) NF

Enunciado del problema:
3. Actualización de vistas 3.2 Estudio avanzado del problema. Enunciado del problema: Dados el esquema (L,RI) de una base de datos deductiva, un estado de base de datos D de ese esquema tal que W  RI se cumple que D satisface W, y dado un requisito de actualización U tal que U no es cierto en D entonces encontrar una transacción T tal que W  RI, D’ = T(D) satisface W y U es cierto en D’.

Ejemplo 1 3. Actualización de vistas 1. p(x)  q(x)  t(x)
2. p(x)  w(x)  v(x) 3. t(x)  s(x)  ¬r(x) Actualización: U = p(1) 1) {w(1), v(1)} Í BDE 2) {q(1), s(1)} Í BDE y {r(1)}  BDE 3) {p(1)} Í BDE 4) {q(1), t(1)} Í BDE Obtener transacciones que aseguren una de estas cuatro situaciones

Caracterización del problema:
3. Actualización de vistas Caracterización del problema: Tiempo de generación de la solución. Variables cuantificadas existencialmente Recursividad Información asumida Tratamiento de restricciones de integridad

1) Tiempo de generación de la solución.
3. Actualización de vistas 1) Tiempo de generación de la solución. Tiempo de ejecución: el árbol de derivación para el requisito de actualización se genera cuando la actualización es solicitada. Tiempo de definición: el árbol de derivación para un requisito de actualización se estudia cuando se define el esquema de la base de datos, lo que supone una mejora ya que determinadas tareas sólo se realizan una vez. Mixto: en este caso una parte de la solución se genera en tiempo de definición del esquema y se completa en tiempo de ejecución.

En el Ejemplo 1: un método que obtuviese la solución en tiempo de ejecución estudiaría el árbol de derivación de la actualización p(1) para encontrar una solución. un método que trabajase en tiempo de definición del esquema estudiaría el requisito genérico p(x) para obtener soluciones que luego se instanciarían en tiempo de ejecución.

x1 ¼xi-1 xi+1 ¼ xm (A  $xi (L1 Ù ¼ Ù Ln))
3. Actualización de vistas 2) Variables existencialmente cuantificadas. Dada una regla deductiva de una base de datos normal, a las variables que aparecen en el cuerpo de la regla y no aparecen en la cabeza se les denomina variables existencialmente cuantificadas. x1 ¼xi ¼xm (A  L1 Ù  Ù Ln)  (xi no aparece en A) x1 ¼xi-1 xi+1 ¼ xm (A  $xi (L1 Ù ¼ Ù Ln)) La presencia de variables existencialmente cuantificadas en las reglas deductivas puede provocar la aparición del problema llamado falta de valores durante la generación de las transacciones que resuelven un requisito de actualización.

BDD: 1. p(x)  q(x,y)  t(x,y) …. t(1,2) Ejemplo 2: ¬ p(1) Actualización: U = p(1). 1 resolución ¬ q(1,y)  t(1,y) $y (q(1,y) Ù t(1,y)) {y/--} Una solución sencilla a este problema consiste en utilizar el valor nulo para la variable de la que se desconoce el valor o bien un valor cualquiera proporcionado por el usuario o extraído sin criterio de la base de datos. Aunque en ocasiones esta solución es la única posible, en otras se puede elegir un valor tal que la transacción obtenida sea más sencilla.

BDD: 1. p(x)  q(x,y)  t(x,y) …. t(1,2) Ejemplo 2: ¬ p(1) Actualización: U = p(1). 1 resolución ¬ q(1,y)  t(1,y) $y (q(1,y) Ù t(1,y)) {y/ nulo} {y/ c} {y/ 2} Sea la base de datos del Ejemplo 2 y considérese que el hecho t(1,2) forma parte de BDE. Si se considera la solución trivial, para el requisito de actualización p(1) se generaría una transacción con las operaciones {insertar(q(1,?)), insertar(t(1,?))} donde el símbolo ? representa el valor nulo o con las operaciones {insertar(q(1,c)), insertar(t(1,c))} donde "c" es una constante cualquiera. Sin embargo es fácil darse cuenta de que la transacción más evidente es {insertar(q(1,2))} que puede obtenerse si se busca en la base de datos un valor para la variable "y" con criterios apropiados. T1 = { insertar(q(1,nulo)), insertar(t(1,nulo))} T2 = { insertar(q(1, c)), insertar(t(1, c))} T3 = { insertar(q(1,2))}

3) Recursividad. 3. Actualización de vistas
La presencia de reglas recursivas en la base de datos puede complicar la generación de la transacción, ya que el árbol de derivación puede ser infinito para un determinado requisito de actualización, lo que supone la existencia de infinitas transacciones posibles para satisfacerlo.

Ejemplo 3: BDD: 1. p(x,y)  q(x,y) 2. p(x,y)  q(x,z)  p(z,y) Actualización: U = p(1,1). Para satisfacer este requisito hay infinitas transacciones posibles: T1: {insertar(q(1,1))} T2: {insertar(q(1,2)), insertar(q(2,1))} T3: {insertar(q(1,2)), insertar(q(2,3)), insertar(q(3,1))} …

4) Problema de la información asumida.
3. Actualización de vistas 4) Problema de la información asumida. En presencia de negación en las reglas deductivas, es posible que algunas soluciones que podrían parecer correctas no lo sean, ya que alguna información que se ha supuesto cierta (resp. falsa), durante la construcción de la solución pase a ser falsa (resp. cierta) debido a las actualizaciones propuestas más adelante.

BDD: 1. p(x)  r(x,y) Ù Ø s(x,y) Ù q(x,y) 2. s(1,2)  q(1,2) r(1,2) Ejemplo 4: ¬ p(1) Actualización: U = p(1). 1 resolución $y (r(1,y) Ù Ø s(1,y) Ù q(1,y)) ¬ r(1,2)  ¬ s(1,2)  q(1,2) ¬ r(1,y)  ¬ s(1,y)  q(1,y) {y/2} r(1,2)  BDE s(1,2) fallo finito q(1,2)  BDE T1 = { insertar( q(1,2)) } ¬ s(1,2) ¬ s(1,2) T1 no es una solución correcta porque induce la inserción de s(1,2) que se había asumido falsa en la construcción de la solución. 2 2 resolución resolución Una transacción correcta sería por ejemplo {insertar(r(1,3)), insertar(q(1, 3))}. ¬q(1,2) ¬q(1,2) q(1,2) resolución

5) Tratamiento de las restricciones de integridad.
3. Actualización de vistas 5) Tratamiento de las restricciones de integridad. La solución propuesta para un requisito de actualización puede suponer la violación de alguna restricción de integridad por lo que es interesante estudiar cómo integra cada método, si lo hace, su estrategia con la comprobación de las restricciones del esquema.

T1= { insertar(q(1)), insertar(r(1)) }
3. Actualización de vistas Ejemplo 5: BDD: 1. p(x)  q(x) Ù r(x) … W = x (r(x)  t(x)) ¬ p(1) 1 resolución Actualización: U = p(1). ¬ q(x)  r(x) T1= { insertar(q(1)), insertar(r(1)) } T1 no es una solución correcta porque el estado T1(BDD) viola la restricción de integridad W Un método que integre la generación de las soluciones con la restauración de la integridad podría generar la transacción {insertar(q(1)), insertar(r(1)), insertar(t(1))}.

Estudio de un método de actualización: 1. Semántica asumida: la semántica declarativa determina el conjunto de posibles soluciones al requisito de actualización y la semántica operacional constituye la herramienta para computar esas soluciones. 2. Bases de datos: tipo de bases de datos y de restricciones de integridad para los que está definido el método. 3. Requisitos de actualización: forma sintáctica de los requisitos de actualización permitidos en el método. 4. Transacciones generadas: tipo de soluciones obtenidas y si sólo se obtiene una o todas las soluciones posibles. 5. Descripción del método: estrategia seguida para generar las transacciones. 6. Corrección y completitud del método. 7. Resumen: cómo el método resuelve los problemas antes mencionados.

Métodos: 3. Actualización de vistas Método de Kakas y Mancarella
Método de Guessoum y Lloyd

Método de Kakas y Mancarella
Este método se basa en el procedimiento de abducción de Eshghi y Kowalski definido en [EK89]. Semántica asumida. semántica declarativa: modelo estable [GL88]. semántica operacional: procedimiento de abducción de Eshghi y Kowalski. Bases de datos. bases de datos localmente estratificadas sin restricciones de integridad específicas. [KM90] Kakas, A. C.; Mancarella, P. Database updates through abduction. Proc. 16th International Conference on Very Large Databases, 1990, págs [EK89] Eshghi, K.; Kowalski, R.A. Abduction compared with negation by failure. Proc. 6th International Conference on Logic Programming, MIT Press, 1989.

Marco Abductivo: Debido a la semántica operacional asumida, la base de datos se traduce a un marco abductivo. Dado un estado de base de datos D = BDE È BDI, el marco abductivo asociado con D es < BDI*, Ab, RI* > donde: BDI* es el conjunto de reglas deductivas obtenido a partir de BDI, reemplazando cada literal negativo Øq( ) por un nuevo literal positivo q*( ). Ab está formado por el conjunto de símbolos de predicados básicos junto con un nuevo predicado p* por cada predicado básico o derivado p. Ab es el conjunto de predicados abducibles. Un átomo es abducible si su predicado lo es. RI* es un conjunto de restricciones de integridad tal que para todo conjunto  de hipótesis abducidas sobre predicados de Ab representadas por átomo abducibles, BDI* È D debe satisfacer: RI* = { p() Ù p*() } È { p() Ú p*()} : p es un predicado de la base de datos. (Estas restricciones de integridad definen la equivalencia entre p*() y  p()).

Ejemplo 6: BDI: 1. p(x)  q(x)  ¬ r(x) 2. p(x)  t(x) 3. r(x)  s(x)
Marco abductivo: BDI* = {p(x)  q(x)  r*(x), Ab = {q, s, t, p*, q*, r*, s*, t*} p(x)  t(x), r(x)  s(x)} RI* = {  p(x)  p*(x), p(x)  p*(x),  q(x)  q*(x), q(x)  q*(x),  r(x)  r*(x), r(x)  r*(x),  s(x)  s*(x), s(x)  s*(x),  t(x)  t*(x), t(x)  t*(x) }

Requisitos de actualización. insertar(A) o borrar(A) (A es un átomo derivado base) Transacción generada. conjunto de operaciones de inserción y borrado de hechos.

Descripción del método. Dado un requisito de actualización insertar(p()) (resp. borrar(p())) el método distingue dos etapas: Paso A: Búsqueda de una derivación abductiva para  p() (resp.  p*()). Este paso devuelve un conjunto de hipótesis  tal que: BDI*   implica p() (resp. p*()) y tal que BDI*   es consistente y no viola RI*. Paso B: Obtención de una transacción T sobre BDE tal que el estado T(D) implique cualquier hipótesis en . Dado un átomo L = p() (resp. L = p*()) con la expresión L* se representará al átomo p*() (resp. p()). Una regla de selección R es segura si es una función parcial tal que dado un objetivo  L1  …  Lk (k  1) devuelve un átomo Lj (1  j  k) tal que Lj no es abducible o Lj es abducible y base.

Paso A: Procedimiento de demostración abductivo. El procedimiento abductivo se basa en las definiciones de derivación abductiva y derivación de consistencia.

Derivación abductiva. Una derivación abductiva desde (G1 1) hasta (Gn  n) vía una regla segura R es una secuencia (G1  1), (G2  2), …, (Gn  n) tal que i (1  i  n) Gi tiene la forma  L1  …  Lk,  i es un conjunto de hipótesis abducibles, la regla R selecciona el literal Lj (1  j  k) y (Gi+1  i+1) se obtiene de acuerdo con una de las siguientes reglas: Regla A1: Si Lj no es abducible entonces Gi+1 := C y i+1 :=  i donde C es el resolvente de alguna cláusula de BDI* con Gi sobre el literal Lj. Regla A2: Si Lj es abducible y Lj   i entonces Gi+1 :=  L1  …  Lj-1  Lj+1  …  Lk y  i+1 :=  i. Regla A3: Si Lj es abducible, es básico, Lj   i y Lj*   i entonces Gi+1 :=  L1  …  Lj-1  Lj+1  …  Lk y  i+1 :=  i  {Lj}. Regla A4: Si Lj es abducible, es derivado y Lj   i y hay una derivación de consistencia desde ({ Lj*}  i  Lj) hasta ({ } ’) entonces Gi+1 :=  L1  …  Lj-1  Lj+1  …  Lk y  i+1 := ’.

Derivación de consistencia
Derivación de consistencia. Una derivación de consistencia desde (F1 1) hasta (Fn  n) vía una regla segura R es una secuencia (F1  1), (F2 2), … , (Fn  n) tal que i (1  i  n) Fi tiene la forma {  L1  …  Lk}  Fi’ siendo Fi’ un conjunto de objetivos,  i es un conjunto de hipótesis abducibles, la regla R selecciona el literal Lj (1  j  k) y (Fi+1  i+1) se obtiene de acuerdo con una de las siguientes reglas: Regla C1: Si Lj no es abducible entonces Fi+1 := C  Fi’ donde C es el conjunto de todos los resolventes de cláusulas de BDI* con  L1  …  Lk sobre el literal Lj, [ ]  C y  i+1 :=  i. Regla C2: Si Lj es abducible, Lj   i y k > 1 entonces Fi+1 := {  L1  …  Lj-1  Lj+1  …  Lk}  Fi’ y  i+1 :=  i. Regla C3: Si Lj es abducible y Lj*   i entonces Fi+1 := Fi’ y  i+1 :=  i. Regla C4: Si Lj es abducible, es básico, Lj   i y Lj*   i entonces Fi+1 := Fi’ y i+1 :=  i  {Lj*}. Regla C5: Si Lj es abducible, no es básico y existe una derivación abductiva desde ( Lj*  i) hasta ([ ] ’) entonces Fi+1 := Fi’ y  i+1 := ’.

Ejemplo 6: BDI: 1. p(x)  q(x)  ¬ r(x) Actualización: U = insertar(p(1)) 2. p(x)  t(x) 3. r(x)  s(x) Marco abductivo: BDI* = {p(x)  q(x)  r*(x), Ab = {q, s, t, p*, q*, r*, s*, t*} p(x)  t(x), r(x)  s(x)} RI* = {  p(x)  p*(x), p(x)  p*(x),  q(x)  q*(x), q(x)  q*(x),  r(x)  r*(x), r(x)  r*(x),  s(x)  s*(x), s(x)  s*(x),  t(x)  t*(x), t(x)  t*(x) }

Ejemplo 6: BDI: 1. p(x)  q(x)  ¬ r(x) Actualización: U = borrar(p(1)) 2. p(x)  t(x) 3. r(x)  s(x) Marco abductivo: BDI* = {p(x)  q(x)  r*(x), Ab = {q, s, t, p*, q*, r*, s*, t*} p(x)  t(x), r(x)  s(x)} RI* = {  p(x)  p*(x), p(x)  p*(x),  q(x)  q*(x), q(x)  q*(x),  r(x)  r*(x), r(x)  r*(x),  s(x)  s*(x), s(x)  s*(x),  t(x)  t*(x), t(x)  t*(x) }

Paso B: Obtención de una transacción. Sea  un conjunto de hipótesis generadas por el procedimiento abductivo, T es una transacción asociada a  si dado un estado D, para cada átomo abducido básico L   (resp. L*   ), D’ |= L (resp. D’ |= ¬L) donde D’ es el estado de base de datos obtenido al aplicar T a D.

Ejemplo 6: BDI: 1. p(x)  q(x)  ¬ r(x) Actualización: U = insertar(p(1)) 2. p(x)  t(x) 3. r(x)  s(x) Marco abductivo: BDI* = {p(x)  q(x)  r*(x), Ab = {q, s, t, p*, q*, r*, s*, t*} p(x)  t(x), r(x)  s(x)} RI* = {  p(x)  p*(x), p(x)  p*(x),  q(x)  q*(x), q(x)  q*(x),  r(x)  r*(x), r(x)  r*(x),  s(x)  s*(x), s(x)  s*(x),  t(x)  t*(x), t(x)  t*(x) }

BDE: s(1)  T1 = { insertar(t(1)) }  T2= {insertar(q(1)), borrar(s(1))}

Ejemplo 6: BDI: 1. p(x)  q(x)  ¬ r(x) Actualización: U = borrar(p(1)) 2. p(x)  t(x) 3. r(x)  s(x) Marco abductivo: BDI* = {p(x)  q(x)  r*(x), Ab = {q, s, t, p*, q*, r*, s*, t*} p(x)  t(x), r(x)  s(x)} RI* = {  p(x)  p*(x), p(x)  p*(x),  q(x)  q*(x), q(x)  q*(x),  r(x)  r*(x), r(x)  r*(x),  s(x)  s*(x), s(x)  s*(x),  t(x)  t*(x), t(x)  t*(x) }

BDE: q(1) t(1)  T3= {borrar(q(1)), borrar(t(1))}  T4= {insertar(s(1)), borrar(t(1))}

Corrección y completitud. Corrección: Sea D una base de datos localmente estratificada, U un requisito insertar(L) (resp. borrar(L)). Si hay una derivación abductiva desde (L {}) (resp. (L* {})) hasta ([] ) entonces para cualquier base de datos extensional se cumple que |=MD’ L (resp. |=MD’ ¬L) donde D’ es el estado de base de datos obtenido al aplicar a D una transacción asociada a D y MD’ es el modelo estable de D’. Completitud: Sea D = BDI  BDE un estado de base de datos cuya parte intensional cumple las propiedades de ser acíclica y de no tener variables existencialmente cuantificadas, U un requisito insertar(L) (resp. borrar(L)). Si existe una parte extensional BDE’ tal que |=MD’L (resp. |=MD’¬L) donde D’ = BDI  BDE’ y MD’ es el modelo estable de D’ entonces hay una derivación abductiva desde ( L {}) (resp. ( L* {})) hasta ([] ) tal que L’  BDE’ (resp. L’  BDE’) para cada átomo abducible básico L’   (resp. L’*  ).

Resumen: Los requisitos de actualización sólo pueden ser inserciones o borrados de tuplas base sobre predicados derivados no admitiendo requisitos más generales. Obtiene las soluciones (conjunto ) en tiempo de ejecución pero sin acceder al conjunto de hechos. Debido a la regla de selección segura que utiliza el método, no se pueden elegir en las derivaciones las reglas deductivas con variables existencialmente cuantificadas por lo que no se aporta solución al problema de falta de valores. Debido al problema anterior, el método no puede tratar con reglas recursivas. En el caso de predicados derivados definidos recursivamente sólo se consideraría las reglas que definen el caso base encontrándose soluciones sólo en el caso de requisitos de inserción. En [KM90] se comenta que el método puede extenderse fácilmente para comprobar las restricciones de integridad durante el paso de obtención de las hipótesis El problema de la información asumida es controlado por el método en la regla A3 de la derivación abductiva y en la regla C4 de la derivación de consistencia ya que en ellas la abducción de un literal se realiza tras comprobar que su complementario no pertenece ya al conjunto de hipótesis.

Método de Guessoum y Lloyd
Semántica asumida. semántica declarativa: la compleción. semántica operacional: procedimiento SLDNF Base de Datos. bases de datos localmente consistentes en llamada el conjunto de predicados básicos y el conjunto de predicados derivados pueden no ser disjuntos. las restricciones de integridad se representan por fórmulas cerradas bien formadas. [GL90] Guessoum, A.; Lloyd, J. W. Updating knowledge bases. New Generation Computing, Vol. 8, 1990, págs [GL91] Guessoum, A.; Lloyd, J. W. Updating knowledge bases II. New Generation Computing, Vol. 10, 1991, págs

Requisito de actualización. insertar(A) (resp. borrar(A)) (A es un átomo). Transacción generada. inserción y borrado de hechos y reglas deductivas En el caso de la inserción de reglas deductivas, éstas sólo pueden ser de la forma A , donde A es un átomo que no es base (esto significa que se admite la inserción de reglas deductivas dependientes del dominio). Así pues la transacción obtenida es un conjunto de operaciones de la forma insertar(C) donde C es un átomo que, si es base es un hecho y si no lo es representa una regla deductiva sin cuerpo, o de la forma borrar(C) donde C es una sentencia de base de datos (hecho o regla deductiva).

Descripción del método.
Método de Guessoum y Lloyd Descripción del método. El método de actualización se basa en los procedimientos: Borrado Inserción que utilizan a su vez los procedimientos básicos: Borrado-Básico Inserción-Básica que se llaman recursivamente entre sí. En estos procedimientos, que se presentan a continuación, se utiliza el concepto de árbol SLDNF trivial que es aquél que sólo consta del nodo raíz.

ALGORITMO Borrado ENTRADA D: Estado de base de datos;
U = borrar(A) : Requisito de actualización de borrado; RI: Conjunto de restricciones de integridad; SALIDA:  : Conjunto de transacciones; INICIO SI comp(D) |= A ENTONCES Borrado_Básico (D, A, t0); t := {T : T  t0, comp(T(D)) |¹ A y T(D) satisface RI} FIN_SI FIN.

ALGORITMO Borrado_Básico
ENTRADA D: Estado de base de datos; A: átomo; SALIDA: t0: Conjunto de transacciones; INICIO t := árbol SLDNF finito que no sea trivial para D È {  A}; t0 := {[T1, ¼ , Tn] : existe un Ti (no necesariamente distinto) para cada rama que no sea fallada de t, tal que Ti = borrar(Ci) donde Ci es una sentencia de D utilizada como cláusula de entrada en una rama no fallada de t o Ti  ti tal que ØB tiene éxito en una rama no fallada de t y ti es la salida de la llamada al procedimiento de Inserción_Básica con argumentos de entrada D y B} FIN.

ALGORITMO Inserción ENTRADA D: Estado de base de datos;
U = insertar(A) : Requisito de actualización de inserción; RI: Conjunto de restricciones de integridad; SALIDA t : Conjunto de transacciones; INICIO SI comp(D) |¹ A ENTONCES} Inserción_Básica(D, A, t0); t := {T|T t0, comp(T(D)) |= A y T(D) satisface RI} FIN.

ALGORITMO Inserción_Básica
ENTRADA D: Estado de base de datos; A: átomo; SALIDA t0: Conjunto de transacciones; INICIO t := un árbol SLDNF finito para D È {  A}; t0 := {[T1, ¼ , Tn] :  L1, ¼ , Ln es un objetivo en t tal que Li es base si es negativo y, o Ti = insertar(Ai) si Li = Ai (donde Ai es un átomo) Ti  ti si Li = ØBi (donde Bi es un átomo) y ti es la salida de la llamada al procedimiento Borrado_Básico con argumentos de entrada D y Bi} FIN.

Ejemplo 7: BDI: 1. p(x)  q(x)  ¬ r(x) Actualización: U = insertar(p(1)) 2. p(x)  t(x) 3. r(x)  s(x) s(1) El procedimiento Inserción llama al procedimiento Inserción_Básica tras comprobar que p(1) no es consecuencia lógica de comp(D) ; supóngase que este procedimiento construye el árbol SLDNF que se muestra a continuación.

Inserción_Básica  p(1)  T1 = {insertar(p(1))}
 t(1)  T2 = {insertar(t(1))}  q(1)  r(1)  T3 = {insertar(q(1)), borrar(r(x)  s(x))}  q(1)   r(1)  T4 = {insertar(q(1)), borrar(s(1))} En las transacciones T3 y T4 la segunda operación se obtiene de la salida del procedimiento Borrado_Básico con el átomo de entrada r(1) que estudia el siguiente árbol SLDNF.

Borrado-Básico T1’ = { borrar (r(x)  s(x)) } T2’ = { borrar (s(1)) }

Ejemplo 8: BDI: 1. p(x)  q(x)  ¬ r(x) Actualización: U = borrar(p(1)) 2. p(x)  t(x) 3. r(x)  s(x) q(1) t(1) El procedimiento Borrado llama al procedimiento Borrado_básico tras comprobar que comp(D) |= p(1); supóngase que este procedimiento construye el árbol SLDNF que se muestra a continuación.

Borrado_Básico T1 = {borrar(p(x)  q(x)  ¬r(x)), borrar(p(x)  t(x)) } T5 = { insertar(r(1)), borrar(p(x)  t(x)) } T2 = {borrar(p(x)  q(x)  ¬ r(x)), borrar(t(1)) } T6 = { insertar(r(1)), borrar(t(1)) } T3 = {borrar(q(1)), borrar(p(x)  t(x)) } T7 = { insertar(s(1)), borrar(p(x)  t(x)) } T4 = {borrar(q(1)), borrar(t(1)) } T8 = { insertar(s(1)), borrar(t(1)) }

Inserción_Básica T1’ = { insertar (r(1)) } T2’ = { insertar (s(1)) }

Corrección y completitud.
Método de Guessoum y Lloyd Corrección y completitud. Corrección del procedimiento de inserción: Sea D una base de datos normal localmente consistente en llamada, A un átomo y RI un conjunto de restricciones de integridad tal que comp(D) |= A y tal que D satisface RI. Sea T una transacción del conjunto t que es la salida de la llamada al procedimiento Inserción con parámetros de entrada (D, insertar(A), RI) entonces se cumple comp(T(D)) |= A. Corrección del procedimiento de borrado: Sea D una base de datos normal localmente consistente en llamada, A un átomo y RI un conjunto de restricciones de integridad tal que comp(D) |= A y tal que D satisface RI. Sea T una transacción del conjunto t que es la salida de la llamada al procedimiento Borrado con parámetros de entrada (D, borrar(A), RI) entonces se cumple comp(T(D)) ) |= A.

Resumen. Las soluciones obtenidas ante un requisito de actualización dependen del árbol SLDNF obtenido en el primer paso del algoritmo Inserción_Básica o del algoritmo Borrado_Básico siendo necesario para obtener todas las soluciones la ejecución del mismo para cada uno de los posibles árboles El problema de la falta de valores no se resuelve con la elección de valores para las variables existencialmente cuantificadas sino al permitir la inserción de reglas deductivas sin cuerpo (que no cumplen, por lo tanto, la propiedad de ser independientes del dominio). La corrección de una transacción T obtenida para el requisito de actualización insertar(A) (resp. borrar(A)) se comprueba en la última instrucción de los algoritmos Inserción (resp. Borrado) cuando verifica que comp(T(D)) |= A (resp. comp(T(D)) |= A), también en este momento se comprueba si se satisfacen las restricciones de integridad. Esta verificación es muy costosa ya que en general se realizan tantos accesos a la base de datos extensional como accesos se hayan realizado en la generación de la solución.

4. Comprobación de restricciones de integridad
4.1 Introducción al problema Restricción de integridad: propiedad del mundo real que una base de datos debe satisfacer en cualquier instante para ser consistente con cierto modelo del mundo real. Evolución de una BD D0 T1 D1 Ti Di Tn Dn Restricciones estáticas: hacen referencia a un único estado de la base de datos. Estas restricciones restringen los estados válidos con independencia de la secuencia de los mismos. Restricciones dinámicas: hacen referencia a dos o más estados de la base de datos. Estas restricciones restringen las secuencias de estados válidas. Un caso particular de restricciones dinámicas son las restricciones de transición que restringen dos estados consecutivos válidos.

Comprobación de la integridad: la comprobación de la integridad en bases de datos consiste en comprobar si el par de estados (D,D') implicados en una transacción T satisface las restricciones de transición y si el estado final D' satisface las restricciones estáticas. Método de comprobación de la integridad: es un procedimiento de decisión tal que, dado un estado D y una restricción de integridad estática W, decide con una respuesta binaria si/no si el estado D satisface/viola la restricción W.

La forma más sencilla de comprobar las restricciones estáticas es evaluar cada una de ellas después de la transacción; sin embargo esta aproximación puede ser muy costosa en bases de datos voluminosas. La comprobación de la integridad podría simplificarse si consideráramos sólo los "cambios" que la transacción ha producido en la base de datos. Todos los métodos propuestos para simplificar la comprobación de la integridad suponen que la base de datos era íntegra antes de la transacción. Apoyándose en esta hipótesis, los métodos comprueban sólo instancias de las restricciones generadas a partir de las actualizaciones (inserciones y borrados) de la transacción, evitando comprobar instancias que ya se satisfacían antes de la transacción y que además no se ven afectadas por ésta.

Comprobación simplificada de la integridad en bases de datos relacionales: PRECIOS (codprov: D4, codpieza: D1, precio: D7) CP = {codprov, codpieza} CAj = {codprov} ® PROV CAj = {codpieza} ® PIEZA W: "x "y "z ( (precios(x, y, z) ® $w $t (prov(x,w,t)) ) T = { insertar (PRECIOS (pv11,pz3,100)) } D T D’ Si D es un estado íntegro entonces D’ satisface W si y sólo si D’ satisface $w $t (prov (pv11,w,t) )

Comprobación simplificada de la integridad en bases de datos relacionales: Paso 1: detectar restricciones de integridad relevantes para la transacción Paso 2: obtener instancias simplificadas de las restricciones de integridad relevantes para la transacción Paso 3: simplificar las instancias de las restricciones de integridad relevantes para la transacción Paso 4: evaluar las instancias simplificadas de las restricciones de integridad relevantes en el nuevo estado

Paso 1: detectar restricciones de integridad relevantes para la transacción: W: "x "y "z ( (precios(x, y, z) ® $w $t ( prov(x, w, t)) ) insertar (PRECIOS (-, -,-)) borrar (PROV (-, -,-)) Paso 2: obtener instancias de las restricciones de integridad relevantes para la transacción W: "x "y "z ( (precios(x, y, z) ® $w $t (prov(x, w, t)) ) insertar (PRECIOS (pv11, pz3,100)) W’: (precios (pv11, pz3,100) ® $w $t (prov (pv11, w, t))

Paso 3: simplificar las instancias de las restricciones relevantes W’’: $w $t (prov (pv11, w, t)) Paso 4: evaluar las instancias simplificadas de las restricciones de integridad relevantes en el nuevo estado Teorema de simplificación D’ satisface W si y sólo si D’ satisface W’’ $w $t (prov (pv11, w, t) es falso en D’ D’ viola W

Comprobación simplificada de la integridad en bases de datos deductivas: Las actualizaciones generadas por una transacción no son sólo las explícitamente requeridas por ésta (operaciones que la componen) sino también todas las actualizaciones que se pueden inducir por la presencia de reglas deductivas en la base de datos.

Comprobación simplificada de la integridad en bases de datos deductivas: Paso 1: determinar el conjunto de actualizaciones inducidas por la transacción: Act Paso 2: detectar restricciones de integridad relevantes respecto al conjunto de actualizaciones Act Paso 3: obtener instancias de las restricciones de integridad relevantes Paso 4: simplificar las instancias de las restricciones de integridad relevantes Paso 5: evaluar las instancias simplificadas de las restricciones de integridad relevantes en el nuevo estado

Paso 1 Reglas deductivas:
COMP COMPONENTE Reglas deductivas: COMPONENTE COMPONENTE (x, y) ¬ COMP (x,z) ÙCOMPONENTE (z, y) COMPONENTE (x, y) ¬ COMP (x, y) Transacción: {insertar (COMP(pz8,pz1))} COMP Paso 1

Restricción de integridad: W: "x "y ( COMPONENTE (x,y) ® Ø COMPONENTE (y,x) ) Paso 2 insertar (COMPONENTE(pz8,pz1)) Paso 3 W’: COMPONENTE (pz8, pz1) ® Ø COMPONENTE (pz1, pz8) Paso 4 W’’: Ø COMPONENTE (pz1, pz8) Paso 5 Ø COMPONENTE (pz1, pz8) es falso en D’ D’ viola W

4.2 Estudio avanzado del problema Enunciado del problema Método de simplificación de Nicolas para base de datos relacionales Concepto de satisfacción Corrección y completitud de un método de simplificación Fases en la comprobación simplificada de la integridad Métodos de comprobación simplificada en bases de datos deductivas: Estudio de un método de simplificación Métodos

Enunciado del problema: Dados: • el esquema (L,RI) de una base de datos deductiva, donde: - L es un lenguaje de primer orden, y - RI es el conjunto de restricciones de integridad, fórmulas cerradas de L. • un estado D de la base de datos: D = {A: A es un átomo base} (hechos)  {A W: A es un átomo y W es una fórmula bien formada} (reglas) tal que D satisface W (para toda W  RI). • una transacción T formada por dos conjuntos de sentencias de base de datos: - Tins: hechos y reglas que van a ser insertados por la transacción y - Tdel: hechos y reglas que van a ser borrados por la transacción. ( Tins  Tdel = , Tdel  D y Tins  D =  ) . • el estado D' resultante de aplicar a D la transacción T: D' = (D  Tins) \ Tdel. Comprobar: D' satisface W (para toda W  RI).

Método de Nicolas para la comprobación simplificada de la integridad en bases de datos relacionales: Dado un estado íntegro D y una transacción T, obtener instancias simplificadas de las restricciones de integridad relevantes para la transacción, que será suficiente comprobar en D‘=T(D) para asegurar su integridad. En el trabajo original de Nicolas, [Nic79], [Nic82], una base de datos relacional se formaliza como una interpretación I de unlenguaje de 1er orden; dicha interpretación se construye a partir de la extensión de la base de datos [NG78]. En esta formalización el concepto de satisfacción utilizado es el siguiente: D satisface W sii |=I W.

Método de Nicolas : Ejemplo: D = { p(1,1), p(2,2) q(1,1,1), q(1,2,2), q(2,1,1), q(1,3,3) } RI = { W1 = x y (p(x,y)  z q(z,x,y)) W2 = z x y (p(x,y)  q(z,x,y)) } T: Tins= {p(3,3)} Tdel={q(2,1,1)}

Método de Nicolas: Restricciones de integridad relevantes para T: Si W es una restricción de integridad de rango restringido [Nic82] (independiente del dominio), podemos afirmar que: "W es relevante respecto a la inserción (resp. borrado) de la tupla <e1,e2,...,en> en R si y sólo si R(e1,e2,...,en) es unificable con un átomo que ocurre negativamente (resp. positivamente) en W". Un átomo A ocurre negativamente (resp. positivamente) en una fórmula W sii ¬A (resp. A) aparece en la forma prenexa normal de W. Ejemplo: W1 y W2 son relevantes respecto a las dos operaciones de la transacción.

Método de Nicolas: Instancias de las restricciones de integridad: Sea: • W una restricción de integridad relevante respecto a la inserción (resp. borrado) de <e1,e2,...,en> en R. •  el unificador más general que unifica R(e1,e2,...,en) con un átomo que ocurre negativamente (resp. positivamente) en W. •  la restricción de  a aquellas variables cuantificadas universalmente no precedidas de un cuantificador existencial. Entonces, definimos una instancia de W generada por la inserción (resp. borrado) de <e1,e2,...en > en R como la fórmula W.

Método de Nicolas: Ejemplo: a) La sustitución  no debe aplicarse a las variables cuantificadas existencialmente. La operación borrar(q(2,1,1)) genera una instancia de W1:  = {z/2, x/1, y/1} W1 = p(1,1)  q(2,1,1). D' no satisface W1. y sin embargo D' satisface W1. b) La sustitución  no debe aplicarse a las variables cuantificadas universalmente precedidas de un cuantificador existencial. La operación borrar(q(2,1,1)) genera una instancia de W2:  = {z/2, x/1, y/1} W2 = p(1,1)  q(2,1,1). D' no satisface W2 y sin embargo D' satisface W2. En nuestro ejemplo las instancias de las restricciones generadas por la transacción son: Para W1: insertar(p(3,3)): 1= {x/3, y/3}, W11= p(3,3) z q(z,3,3) borrar(q(2,1,1)): 2 = {x/1, y/1}, W12 = p(1,1) z q(z,1,1). Para W2: W2 es relevante para la transacción pero no se generan instancias de ella.

Método de Nicolas: Simplificación de las instancias: Las instancias de W pueden simplificarse reemplazando las ocurrencias de R(e1,e2,...,en) por el valor cierto (resp. falso) si la transacción ha insertado (resp. borrado) la tupla <e1,e2,...,en> en R y aplicando reglas de absorción. Ejemplo: (W1 1)s = z q(z,3,3) (W1 2)s = p(1,1) z q(z,1,1).

Método de Nicolas: Comprobación de la integridad (método de Nicolas): RI = { W1 = x  y (p(x,y)  z q(z,x,y)) W2 = z  x  y (p(x,y)  q(z,x,y)) }. W1s=(W1 1)s  (W1 2)s = z q(z,3,3)  (p(1,1)  z q(z,1,1)) D' satisface W1s, entonces D' satisface W1. D' satisface W2.

Concepto de satisfacción: a) Punto de vista de la demostración: D satisface W sii Tr |= W. b) Punto de vista de la consistencia: D satisface W sii Tr  {W} es consistente. El concepto de violación se define en términos del concepto de satisfacción: D viola W sii no (D satisface W). Diremos que un estado D es íntegro si, para toda restricción W perteneciente a RI, D satisface W. Tr es la teoría de 1er orden que representa la base de datos en la semántica asumida

Ejemplo 1: D = { p(a)  q(x)  ¬r(x), q(a), r(x)  r(x) }. Si asumimos la semántica de la compleción: Tr=comp(D) = {y(p(y)  y=a  x(q(x)  ¬r(x))),  x(q(x)  x=a),  x(r(x)  r(x)) }. Desde el punto de vista de la consistencia D satisface: W1=q(a), W2=r(a), W3=p(a), W4=¬r(a). Desde el punto de vista de la demostración D satisface: W1=q(a). Tr es la teoría de 1er orden que representa la base de datos en la semántica asumida

Si asumimos la semántica del punto fijo iterado: MD={q(a), p(a)} Tr(MD) = {x (p(x)  x=a), x (q(x)  x=a), x (r(x) }. D satisface W1=q(a) y W2=p(a) en los dos conceptos de satisfacción. Tr es la teoría de 1er orden que representa la base de datos en la semántica asumida

Fases en la comprobación simplificada de la integridad: Hipótesis: D es íntegro. Comprobación de la integridad: FASE I: Fase de Generación Paso1: Cálculo de conjuntos de literales que “representen” la diferencia entre los estados consecutivos D y D'. Paso 2: Identificación de las restricciones relevantes. Paso 3: Instanciación de las restricciones relevantes. Paso 4: Simplificación de las instancias de las restricciones relevantes. FASE II: Fase de Evaluación Paso 5: Comprobación en D' de las instancias simplificadas de las restricciones relevantes.

Corrección y completitud de un método: Sean: M un método de comprobación de la integridad. D satisfaceM (resp. violaM) W significa que el método M decide que el estado D satisface (resp. viola) la restricción W (WRI). CS el concepto de satisfacción asumido por el método M. D satisfaceCS (resp. violaCS) W significa que el estado D satisface (resp. viola) la restricción W (WRI) en el concepto de satisfacción CS. Un método M es correcto cuando se cumple: si D satisfaceM W entonces D satisfaceCS W (correcto para satisfacción) si D violaM W entonces D violaCS W (correcto para violación). Un método M es completo cuando se cumple: si D satisfaceCS W entonces D satisfaceM W (completo para satisfacción) si D violaCS W entonces D violaM W (completo para violación).

Estudio de un método de simplificación: Semántica asumida. Concepto de satisfacción. 3. Requisitos sintácticos: forma sintáctica de las reglas y de las restricciones de integridad. 4. Corrección y completitud del método. Estrategia del método: Fase de Generación: potencial (sin acceso a la BDE), real (con acceso a la BDE). Intercalación de las fases de Generación y Evaluación. Etapa de compilación independiente de la transacción

Métodos: 4. Comprobación de restricciones de integridad
Método de Lloyd, Sonnenberg y Topor Método de Sadri y Kowalski

Método de Lloyd, Sonnenberg y Topor Concepto de satisfacción Este método utiliza el punto de vista de la demostración con Tr = comp(D)  {ACD}: D satisface W sii Tr |= W.

Actualizaciones potenciales:
Sea T una transacción y D y D' los estados consecutivos relacionados con T tales que DD'; entonces, se definen posD,D' (conjunto de inserciones potenciales) y negD,D' (conjunto de borrados potenciales) inductivamente de la forma siguiente: Po D,D‘ = {A: A← W  D' \D} (inserciones potenciales explícitas) PosD,D‘ n+1 = {A : A ← W  D, B ocurre positivamente en W, C  posD,D‘n y  = mgu(B,C)}  {A : A ← W  D, B ocurre negativamente en W, C  negD,D‘n y  = mgu(B,C)} (inserciones potenciales inducidas) NegD,D‘0 =  (borrados potenciales explícitos) NegD,D‘n+1 = {A : A ← W  D, B ocurre positivamente en W, C  negD,D‘n y  = mgu(B,C)} {A  : A ← W  D, B ocurre negativamente en W, C  posD,D‘n y  = mgu(B,C)} (borrados potenciales inducidos) posD,D‘ = n0 posD,D‘n negD,D‘ = n0 negD,D‘n

Actualizaciones potenciales:
Según la anterior definición, la obtención de los conjuntos posD,D‘ y negD,D‘ podría significar el cálculo de infinitos conjuntos posD,D‘n y negD,D'n . En la práctica, el cálculo puede realizarse en un número finito de pasos si se utiliza alguna regla de parada del tipo siguiente: en lugar de calcular los conjuntos posD,D‘n y negD,D‘n calcular los conjuntos Pn y Nn definidos de la siguiente forma: Pn (resp. Nn) = {A: A  posD,D‘n (resp. NegD,D‘n) y  A'  posD,D‘k (resp. NegD,D‘k) (0  k  n) tal que A es una instancia de A'}. La computación finaliza cuando, para un valor de n, los conjuntos Pn y Nn son vacíos. El conjunto posD,D‘ (resp. negD,D‘) se caracteriza porque cualquier inserción (resp. borrado) real es una instancia de alguno de sus elementos.

Teorema de Simplificación
Sea: • (L,RI) el esquema de una base de datos deductiva, donde: - L es un lenguaje de primer orden heterogéneo. Los conjuntos de símbolos de constante, función y predicado de L son finitos. - RI = {W: W=x1 x2... xn W'} es el conjunto de restricciones de integridad, fórmulas cerradas de L en forma prenexa normal. • D un estado de la base de datos: D = {A← B: A es un átomo, B es una fbf }. • La semántica asumida es la de la compleción más el axioma de cierre de dominio. La teoría que representa el estado D es Tr = comp(D)  {ACD}. Es importante destacar que comp(D) y ACD son las versiones con tipos de la compleción de D y del axioma de cierre de dominio [Llo87]. • T una transacción formada por dos conjuntos de cláusulas: Tdel: borrados de T Tins: inserciones de T. La transacción no es contradictoria (no inserta y borra la misma cláusula) y además no modifica el lenguaje L.

Teorema de Simplificación
Sea: • D'' y D' estados tales que: D'' = D \ Tdel y D' = D''  Tins. • D y D' son estratificadas. • W una restricción de integridad tal que D satisface W. •  = { :  es la restricción a x1,x2,...,xn del unificador más general entre un átomo que ocurre negativamente en W y un átomo de posD'',D‘ o de un átomo que ocurre positivamente en W y un átomo de negD'',D‘ }. •  = {:  es la restricción a x1,x2,...,xn del unificador más general entre un átomo que ocurre positivamente en W y un átomo de posD'',D o de un átomo que ocurre negativamente en W y un átomo de negD'',D }. Se cumple: a) D' satisface W sii D' satisface  (W‘) para todo     . b) Si D'  {← (W‘)} tiene una refutación SLDNF para todo     , entonces D' satisface W. c) Si D'  {← (W‘)} tiene un árbol SLDNF fallado finitamente para algún     , entonces D' viola W. Si    es el conjunto vacío, W no se ve afectada por la transacción. Si      , W no admite simplificación.

Método de Lloyd, Sonnenberg y Topor
Resumen. Semántica asumida: semántica de la compleción. Concepto de satisfacción: punto de vista de la demostración. Tipo de base de datos: las reglas deductivas son cláusulas generales de la forma A W. Restricciones sintácticas: la base de datos debe ser estratificada. Las restricciones de integridad son fórmulas cerradas en forma prenexa normal. Estrategia: Fase de Generación potencial (sin acceso a la BDE).

Método de Sadri y Kowalski Concepto de satisfacción Este método utiliza el punto de vista de la consistencia, con Tr=comp(D) (semántica de la compleción): D satisface W sii Tr  {W} es consistente

Método de Sadri y Kowalski
Actualizaciones de la transacción Sea T= Tins Tdel una transacción formada por dos conjuntos de cláusulas. El conjunto ACT de actualizaciones de la transacción se define: ACT= { A: AL1  L2  ...  Ln  Tins}  {¬A: A  Tdel y existe un árbol SLDNF fallado finitamente para D'  {A}} { ¬A: A L1  L2  ...  Ln Tdel,  es una respuesta computada para D  { L1 L2 ... Ln} y existe un árbol SLDNF fallado finitamente para D'  { A} }.

Procedimiento SLDNF* (SLDNF extendido) Sea: • S = D  RI donde: - D es un conjunto de cláusulas de la forma: A  L1  L2  ...  Ln (n  0) - RI un conjunto de cláusulas de la forma:  L1  L2  …  Ln (n>0) (Li es un literal; si Li es positivo (resp. negativo) le denominaremos condición positiva (resp. condición negativa)). • C0 una cláusula de S o un átomo negado (¬A) tal que existe un árbol SLDNF* fallado finitamente para S  {A}. • R una regla de computación segura.

Procedimiento SLDNF* (SLDNF extendido) Una derivación vía R para S  {C0} es una secuencia posiblemente infinita C0, C1, C2... tal que, Ci (i>0) es una cláusula, y para todo i0, Ci+1 se obtiene a partir de Ci de la siguiente forma: a) Si R selecciona de Ci un literal L que no es una condición negativa de Ci, entonces Ci+1 es el resolvente sobre L de Ci y alguna cláusula de S. b) Si R selecciona una condición negativa ¬A de Ci, entonces Ci+1 es Ci eliminando el literal seleccionado, ¬A, si existe un árbol SLDNF* fallado finitamente para S  {A}. c) Si Ci es ¬A y en S hay una cláusula B¬A‘  C de forma que A y A' unifican a través del unificador más general , entonces Ci+1 es (BC) . El SLDNF* es correcto para consistencia: "Si existe una refutación SLDNF* para S  {C0} entonces comp(D)  RI es inconsistente"

Teorema de simplificación Sea: • (L,RI) el esquema de una base de datos deductiva, donde: - L es un lenguaje de primer orden y - RI es el conjunto de restricciones de integridad, fórmulas cerradas de L. • {incw: incw¬W, WRI} el conjunto de restricciones de integridad en forma negada (las cláusulas resultantes de aplicar el algoritmo Lloyd y Topor [LT84] a {incw  ¬W: WRI} deben ser de rango restringido y formar parte de cualquier estado de la base de datos). • D un estado de la base de datos: D= {AL1 L2  ...  Ln: A es un átomo, Li es un literal y n  0}. • La semántica asumida es la de la compleción.

Teorema de simplificación Sea: • T una transacción formada por dos conjuntos de cláusulas, el conjunto Tins de inserciones y un conjunto Tdel de borrados. • D' el estado resultante de aplicar a D la transacción T: D‘ = (DTins)\Tdel. • D y D' son estratificados y de rango restringido. • W una restricción de integridad tal que D satisface W. Se cumple: "Si existe una refutación SLDNF* para D'  RI  {C0} para alguna actualización C0 de la transacción entonces D' viola RI".

Resumen. Semántica asumida: semántica de la compleción. Concepto de satisfacción: punto de vista de la consistencia. Tipo de base de datos: las reglas deductivas son cláusulas normales de la forma AL1 L2  ...  Ln. Restricciones sintácticas: la base de datos debe ser estratificada y las reglas de rango restringido. Las restricciones de integridad son fórmulas cerradas en forma negada (incw: incw¬W, WRI) . Estrategia: Intercalación de la Fase de Generación y de la Fase de Evaluación. El procedimiento SLDNF* no contempla los borrados inducidos.

5. SGBD deductivos Extender un SGBD Relacional con un mecanismo de inferencia para evaluar vistas recursivas SGBD relacional Mecanismo de inferencia Sistema de Programación Lógica Gestión de hechos en memoria secundaria Extender un Sistema de Programación Lógica con un sistema de gestión de los hechos en memoria secundaria Sistema de Programación Lógica Acoplar (por medio de una interfaz) un SGBD Relacional y un Sistema de Programación Lógica SGBD relacional

5. SGBD deductivos Relación derivada PRECIOS3:
Mecanismo de vistas del modelo relacional (SQL92) definición relaciones derivadas Relación derivada PRECIOS3: CREATE VIEW PRECIOS3 AS SELECT codprov, codpieza, precio FROM PRECIOS, PROV WHERE (PRECIOS.codprov = PROV.codprov AND PROV. zona=3) evaluación PRECIOS3  ( (PROV DONDE zona=3) JOIN PRECIOS ) [ codprov,codpieza,precio ]

Relación derivada COMPONENTE:
CREATE VIEW COMPONENTE AS SELECT pieza1, pieza2 FROM COMP UNION FROM COMP, COMPONENTE evaluación COMPONENTE  COMP UNION (COMP ((pieza2,X)) JOIN COMP ((pieza1,X) ) [pieza1, pieza2 ] (COMP((pieza2,X)) JOIN COMP((pieza1,X), (pieza2, Y) ) JOIN COMP((pieza1,Y) ) [pieza1, pieza2 ] (COMP((pieza2,X)) JOIN COMP((pieza1,X), (pieza2, Y) ) ...

Esquema 5. SGBD deductivos Relaciones básicas: Relaciones derivadas:
PIEZA (codpieza: D1, desc: D2, peso: D3) CP = {codpieza} PROV (codprov: D4, nombre: D5, zona: D6) CP = {codprov} PRECIOS (codprov: D4, codpieza: D1, precio: D7) CP = {codprov, codpieza} CAj = {codprov} ® PROV CAj = {codpieza} ® PIEZA COMP (pieza1: D1, pieza2: D1) CP = {pieza1, pieza2} CAj = {pieza1} ® PIEZA CAj = {pieza2} ® PIEZA Relaciones derivadas: PRECIOS3 (codprov: D4, codpieza: D1, precio: D7) CP = {codprov, codpieza} CAj = {codprov} ® PROV CAj = {codpieza} ® PIEZA PRECIOS_EXT (codprov: D4, nombre: D5, codpieza: D1, desc: D2, precio: D7) COMPONENTE (pieza1: D1, pieza2: D1) CP = {pieza1, pieza2} CAj = {pieza1} ® PIEZA CAj = {pieza2} ® PIEZA Restricciones de integridad: "x "y ( COMPONENTE (x,y) ® Ø COMPONENTE (y,x) ) Esquema

5. SGBD deductivos BDD: PIEZA PROV PRECIOS COMP Reglas deductivas:
1 precios3 (x, y,z) ¬ precios (x, y, z) Ù prov (x, w, 3) 2 componente (x, y) ¬ comp (x, z) Ù componente (z, y) 3 componente (x, y) ¬ comp (x, y) 4 precios_ext (x,n,y,d,p) ¬ prov (x, n,_)Ùpieza (y, d,_)Ùprecios (x, y, p)

5. SGBD deductivos Estrategias Estrategia Bottom-up:
bottom-up (forward chaining) Estrategias top-down (backward chaining) Estrategia Bottom-up: Naive (Bancilhon y otros, 1986) Seminaive (Bancilhon y otros, 1986) Magic sets (Beeri&Ramakrishnan, 1987) Estrategia Top-down: SLDNF(1978) Procedimiento abdubctivo (Eshghi&Kowalski,89) SLD-AL (Vielle, 89)

5. SGBD deductivos Estrategia bottom-up Paso1 Paso 2
Generación de la información derivada (F*) aplicando las reglas deductivas al conjunto de hechos (F) Paso1 Paso 2 Evaluación de la consulta en F È F*

Generación de información derivada (F*) Iteración 1ª
Paso 1 Generación de información derivada (F*) Iteración 1ª F Reglas F1* PIEZA PRECIOS_EXT 4 Generación de información derivada que no es relevante para la consulta PROV PRECIOS3 ¿De qué piezas se compone la pieza pz1? 1 PRECIOS COMP COMPONENTE 3

Paso 1 Generación de información derivada (F*) Iteración 2ª FÈ F1* Reglas F1* PIEZA PRECIOS_EXT 4 PROV PRECIOS3 1 ¿De qué piezas se compone la pieza pz1? PRECIOS Generación de la misma información derivada en cada iteración. PRECIOS_EXT PRECIOS3

Paso 1 Generación de información derivada (F*) Iteración 2ª FÈ F1* Reglas F2* COMP COMPONENTE 3 2 ¿De qué piezas se compone la pieza pz1? COMPONENTE Generación de la misma información derivada en cada iteración.

5. SGBD deductivos Estrategia bottom-up Problemas: Soluciones:
generación de información derivada que no es relevante para la consulta generación de la misma información (filas) varias veces Soluciones: restringir las regla utilizadas durante la generación de la información derivada a aquellas que son relevantes para la consulta original eliminar en cada iteración las filas que ya han sido generadas en iteraciones anteriores propagar las constantes de la consulta original a las reglas deductivas

Paso 1 Generación de información derivada (F*) Iteración 1ª F Reglas F1* PIEZA PRECIOS PROV ¿De qué piezas se compone la pieza pz1? COMP COMPONENTE 3

Paso 1 Generación de información derivada (F*) Iteración 2ª FÈ F1* Reglas F2* COMP COMPONENTE 2 ¿De qué piezas se compone la pieza pz1? COMPONENTE

Método NAIVE Entrada: Una base de datos definida D y una consulta definida Q Salida: el conjunto de respuestas a Q Paso 1: Seleccionar el subconjunto de reglas Dreglas relevantes para la consulta*. Paso 2: M ¬ {A: A es un hecho de D} Paso 3: Repetir Mant ¬ M M ¬ Mant È { Hq: existe una regla H ¬ B en Dreglas y una sustitución q para las variables de B, tal que B q es cierto en Mant } hasta M = Mant Paso 4: generar cualquier sustitución q de las variables de Q tal que cualquier hecho en Qq sea cierto en M * Una regla de D será miembro de Dreglas si y sólo si, en el grafo de dependencias de D, aparece en un camino entre un predicado de la consulta y un predicado básico.

Método NAIVE Paso 1 Dreglas = { 2,3 }
Paso 2 M=PROV È PIEZA È PRECIOS È {comp(pz1, pz3), comp(pz3, pz8)} Paso 3 Mant M PROV È PIEZA È PRECIOS È {comp(pz1, pz3), comp(pz3, pz8) componente(pz1, pz3), componente(pz3, pz8)} PROV È PIEZA È PRECIOS È {comp(pz1, pz3), comp(pz3, pz8)} 1 PROV È PIEZA È PRECIOS È {comp(pz1, pz3), comp(pz3, pz8) componente(pz1, pz3), componente(pz3, pz8) }È {componente(pz1, pz3), componente(pz3, pz8) componente (pz1, pz8)} PROV È PIEZA È PRECIOS È {comp(pz1, pz3), comp(pz3, pz8) componente(pz1, pz3), componente(pz3, pz8)} 2 PROV È PIEZA È PRECIOS È {comp(pz1, pz3), comp(pz3, pz8) componente(pz1, pz3), componente(pz3, pz8) componente(pz1, pz8)} È {componente(pz1, pz3), componente(pz3, pz8) componente (pz1, pz8)} PROV È PIEZA È PRECIOS È {comp(pz1, pz3), comp(pz3, pz8) componente(pz1, pz3), componente(pz3, pz8) componente(pz1, pz8)} 3

Método SEMINAIVE Entrada: Una base de datos definida D y una consulta definida Q Salida: el conjunto de respuestas a Q Paso 1: Seleccionar el subconjunto de reglas Dreglas relevantes para la consulta. Paso 2: M ¬ {A: A es un hecho de D} Mdif = M Paso 3: Repetir Mant ¬ M M ¬ Mant È { Hq: existe una regla H ¬ B en Dreglas y una sustitución q para las variables de B, tal que B q es cierto en Mant y al menos un hecho de B q está en Mdif } Mdif ¬ M - Mant hasta Mdif = Æ Paso 4: generar cualquier sustitución q de las variables de Q tal que cualquier hecho en Qq sea cierto en M

Método SEMINAIVE Paso 1 Dreglas = {2,3 }
Paso 2 M=PROV È PIEZA È PRECIOS È {comp(pz1, pz3), comp(pz3, pz8)} Mdif = PROV È PIEZA È PRECIOS È {comp(pz1, pz3), comp(pz3, pz8)} Paso 3 Mant M Mdif PROV È PIEZA È PRECIOS È {comp(pz1, pz3), comp(pz3, pz8)} È {componente(pz1, pz3), componente(pz3, pz8) } PROV È PIEZA È PRECIOS È {comp(pz1, pz3), comp(pz3, pz8)} 1 componente(pz1, pz3), componente(pz3, pz8) PROV È PIEZA È PRECIOS È {comp(pz1, pz3), comp(pz3, pz8)} È {componente(pz1, pz3), componente(pz3, pz8) componente (pz1, pz8)} PROV È PIEZA È PRECIOS È {comp(pz1, pz3), comp(pz3, pz8) componente(pz1, pz3), componente(pz3, pz8) } 2 componente (pz1, pz8) PROV È PIEZA È PRECIOS È {comp(pz1, pz3), comp(pz3, pz8) componente(pz1, pz3), componente(pz1, pz8) componente(pz1, pz8) } PROV È PIEZA È PRECIOS È {comp(pz1, pz3), comp(pz3, pz8) componente(pz1, pz3), componente(pz1, pz8) componente(pz1, pz8) } 3

D: PIEZA PROV PRECIOS COMP Reglas deductivas:
1 precios3 (x, y,z) ¬ precios (x, y, z) Ù prov (x, w, 3) 2 componente (x, y) ¬ comp (x, z) Ù componente (z, y) 3 componente (x, y) ¬ comp (x, y) 4 precios_ext (x,n,y,d,p) ¬ prov (x, n,_)Ùpieza (y, d,_)Ùprecios (x, y, p)

Método NAIVE Entrada: D
Salida: extensión de PRECIOS3, PRECIOS_EXT, COMPONENTE Paso 1: {1,2,3,4} Paso 2: PRECIOS3  { }, PRECIOS_EXT { }, COMPONENTE { } Paso 3: Repetir PRECIOS3ant ¬ PRECIOS PRECIOS_EXTant ¬ PRECIOS_EXT COMPONENTEant ¬ COMPONENTE PRECIOS3 ¬ PRECIOS3ant UNION (PROV DONDE zona=3 JOIN PRECIOS)[codprov, codpieza, precio] PRECIOS_EXT ¬ PRECIOS_EXTant UNION (PROV[codprov, nombre] JOIN PRECIOS JOIN PIEZA[codpieza, desc]) COMPONENTE ¬ COMPONENTEant UNION (COMP UNION (COMP ((pieza2,X)) JOIN COMPONENTE ((pieza1,X))[pieza1,pieza2]) hasta PRECIOS3 = PRECIOS3ant  PRECIOS_EXT = PRECIOS_EXTant  COMPONENTE = COMPONENTEant

5. SGBD deductivos Limitaciones de los algoritmos NAIVE y SEMINAIVE: definidos para reglas deductivas definidas no tienen en cuenta las constantes de la consulta del usuario

5. SGBD deductivos Algoritmo Naive Solución incorrecta
Reglas deductivas con negación D: Hechos: q(1), r(1) Reglas deductivas: 1. s(x)  r(x) 2. p(x)  q(x)  s(x) Paso 1: Dreglas= {1,2} Paso 2: M = {q(1), r(1)} Paso 3: Iteración. 1ª: M = {q(1), r(1), s(1), p(1)} Iteración 2ª: Naive y Seminaive: algoritmos definidos para reglas deductivas definidas Algoritmo Naive Solución incorrecta

5. SGBD deductivos Solución
aplicar el algoritmo (paso 3) por niveles de reglas (estratificación de la BDI) Solución p Nivel 1 r q (hechos) Nivel 2 s Nivel 3 p 2 2 + - q s + 1 r Paso 1: Dreglas= {1,2} Paso2: Nivel 1 M = {q(1), r(1)} Paso3: Nivel 2 Iteración. 1ª: M = {q(1), r(1), s(1)} Nivel 3 Iteración 1ª: M = {q(1), r(1), s(1)} En el Paso 3, en cada nivel se aplican sólo las reglas que definen los predicados del nivel.

Estratificación de la BDI*:
5. SGBD deductivos Estratificación de la BDI*: Asignar cada predicado a un nivel de forma que para toda regla de la BDI, A  L1  L2  ...  Ln, se cumple que “el nivel de todo predicado positivo en el cuerpo de la regla es menor o igual que el nivel del predicado de la cabeza, y el nivel de todo predicado negativo en el cuerpo de la regla es menor que el nivel del predicado de la cabeza” *La estratificación no siempre es posible, las bases de datos que lo permiten se llaman estratificadas.

5. SGBD deductivos Solución Algoritmos muy complejos
¿cuáles son las componentes de la pieza pz1? Paso 1: Dreglas= {2,3} Paso2: M = {comp(pz1,pz3), comp(pz3,pz8)} Paso3: Iteración. 1ª: M = {comp(pz1,pz3), comp(pz3,pz8), componente(pz1,pz3)} Iteración 2ª: M = {comp(pz1,pz3), comp(pz3,pz8), componente(pz1,pz3)} Naive y Seminaive: algoritmos que no tienen en cuenta las constantes de la consulta del usuario 2. componente(pz1,y)  com(pz1,z) , componente(z,y) 3. componente (pz1,y)  comp (pz1,y) Reglas instanciadas por la consulta del usuario

5. SGBD deductivos Estrategia top-down Problemas: Soluciones: Paso 1
Generación de consultas derivadas aplicando las reglas deductivas a la consulta original Estrategia top-down Paso 1 Evaluación de subconsultas sobre relaciones básicas en la base de datos explícita y propagación de respuestas a la consulta original Paso 2 Problemas: no terminación del proceso de generación de consultas derivadas en presencia de reglas recursivas Soluciones: uso de técnicas de detección de ramas infinitas

¿De qué piezas se compone la pieza pz1?
2’ componente (x, y) ¬ componente (z, y) Ù comp (x,z) 3’ componente (x, y) ¬ comp (x, y) ¬componente (pz1,w) 2’ 3’ ¬componente (z, w) Ù comp( pz1,z) ¬ comp (pz1, w) 2’ w / pz3 hecho 3’ ¬componente (z’, w) Ù comp ( z, z’) Ù comp (pz1, z) ¬ comp (z, w) Ù comp(pz1, z) ¿De qué piezas se compone la pieza pz1? 2’ hecho z / pz3 w / pz8 ¬ componente (z’’, w) Ù comp ( z’, z’’) Ù comp (z, z’) Ù comp (pz1, z) ¬ comp (pz1, pz3) hecho rama infinita w = pz3 w = pz8

Definición de vistas recursivas SQL3:
5. SGBD deductivos Definición de vistas recursivas SQL3: Relación básica: comp (pieza1 char(3), pieza2 char(3)) Relación derivada: componente (pieza1 char(3), pieza2 char(3)) Reglas deductivas: componente (x,y)  comp (x,y) componente(x,y)  com(x,z) , componente(z,y)

5. SGBD deductivos CREATE [ RECURSIVE ] VIEW nombre_vista
[(nombre_atr1 [{,nombre_atr2}...]) ] AS sentencia_SELECT CREATE RECURSIVE VIEW componente (pieza1, pieza2) AS (SELECT * FROM comp UNION SELECT C.pieza1, CP.pieza2 FROM comp C, componente CP WHERE C.pieza2 = CP.pieza1) SELECT recursiva que define la vista (relación derivada)

Lógica y Bases de Datos Matilde Celma Giménez.

Presentaciones similares

Presentación del tema: "Lógica y Bases de Datos Matilde Celma Giménez."— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback

Iniciar la sesión

Autorizarse a través de una red social:

Lógica y Bases de Datos Matilde Celma Giménez.

Presentaciones similares

Presentación del tema: "Lógica y Bases de Datos Matilde Celma Giménez."— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback