Ly bd

Departamento de Sistemas Informáticos y Computación / Universidad Politécnica de Valencia
Lógica
y
Bases de Datos
Matilde Celma Giménez

Departamento de Sistemas Informáticos y Computación / Universidad Politécnica de Valencia 2
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

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

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)
Estructuras de datos
• Tupla
• Relación

Relación: conjunto de tuplas del mismo esquema al que se
denomina esquema de la relación.
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
a11 a12 a13 ……… a1n
a21 a22 a23 ……… a2n
a31 a32 a33 ……… a3n
……… ……… ……… ……… ………
R
representación
tabular de la
extensión de la
relación
A1
A2
A3
…
An
R
representación del
esquema de una
relación
Estructuras de datos
• Tupla
• Relación

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

Lenguajes
• Cálculo Relacional de Dominios
• Cálculo Relacional de Tuplas 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

Turiar2
Tajor1
nombrercod
Río
Turiar2
Tajor1
nombrercod
Río
Toledo45
Cáceres10
Cuenca16
Valencia46
Teruel44
nombrepcod
Provincia
Toledo45
Cáceres10
Cuenca16
Valencia46
Teruel44
nombrepcod
Provincia
r116
r128
r145
r110
r216
r246
r244
rcodpcod
Pasa_por
r116
r128
r145
r110
r216
r246
r244
rcodpcod
Pasa_por
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] ) Río) [nombre]
producto
cartesiano
selección
proyección concatenación
diferencia
Lenguaje de
tipo
algebraico

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

Turiar2
Tajor1
nombrercod
Río
Turiar2
Tajor1
nombrercod
Río
Toledo45
Cáceres10
Cuenca16
Valencia46
Teruel44
nombrepcod
Provincia
Toledo45
Cáceres10
Cuenca16
Valencia46
Teruel44
nombrepcod
Provincia
r116
r128
r145
r110
r216
r246
r244
rcodpcod
Pasa_por
r116
r128
r145
r110
r216
r246
r244
rcodpcod
Pasa_por
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
AND
P1.pcod <> P2.pcod ) ) )
Lenguaje de
tipo lógico

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)

Dominios:
dom_P= { A, B, C }
dom_A = { a, b, c, d }
dom_C = { CS100, CS200, P100, P200 }
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
CAj: {cod_curso}  Curso
Restricciones:
"Todo curso es impartido por algún profesor"
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}
Esquema S:

C
B
A
C
B
A
d
c
b
a
d
c
b
a
P200
P100
CS200
CS100
P200
P100
CS200
CS100
P200C
P100B
CS200A
CS100A
P200C
P100B
CS200A
CS100A
P200d
CS100d
P100c
CS100b
CS200a
CS100a
P200d
CS100d
P100c
CS100b
CS200a
CS100a
Ext(Profesor) Ext(Alumno) Ext(Curso
)
Ext(Matriculado) Ext(Enseña)
Base de Datos: Ext (S)

Esquema S: (L, RI)
Constantes C
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 }
Predicados P Nombres de relación del esquema:
P = { Rn: R (A1: D1, A2: D2 , ..., An: Dn)  S }  {=}
LenguajeL
Restricciones de Integridad (RI)
Fórmulas bien
formadas (f.b.f) de L
RI1. Lógica y Bases de Datos: introducción
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)
Dominio D Unión de los dominios de definición de las
relaciones del esquema:
D = {di : di  i (Di), Di es un dominio de S}
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 }
Interpretación1. Lógica y Bases de Datos: introducción
interpretación de un lenguaje de 1er orden.

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.
Predicados P Nombres de relación del esquema:
P = { Rn: R (A1: D1, A2 : D2 , ..., An : Dn)  S }  {=}

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).
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 }
Dominio D Unión de los dominios de definición de las relaciones del
esquema:
D = {di : di  i (Di), Di es un dominio de S}

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(.,.)}  {=}
Variables: { X, Y, Z, …}
Cuantificadores: { ,$}
Conectivas lógicas: { ,,}
Símbolos de puntuación: { (, ),’, ... }
Restricciones de Integridad:
x ( curso (x)  $ y enseña (y,x) )
Fórmula bien
formada de L
LenguajeLRI

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
C
B
A
C
B
A
d
c
b
a
d
c
b
a
P200
P100
CS200
CS100
P200
P100
CS200
CS100
P200C
P100B
CS200A
CS100A
P200C
P100B
CS200A
CS100A
P200d
CS100d
P100c
CS100b
CS200a
CS100a
P200d
CS100d
P100c
CS100b
CS200a
CS100a
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
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) )
C
B
A
C
B
A
d
c
b
a
d
c
b
a
P200
P100
CS200
CS100
P200
P100
CS200
CS100
P200C
P100B
CS200A
CS100A
P200C
P100B
CS200A
CS100A
P200d
CS100d
P100c
CS100b
CS200a
CS100a
P200d
CS100d
P100c
CS100b
CS200a
CS100a
C
B
A
C
B
A
d
c
b
a
d
c
b
a
P200
P100
CS200
CS100
P200
P100
CS200
CS100
P200C
P100B
CS200A
CS100A
P200C
P100B
CS200A
CS100A
P200d
CS100d
P100c
CS100b
CS200a
CS100a
P200d
CS100d
P100c
CS100b
CS200a
CS100a
E(=) = {(d,d): d D}

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

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

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))),
… }

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
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) }

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.
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)) }

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
Axiomas de compleción
Axiomas de nombre único
Axioma de cierre de dominio
Axioma de la igualdad

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)
Teoría de primer
orden en L
T = comp(D)

{axioma de cierre de dominio}

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
Hipótesis del cierre de dominio
Hipótesis de nombre único
axiomas de compleción
axioma de nombre único
axioma de cierre de dominio

Axiomas de compleción para
las relaciones del esquema
Hipótesis del mundo cerrado
A D
D  A
HMC

Lógica y Bases de Datos
5. SGBD deductivos.
5.2. SQL3

Base de datos
deductiva
+
Base de datos
relacional Conocimiento explícito
Reglas
deductivas
Conocimiento implícito
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
2. Bases de datos deductivas: definición y formalización
Reglas
deductivas
Base de datos
relacional

Padre Hijo
Juan Luis
Luis María
Luis Pedro
Pedro Jose
Padre
Antecesor (x, y) Padre (x, y)
Antecesor (x, y) $z (Padre (x, z) Antecesor (z, y) )
Reglas Deductivas:
Juan es antecesor de Luis
Juan es antecesor de María
Juan es antecesor de Pedro
Luis es antecesor de José

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

Base de datos deductiva
Padre Hijo
Juan Luis
Luis María
Luis Pedro
Pedro José
Padre
Antecesor (x, y) Padre (x, y)
Antecesor (x, y) $z (Padre (x, z) Antecesor (z, y))
Reglas Deductivas:
Antecesor Descendiente
Juan Luis
Juan María
Juan Pedro
Juan José
Luis María
Luis Pedro
Luis José
Pedro José
Antecesor
Relación derivada

Bases de Datos Deductivas
ESQUEMA
Relaciones
Ri (Ai1
: Di1
, Ai2
: Di2
, ..., Aini
: Dini
)
(1 i m) (m relaciones)
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)
Wi: Wi es una expresión lógica
(1 ≤ i ≤ k) (k restricciones de integridad)
Bases de Datos Relacionales

Bases de Datos DeductivasBases de Datos Relacionales
Ri (Di1
x Di2
x ... x Dini
)
Ri  (Di1
x Di2
x ... x Dini
)
Ai1 Ai2 ...... Aini
Base de datos Base de datos
Sij
(x1, x2,..., xni
)  Wij
(1 j Ki) (Ki reglas para la relación Si)
Ri

Bases de Datos DeductivasBases de Datos Relacionales
Ri  (Di1
x Di2
x ... x Dini
)
Ri  (Di1
x Di2
x ... x Dini
)
Base de datos Base de datos
Sij
(x1, x2,..., xni
)  Wij
(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.

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
Esquema2. Bases de datos deductivas: definición y formalización

PRECIOS3 (codprov: D4, codpieza: D1, precio: D7)
PRECIOS_EXT (codprov: D4, nombre: D5, codpieza: D1, desc: D2, precio: D7)
COMPONENTE (pieza1: D1, pieza2: D1)
CP = {pieza1, pieza2}
Restricciones de integridad:
x y ( COMPONENTE (x,y)   COMPONENTE (y,x) )
Esquema2. Bases de datos deductivas: definición y formalización

codpieza desc peso
pz1 tornillo 10
pz3 tuerca 11
pz8 arandela 8
PIEZA
codprov nombre zona
pv1 Juan 1
pv5 Carlos 3
pv3 Luis 3
PROV
codprov codpieza precio
pv1 pz3 10
pv1 pz8 20
pv3 pz8 30
pv5 pz1 50
PRECIOS
pieza1 pieza2
pz1 pz3
pz3 pz8
COMP
BasedeDatos2. Bases de datos deductivas: definición y formalización

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) )
BasedeDatos
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
PRECIOS3 PRECIOS_EXT COMPONENTE
BASEDEDATOS
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)

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

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

INSERT INTO PRECIOS
VALUES (pv12, pz23, 20)
¿el proveedor pv12 existe
y es de la zona 3 y la
pieza pz23 existe?
opción 2
NOSI
error

¡Debido a la ambigüedad existente, el SQL92 no permite actualizar
vistas definidas a partir de una concatenación de tablas!
opción 1 opción 2

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
Ri (Ai1
: Di1
, Ai2
: Di2
..., Aini
: Dini
)
Si (Ai1
: Di1
, Ai2
: Di2
, ..., Aini
: Dini
)
Ri  (Di1
x Di2
x ... x Dini
)
(1 i m)
BASE DE DATOS
Sij
(x1, x2,..., xni
)  Wij
(1 i s)
(1 j Ki)
notación
algebraic
a
notación
lógica

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) )
ReglasdeductivasHechos
Basededatosdeductiva
Formalización: 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:

Lenguaje de definición de reglas
Lenguaje de 1er orden
Base de datos deductiva Programa lógico
Sistema de programación
lógica
Sistema de gestión
de bases de datos
deductivas

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)

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)
BASE DE DATOS
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 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)
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)

Esquema: (L, RI) :
Constantes Unión de los dominios de definición de
las relaciones del esquema
Predicados Nombres de relación del esquema
LenguajeL
Restricciones de Integridad (RI)
Fórmulas bien
formadas (f.b.f) de L
RI

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}
Variables: { X, Y, Z, …}
Cuantificadores: { ,$}
Conectivas lógicas: { ,,}
Símbolos de puntuación: { (, ),’, ... }
Restricciones de Integridad:
x y ( componente (x,y)   componente (y,x) )
Fórmulas bien
formadas de L
LenguajeLRI

{ pieza (pz1, tornillo, 10), ...,
proveedor (pv1, Juan, 1), ...,
precios (pv1, pz3, 100), ...,
comp (pz1, pz3), ... }
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
BDD:

Fórmulas bien
formadas de L

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

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
Semántica de una BDD

componente (pz1,w)
comp (pz1,z)  componente (z,w)
componente (pz3,w)
comp (pz3,z ‘)  componente (z ‘,w)
componente ( pz8,w)
comp (pz8,z ‘‘)  componente (z ‘‘,w) comp (pz8,w)
comp (pz3,w)
comp (pz1,w)
2
hecho z/pz3
2 3
hecho
z’/pz8
2 3
hecho w/pz3
hecho
w/pz8
3
w = pz3
w = pz8
¿Dequépiezassecomponelapiezapz1?
2 componente (x, y) comp (x, z)  componente (z, y)
3 componente (x, y) comp (x, y)
Procedimiento
SLDNF

comp (pz1,z)  componente (z,w)
resolución componente (x,y) comp (x,z)  componente (z,y)
x/pz1 y/w
resolución
comp (pz1,pz3) hecho
regla 2
z/pz3
comp (pz3,pz8) hecho
w/pz8
resolución
éxito
w = pz8
respuesta
componente (x,y) comp (x,y) regla 3
x/pz3 y/w
comp (pz3,w)
resolución
¿Dequépiezassecomponelapiezapz1?
Procedimiento
SLDNF

proveedor (x, y, z) precios (x,pz1,30)
precios (pv1, pz1,30)
resolución proveedor (pv1,Juan,1)
x/pv1, y/Juan, z/1
hecho
precios (pv1,pz1,30)
fallo
negación
como fallo
éxito
x/pv1
respuesta
¿Quéproveedoresnosuministranlapiezapz1a30€? Procedimiento
SLDNF

Semántica declarativa: teoría de la compleción de D (comp(D))
precios (pv1, pz1, 30)
no
D precios (pv1, pz1, 30)
D precios (pv1, pz1, 30)
SLDNF no infiere consecuencias lógicas de D
SLDNF infiere consecuencias lógicas de comp(D)
¿Suministra el proveedor
pv1 la pieza pz1 a 30€?

{ precios (pv1, pz3,10),
precios (pv1, pz8,20),
precios (pv3, pz8, 30),
precios (pv5, pz1,50),
, ... }
D:
D precios (pv1, pz1, 30)
D precios (pv1, pz1, 30)
{ precios (pv1, pz3,10),
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)Comp(D):

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 de la igualdad
Axiomas sobre p en D
Axiomas de compleción de p
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
eficiencia 
tiempo del
sistema de inferencia
eficiencia 

5. SGBD deductivos.
5.2. SQL3

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
3. Actualización de vistas

codpieza desc peso
pz1 tornillo 10
pz3 tuerca 11
pz8 arandela 8
codprov nombre zona
pv1 Juan..... 1
pv5 Carlos .... 3
pv3 Luis ...... 3
codprov nombre codpieza desc precio
pv1 Juan... pz3 tuerca 10
pv1 Juan... pz8 arandela 20
pv3 Luis... pz8 arandela 30
pv5 Carlos..
.
pz1 tornillo 50
codprov codpieza precio
pv1 pz3 10
pv1 pz8 20
pv3 pz8 30
pv5 pz1 50
PIEZA
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))}

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

precios_ext (pv1, x1, x2, x3, x4)
prov (pv1, x1, x5)  pieza (x2,x3,x6) precios (pv1,x2,x4)
pieza (x2,x3,x6)  precios (pv1,x2,x4)
precios (pv1,pz3,x4) precios (pv1,pz8,x4)
prov(pv1,Juan,1)
pieza(pz3,tuerca,11)
x2 / pz8, x3 / arandela
precios(pv1,pz3.10)
x4/ 10 x4/ 20
4
T1
T2T2
T3T3
SLDNF:
pieza(pz8,arandela,8)
x2 / pz3, x3 / tuerca
x1 / Juan
precios(pv1,pz8,20)

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

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)
 ¬q(a)  f(a)  s(a)  n(a)
 r(a)  n(a)  t(a)  ¬m(a)  n(a)
 n(a)
T1= {insertar (f(a)), borrar (q(a))}
T2 = {insertar (t(a)), borrar (m(a)), insertar (n(a))}
T3 = {insertar (n(a))}
Act: insertar(p(a))
1
resolución
2
3 4
resolución
r(a) resolución

Procedimientos de borrado e inserción
de una tupla de una relación derivada:
- 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.
Hipótesis:
Características:
- sólo actualizan la base de datos explícita
- procedimientos recursivos (se llaman mutuamente)

Procedimiento de borrado: Borrado (D, A, t)
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 t
Inicio
t:= un árbol SLDNF para D  {  A}
t := { [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
o
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, t)
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 t
Inicio
t := { [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
o
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

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)
p(a)
¬q(a) f(a)
r(a) ¬t(a)
¬m(a) n(a)
¬t(a)
1= {insertar(t(a))}
2= {borrar(r(a))}
Act: insertar (p(a))
1
resolución
2
r(a) resolución
q(a)
NF
T1={borrar(m(a)), insertar(n(a))}
3 resolución
borrar(q(a))
T1 = {borrar (r(a)), insertar (f(a))}
T2 = {insertar (t(a)), insertar (f(a))}

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’.

1. p(x)  q(x)  t(x)
2. p(x)  w(x)  v(x)
3. t(x)  s(x)  ¬r(x)
p(1)
w(1) v(1) q(1) t(1)
q(1) s(1) r(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
Ejemplo 1
Actualización: U = p(1)
Obtener transacciones que aseguren
una de estas cuatro situaciones

1) Tiempo de generación de la solución.
2) Variables cuantificadas existencialmente
3) Recursividad
4) Información asumida
5) Tratamiento de restricciones de integridad
Caracterización del problema:

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.

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.

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)
Actualización: U = p(1).
Ejemplo 2:
p(1)
q(1,y)  t(1,y)
1 resolución
$y (q(1,y)  t(1,y))
{y/--}

BDD: 1. p(x)  q(x,y)  t(x,y)
….
t(1,2)
Ejemplo 2:
p(1)
q(1,y)  t(1,y)
1 resolución
$y (q(1,y)  t(1,y))
T1 = { insertar(q(1,nulo)),
insertar(t(1,nulo))}
T2 = { insertar(q(1, c)),
insertar(t(1, c))}
T3 = { insertar(q(1,2))}
{y/ nulo} {y/ c} {y/ 2}

3) Recursividad.
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.

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))}
…
BDD: 1. p(x,y)  q(x,y)
2. p(x,y)  q(x,z)  p(z,y)
Actualización: U = p(1,1).
Ejemplo 3:

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:
$y (r(1,y)   s(1,y)  q(1,y))
p(1)
r(1,y)  ¬ s(1,y)  q(1,y)
1 resolución
{y/2}
r(1,2)  ¬ s(1,2)  q(1,2)
T1 = { insertar( q(1,2)) }
r(1,2)  BDE
s(1,2) fallo finito
q(1,2)  BDE
q(1,2)
q(1,2) resolución
s(1,2)
2 resolución
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.
q(1,2)
s(1,2)
2 resolución

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.

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))}.
BDD: 1. p(x)  q(x)  r(x)
…
W = x (r(x)  t(x))
p(1)
1 resolución
T1= { insertar(q(1)), insertar(r(1)) }
q(x)  r(x)
T1 no es una solución
correcta porque el estado
T1(BDD) viola la
restricción de integridad W
Ejemplo 5:

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:
1. Método de Kakas y Mancarella
2. 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. 650-661.
[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*   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. 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:
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) }

A
= {t(1)}
A
p(1)
t(1)
1ª Derivación abductiva
= 
= 

Derivación de consistencia
A
= {q(1)}
A3
p(1)
q(1)r*(1)
r*(1)
= 
= 
’= {q(1),r*(1)}
C
C4
r(1)}
s(1)}

’= {q(1),r*(1)}
’= {q(1),r*(1),s*(1)}
A4
= {q(1),r*(1),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:
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) }

A4
p*(1)
= 
q(1)r*(1),t(1)}
C
C4
p(1)}
t(1)}
’= {p*(1)}
’= {p*(1)}
’= {p*(1), q*(1)}
C4
} ’= {p*(1), q*(1),t*(1)}
3= {p*(1),q*(1),t*(1)}

A4
p*(1)
= 
q(1)r*(1),t(1)}
C
C5
p(1)}
t(1)}
C4

’= {p*(1)}
’= {p*(1)}
’= {p*(1),s(1)}
’= {p*(1),s(1),t*(1)}
4= {p*(1),s(1),t*(1)}
Derivación abductiva
A1
r(1)
A3
s(1)
’’= {p*(1)}
’’= {p*(1), s(1)}
’’= {p*(1)}

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:
2. p(x)  t(x)
3. r(x)  s(x)
Marco abductivo:
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) }

A
= {t(1)}
A
p(1)
t(1)
= 
= 
 T1 = { insertar(t(1)) }
A
= {q(1)}
A3
p(1)
q(1)r*(1)
r*(1)
= 
= 
’= {q(1),r*(1)}
C
C4
r(1)}
s(1)}

’= {q(1),r*(1)}
’= {q(1),r*(1),s*(1)}
A4
= {q(1),r*(1),s*(1)}
 T2= {insertar(q(1)), borrar(s(1))}
BDE: s(1)

Ejemplo 6:
2. p(x)  t(x)
3. r(x)  s(x)
Marco abductivo:
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) }

A4
p*(1)
= 
q(1)r*(1),t(1)}
C
C4
p(1)}
t(1)}
’= {p*(1)}
’= {p*(1)}
’= {p*(1), q*(1)}
C4
} ’= {p*(1), q*(1),t*(1)}
3= {p*(1),q*(1),t*(1)}
BDE: q(1)
t(1)
 T3= {borrar(q(1)), borrar(t(1))}
A4
p*(1)
= 
q(1)r*(1),t(1)}
C
C5
p(1)}
t(1)}
C4

’= {p*(1)}
’= {p*(1)}
’= {p*(1),s(1)}
’= {p*(1),s(1),t*(1)}
4= {p*(1),s(1),t*(1)}
Derivación abductiva
A1
r(1)
A3
s(1)
’’= {p*(1)}
’’= {p*(1), s(1)}
’’= {p*(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. 71-89.
[GL91] Guessoum, A.; Lloyd, J. W. Updating knowledge bases II. New Generation
Computing, Vol. 10, 1991, págs. 73-100.

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.
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:
t : 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
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
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
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)
o
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:
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.

q(1)r(1) t(1)
p(1)
Fallo Fallo
 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.
Inserción_Básica

r(x)s(x)
 s(1)
 r(1) Cláusula de entrada
s(1)
Éxito
T1’ = { borrar (r(x)  s(x)) }
T2’ = { borrar (s(1)) }
Borrado-Básico

Ejemplo 8:
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.

Éxito
q(1)r(1) t(1)
p(1)
r(1)
Cláusula de entrada
p(x)q(x)r(x)
Cláusula de entrada
p(x)t(x)
Éxito
q(1) t(1)
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)) }
Borrado_Básico

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

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.

5. SGBD deductivos.
5.2. SQL3

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.
4. Comprobación de restricciones de integridad
D0 T1 D1 Ti Di
Evolución de una BDTn 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)
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))

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

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.
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
bases de datos deductivas:

pieza1 pieza2
pz1 pz3
pz3 pz8
pieza1 pieza2
pz1 pz3
pz3 pz8
pz1 pz8
COMP COMPONENTE
COMPONENTE (x, y) COMP (x,z) COMPONENTE (z, y)
COMPONENTE (x, y) COMP (x, y)
Reglas deductivas:
Transacción: {insertar (COMP(pz8,pz1))}
pieza1 pieza2
pz1 pz3
pz3 pz8
pz8 pz1
pieza1 pieza2
pz1 pz3
pz3 pz8
pz1 pz8
pz8 pz1
pz8 pz3
pz8 pz8
pz1 pz1
pz3 pz1
pz3 pz3
COMP
COMPONENTE
Paso 1

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

 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).

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.

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:
1. Semántica asumida.
2. 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.
5. 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:
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.

Ly bd

Recomendados

Recomendados

Más contenido relacionado

Similar a Ly bd

Similar a Ly bd (20)

Último

Último (20)

Ly bd