Ly BD

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

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

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
• Tupla
Estructuras
• Relación
de datos
• Álgebra Relacional
Operadores • Cálculo Relacional de Tuplas/Dominios
(lenguajes)
• SQL
• Definición de relaciones
Restricciones
(estáticas) • Restricciones generales

• Tupla
Estructuras de datos
• Relación
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
Estructuras de datos
• Relación
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 ) A1
A2
Extensión de R: { { (A1, v1), (A2, v2), …, (An, vn)}: i ( vi  Di ) } A3
R …
A1 A2 A3 ……… An An
a11 a12 a13 ……… a1n
a21 a22 a23 ……… a2n representación representación del

tabular de la esquema de una
a31 a32 a33 ……… a3n
extensión de la relación
……… ……… ……… ……… ……… relación

• Valor No Nulo (NOT NULL)

Restricciones de Integridad • 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
actualizació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
consulta
un conjunto de atributos.
concatenar relaciones (join)
unión, intersección, diferencia, …...

Provincia Río
pcod nombre rcod nombre
Pasa_por
44 Teruel
pcod rcod r1 Tajo
46 Valencia 44 r2
r2 Turia
16 Cuenca 46 r2
16 r2
10 Cáceres
10 r1
45 Toledo 45 r1 Lenguaje de
28 r1 tipo
16 r1
algebraico
Consulta: “Nombre de los ríos que sólo pasan por una provincia”
( ( Pasa_por [rcod]
producto
diferencia – cartesiano
proyección concatenación
( (Pasa_por P1  Pasa_por P2 )
DONDE P1.rcod = P2.rcod AND P1.pcod  P2.pcod) [rcod] ) Río) [nombre]
selección
Lenguajes • Cálculo Relacional de Dominios
• Cálculo Relacional de Tuplas SQL (estándar)
SQL
INSERT (insertar tupals)
actualización
DELETE (borrar tuplas)
consulta SELECT

Provincia Río
pcod nombre rcod nombre
Pasa_por
44 Teruel
pcod rcod r1 Tajo
46 Valencia 44 r2
r2 Turia
16 Cuenca 46 r2
16 r2
10 Cáceres
10 r1
45 Toledo 45 r1
28 r1
Lenguaje de
16 r1 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
AND
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 El CRT, CRD y SQL son

un conjunto de lenguajes lógicos
operadores definidos definidos sobre ???
para la estructura de
datos relación (conjunto
de tuplas).
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:
Dominios: Enseña (cod_prof: dom_P, cod_curso: dom_C)
CP: {cod_prof, cod_curso}
dom_P= { A, B, C }
CAj: {cod_prof}  Profesor
dom_A = { a, b, c, d }
CAj: {cod_curso}  Curso
dom_C = { CS100, CS200, P100, P200 }
Matriculado (cod_alum: dom_A, cod_curso: dom_C)
Relaciones:
CP: {cod_alum, cod_curso}
Profesor (cod_prof: dom_P)
CAj: {cod_alum}  Alumno
CP: {cod_prof}
CAj: {cod_curso}  Curso
Alumno (cod_alum: dom_A)
CP: {cod_alum} Restricciones:
Curso (cod_curso: dom_C) "Todo curso es impartido por algún profesor"
CP: {cod_curso}

Base de Datos: Ext (S)
Ext(Profesor) Ext(Alumno) Ext(Curso
)
A a CS100
b
B CS200
c
C P100
d
P200
Ext(Matriculado) Ext(Enseña)
a CS100 A CS100
a CS200
A CS200
b CS100
c P100 B P100
d CS100 C P200
d P200

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
Constantes C dominios de definición de las relaciones del esquema:
Lenguaje L
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 }  {=}
Fórmulas bien
RI
Restricciones de Integridad (RI)

formadas (f.b.f) de L

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:
Interpretación
D = {di : di  i (Di), Di es un dominio de S}
Asignación K : C  D / K = { (c, d): c  C, d  D, c  d}

(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 }

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.

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 E : P  i:1..n ( 2Di ) / E(pk)  (2Dk), E(pk) = Ext(p)

(K, E) (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).

Esquema S: (L, RI) :
Constantes: dom_P dom_A dom_C

= {A, B, C, a, b, c, d, CS100, CS200, P100, P200}
Lenguaje L
Predicados: { Profesor(.), Alumno(.), Curso(.), Enseña(.,.), Matriculado(.,.)}  {=}
Variables: { X, Y, Z, …}
Cuantificadores: { ,$}
Conectivas lógicas: { ,,}
Símbolos de puntuación: { (, ),’, ... }
Restricciones de Integridad:
Fórmula bien
RI
x ( curso (x)  $ y enseña (y,x) ) 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)
A a CS100 a CS100 A CS100

b a CS200
B CS200 A CS200
b CS100
c
C P100 c P100 B P100
d
P200
d CS100 C P200
d P200
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 (Profesor) E (Alumno) E (Curso) E (Matriculado) E (Enseña)
A a CS100 a CS100 A CS100

b a CS200
B CS200 A CS200
b CS100
c
C P100 c P100 B P100
d
P200
d CS100 C P200
d 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

teoría de un lenguaje de 1er orden.
Esquema S: (L, RI) Esquema S: (L, RI)

BD: Interpretación I de L 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), Axiomas de información básica
x =(x, x), Axioma de la igualdad
x1, ..., xn (p(x1, ..., xn)

Axiomas de compleción

((=(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, Axiomas de nombre único
Axioma de cierre de dominio

x (=(x, c1)  =(x, c2)  ...  =(x, cm)): (c1, c2, …, cm) son las constantes de C }

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)
Teoría de primer

orden en L
{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 axiomas de compleción
Hipótesis del cierre de dominio axioma de cierre de dominio
Hipótesis de nombre único axioma de nombre único

Axiomas de compleción para

las relaciones del esquema
A D
Hipótesis del mundo cerrado
D AHMC

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

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

Padre Hijo Antecesor (x, y) Padre (x, y)
Antecesor (x, y) $z (Padre (x, z) Antecesor (z, y) )
Juan Luis
Luis María
Luis Pedro
Pedro Jose
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} Hechos
(información básica)
Sistema Información
de inferencia derivada
Reglas = {reglas deductivas}
(conocimiento implícito) Reglas
Sistema de Gestión
Base de datos
de Bases de Datos
relacional Relacionales
+ +
Reglas
Usuario
deductivas 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
Padre Hijo
Antecesor Descendiente
Juan Luis
Juan Luis
Luis María
Juan María
Luis Pedro
Juan Pedro
Pedro José
Juan José
Luis María
Reglas Deductivas:
Luis Pedro
Antecesor (x, y) Padre (x, y) Luis José
Antecesor (x, y) $z (Padre (x, z) Antecesor (z, y))
Pedro José

Bases de Datos Relacionales Bases de Datos Deductivas
ESQUEMA ESQUEMA
Relaciones Relaciones básicas:

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


Base de datos Base de datos
Ri (Di1 x Di2 x ... x Dini) Ri  (Di1 x Di2 x ... x Din )

i
Sij (x1, x2,..., xn )  Wij

Ri i
Ai1 Ai2 ...... Aini

(1 j Ki) (Ki reglas para la relación Si)

Base de datos Base de datos
Ri  (Di1 x Di2 x ... x Dini) Ri  (Di1 x Di2 x ... x Dini )
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 En la definición de una regla deductiva, S  W: W
concepto de relación coincide con el concepto es una fórmula cuyas únicas variables libres son las
de relación matemática (subconjunto del variables de S.
producto cartesiano de los dominios): se pierde
el concepto de atributo de una relación.

Relaciones básicas:
PIEZA (codpieza: D1, desc: D2, peso: D3)
CP = {codpieza}
PROV (codprov: D4, nombre: D5, zona: D6)

Esquema
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

PRECIOS3 (codprov: D4, codpieza: D1, precio: D7)
Esquema
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) )

PIEZA PROV
codpieza desc peso codprov nombre zona
pz1 tornillo 10 pv1 Juan 1

Base de Datos
pz3 tuerca 11 pv5 Carlos 3
pz8 arandela 8 pv3 Luis 3
PRECIOS COMP
codprov codpieza precio
pieza1 pieza2
pv1 pz3 10
pz1 pz3
pv1 pz8 20
pz3 pz8
pv3 pz8 30
pv5 pz1 50

Base de Datos
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) )
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 Definición de información

del modelo relacional 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!

en la actualización de vistas:
INSERT INTO PRECIOS3 VALUES (pv12, pz23, 20) opción 1
INSERT INTO PRECIOS VALUES (pv12,pz23,20)
¿el proveedor ¿la pieza

existe? existe?
NO SI SI NO
INSERT INTO PROV ¿el proveedor es de INSERT INTO PIEZA

VALUES (pv12,NULL,3) la zona 3? VALUES (pz23,NULL,NULL)
NO SI
error c
INSERT INTO PRECIOS3 VALUES (pv12, pz23, 20) opción 2
¿el proveedor pv12 existe

y es de la zona 3 y la
pieza pz23 existe?
SI NO
INSERT INTO PRECIOS error

VALUES (pv12, pz23, 20)

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

Bases de Datos Deductivas
notación
ESQUEMA BASE DE DATOS
algebraic
a
Relaciones básicas: Ri  (Di1 x Di2 x ... x Din )
i
Ri (Ai1: Di1, Ai2: Di2 ..., Ain : Din ) (1 i m)

i i
(1 i m) (m relaciones básicas) Sij (x1, x2,..., xni )  Wij

(1 i s)
(1 j Ki) notación
Si (Ai1: Di1, Ai2: Di2 , ..., Ain : Din )
i i lógica

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:
pieza (pz1, tornillo, 10)

Base de datos deductiva
...
Hechos
prov (pv1, Juan, 1)

...
comp (pz1, pz3)

...
Reglas deductivas
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) )

Lenguaje de definición de reglas
Lenguaje de 1er orden
Base de datos deductiva Programa lógico
Sistema de gestión
Sistema de programación
de bases de datos
lógica
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)

BASE DE DATOS BDD (programa lógico)
Ri  (Di1 x Di2 x ... x Din )

i {A: A es un átomo base}
(1 i m)

Sij (x1, x2,..., xni )  Wij { A L1  L2 ...  Ln: A es un átomo y Li es un literal}
(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)

Esquema: (L, RI) :

Lenguaje L
Constantes Unión de los dominios de definición de

las relaciones del esquema
Predicados Nombres de relación del esquema
Fórmulas bien
RI
Restricciones de Integridad (RI) formadas (f.b.f) de L

Esquema: (L, RI) :
Constantes: D1 D2 D3 D4 D5 D6 D7

= {pz1, pz3, …, tornillo, tuerca, …, pv1, pv5, ..., Juan,…}
Lenguaje L
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:
Fórmulas bien
RI
x y ( componente (x,y)   componente (y,x) ) formadas de L

BDD:
{ pieza (pz1, tornillo, 10), ...,
proveedor (pv1, Juan, 1), ..., Fórmulas bien
Hechos precios (pv1, pz3, 100), ..., formadas de L
comp (pz1, pz3), ... }

precios3 (x, y,z)  precios (x, y, z)  prov (x, w, 3)
Reglas componente (x, y)  comp (x,z)  componente (z, y)
deductivas 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)

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

componente (pz1,w) Procedimiento
SLDNF
¿ De qué piezas se compone la pieza pz1?
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)
z’/pz8 hecho
w/pz8
hecho
componente ( pz8,w)
2 3
comp (pz8,z ‘‘)  componente (z ‘‘,w) comp (pz8,w)
w = pz3
w = pz8
2 componente (x, y) comp (x, z)  componente (z, y)
3 componente (x, y) comp (x, y)

componente (pz1,w) Procedimiento
SLDNF
¿ De qué piezas se compone la pieza pz1?
resolución componente (x,y) comp (x,z)  componente (z,y) regla 2

x/pz1 y/w
comp (pz1,z)  componente (z,w)

comp (pz1,pz3) hecho
z/pz3
resolución
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
éxito w/pz8

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

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
D precios (pv1, pz1, 30) SLDNF infiere consecuencias lógicas de comp(D)

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

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), ...,
Axiomas de proveedor (pv1, Juan, 1), ...,
hechos precios (pv1, pz3, 100), ...,
comp (pz1, pz3), ... }

precios3 (x, y,z)  precios (x, y, z)  prov (x, w, 3)
Axiomas de componente (x, y)  comp (x,z)  componente (z, y)

reglas 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)


x y z pieza (x, y, z) (x= pz1 y= tornillo  z=10)

(x= pz3 y= tuerca  z=11)

Axiomas de (x= pz8 y= arandela  z=8)
compleción ...
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))

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) ) Axiomas sobre p en D
p(x1,..., xn)  Ek ,
x1, ..., xn ( p(x1, ..., xn)  (E1  ...  Ek) ), Axiomas de compleción de p
x1, ..., xn ¬ p(x1, ..., xn): no existen sentencias de p en D
x =(x, x), Axiomas de la igualdad

¬ =(A, B), ¬ =(A, C), ¬ =(A, a), ..., ¬ =(P100, P200)
x (=(x, A)  =(x, B)  ...  =(x, P200)) } Axioma de cierre de dominio

BDD PL
hechos >>> reglas hechos ~ reglas
relaciones de D:
- básicas predicados de P
- derivadas
lenguaje libre de funciones no
hechos y reglas son

no
independientes del dominio
tiempo de acceso tiempo del

eficiencia  eficiencia 
a los datos sistema de inferencia

5. SGBD deductivos.
5.2. SQL3

3. Actualización de vistas
3.1 Introducción al problema.
Actualización sobre Actualización(es) sobre

relación derivada 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

PIEZA
codpieza desc peso
pz1 tornillo 10
pz3 tuerca 11
pz8 arandela 8
PRECIOS_EXT
PRECIOS
codprov nombre codpieza desc precio
codprov codpieza precio
pv1 Juan... pz3 tuerca 10
pv1 pz3 10
pv1 Juan... pz8 arandela 20
pv1 pz8 20 pv3 Luis... pz8 arandela 30
pv3 pz8 30 pv5 Carlos.. pz1 tornillo 50
pv5 pz1 50 .
PROV
T1={borrar (PROV (pv1,Juan,1))}
codprov nombre zona
T2={borrar (PIEZA (pz3,tuerca,11),
pv1 Juan..... 1 borrar (PIEZA (pz8,arandela,8))}
pv5 Carlos .... 3 T3={borrar (PRECIOS (pv1,pz3,10),
pv3 Luis ...... 3
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

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

BDD: 1. q(x)  ¬r(x)  p(x)
2. q(x)  s(x)
Act: borrar(q(a)) p(a)

q(a)
1 2
resolución
¬ r(a)  p(a) s(a)
r(a) NF
p(a) T1 = { insertar (r(a)) }

p(a) resolución T2 = { borrar (p(a)) }

Act: insertar(p(a))
BDD: 1. p(x)  ¬q(x)  f(x)
2. p(x)  s(x)  n(x)  p(a)
3. s(x)  r(x) 1 2
resolución
4. s(x)  t(x)  ¬m(x)  ¬q(a)  f(a)  s(a)  n(a)
r(a), q(a), m(a) 3 4

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

Ejemplo 1
1. p(x)  q(x)  t(x) Actualización: U = p(1)
2. p(x)  w(x)  v(x)
3. t(x)  s(x)  ¬r(x)
p(1)
1) {w(1), v(1)}  BDE
2) {q(1), s(1)}  BDE y {r(1)}  BDE
w(1) v(1) q(1) t(1) 3) {p(1)}  BDE
4) {q(1), t(1)}  BDE
q(1) s(1) r(1)
Obtener transacciones que aseguren

una de estas cuatro situaciones

Caracterización del problema:
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

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.

BDD: 1. p(x)  q(x,y)  t(x,y)
Ejemplo 2:
….
p(1) t(1,2)
1 resolución Actualización: U = p(1).
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)
Ejemplo 2:
….
p(1) t(1,2)
1 resolución Actualización: U = p(1).
q(1,y)  t(1,y) $y (q(1,y)  t(1,y))
{y/ nulo} {y/ c} {y/ 2}
T1 = { insertar(q(1,nulo)), T2 = { insertar(q(1, c)), T3 = { insertar(q(1,2))}

insertar(t(1,nulo))} insertar(t(1, c))}

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.

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.

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)
Ejemplo 4: 2. s(1,2)  q(1,2)
r(1,2)
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
T1 = { insertar( q(1,2)) } q(1,2)  BDE
s(1,2) s(1,2)
T1 no es una solución
correcta porque induce 2 2 resolución
resolución
la inserción de s(1,2)
que se había asumido q(1,2) q(1,2)
falsa en la construcción
de la solución. q(1,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.

Ejemplo 5: BDD: 1. p(x)  q(x)  r(x)
…
p(1)
W = x (r(x)  t(x))
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:
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) }

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

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

=  p*(1)
A4 p(1)} ’= {p*(1)}
4= {p*(1),s(1),t*(1)} C
q(1)r*(1),t(1)} ’= {p*(1)}

Derivación abductiva
C5
r(1) ’’= {p*(1)}
t(1)} ’= {p*(1),s(1)}
A1
C4
s(1) ’’= {p*(1)}
 ’= {p*(1),s(1),t*(1)}
A3
’’= {p*(1), s(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) }

BDE: s(1)
=  p(1)
A
=  t(1)
 T1 = { insertar(t(1)) }
A
= {t(1)}
=  p(1)
A
=  q(1)r*(1)
r(1)} ’= {q(1),r*(1)}
A3
 T2= {insertar(q(1)), borrar(s(1))}
= {q(1)} r*(1) C
A4 s(1)} ’= {q(1),r*(1)}
= {q(1),r*(1),s*(1)} C4
 ’= {q(1),r*(1),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) }
BDE: q(1)
=  p*(1)
Derivación de consistencia t(1)
A4 p(1)} ’= {p*(1)}
3= {p*(1),q*(1),t*(1)} C
q(1)r*(1),t(1)} ’= {p*(1)}
C4
 T3= {borrar(q(1)), borrar(t(1))}
t(1)} ’= {p*(1), q*(1)}
C4
} ’= {p*(1), q*(1),t*(1)}
=  p*(1)
A4 p(1)} ’= {p*(1)}
4= {p*(1),s(1),t*(1)} C
q(1)r*(1),t(1)} ’= {p*(1)}
C5
Derivación abductiva
r(1) ’’= {p*(1)}
 T4= {insertar(s(1)), borrar(t(1))}
t(1)} ’= {p*(1),s(1)}
A1
C4
s(1) ’’= {p*(1)}
 ’= {p*(1),s(1),t*(1)}
A3
’’= {p*(1), s(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.

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

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

s(1) T2’ = { borrar (s(1)) }
Éxito

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.

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

 s(1) T2’ = { insertar (s(1)) }
Fallo

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

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

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
D’ satisface W si y sólo si D’ satisface W’’
simplificación
$w $t (prov (pv11, w, t) es falso en D’ D’ viola W

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.

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

COMP COMPONENTE
pieza1 pieza2 pieza1 pieza2
pz1 pz3 pz1 pz3
pz3 pz8 pz3 pz8

pz1 pz8
Reglas deductivas:
COMPONENTE
COMPONENTE (x, y) COMP (x,z) COMPONENTE (z, y) pieza1 pieza2
COMPONENTE (x, y) COMP (x, y)
pz1 pz3
Transacción: {insertar (COMP(pz8,pz1))} pz3 pz8
pz1 pz8
COMP
pz8 pz1
pieza1 pieza2
Paso 1 pz8 pz3
pz1 pz3
pz8 pz8
pz3 pz8 pz1 pz1
pz8 pz1 pz3 pz1
pz3 pz3
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

 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

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‘ 0 = {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      , WDepartamento
no admitedesimplificación.
Sistemas Informáticos y Computación / Universidad Politécnica de Valencia 170
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).

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

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.
5.2. SQL3

5. SGBD deductivos
SGBD Mecanismo Extender un SGBD Relacional con

relacional de inferencia un mecanismo de inferencia para
evaluar vistas recursivas
Sistema de Gestión de hechos Extender un Sistema de

Programación en memoria Programación Lógica con un sistema
Lógica secundaria de gestión de los hechos en memoria
secundaria
Sistema de Acoplar (por medio de una

SGBD Programación
relacional interfaz) un SGBD Relacional y un
Lógica Sistema de Programación Lógica

5. SGBD deductivos
Mecanismo de vistas
del modelo relacional definición relaciones derivadas
(SQL92)
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

FROM COMP
UNION
FROM COMP, COMPONENTE
...................
evaluación
COMPONENTE  COMP
UNION
(COMP ((pieza2,X)) JOIN COMP ((pieza1,X) ) [pieza1, pieza2 ]
UNION
(COMP((pieza2,X)) JOIN COMP((pieza1,X), (pieza2, Y) ) JOIN COMP((pieza1,Y) ) [pieza1, pieza2 ]
UNION
(COMP((pieza2,X)) JOIN COMP((pieza1,X), (pieza2, Y) ) .................................................
UNION
...

5. SGBD deductivos
Relaciones básicas: Relaciones derivadas:

PIEZA (codpieza: D1, desc: D2, peso: D3) PRECIOS3 (codprov: D4, codpieza: D1, precio: D7)
CP = {codpieza} CP = {codprov, codpieza}
PROV (codprov: D4, nombre: D5, zona: D6) CAj = {codpieza}  PIEZA
CP = {codprov}
PRECIOS_EXT (codprov: D4, nombre: D5, codpieza: D1,
desc: D2, precio: D7)
PRECIOS (codprov: D4, codpieza: D1, precio: D7) CP = {codprov, codpieza}
CP = {codprov, codpieza} CAj = {codprov}  PROV
CAj = {codprov}  PROV CAj = {codpieza}  PIEZA
COMPONENTE (pieza1: D1, pieza2: D1)
COMP (pieza1: D1, pieza2: D1) CP = {pieza1, pieza2}
CP = {pieza1, pieza2} CAj = {pieza1}  PIEZA
CAj = {pieza1}  PIEZA CAj = {pieza2}  PIEZA
Restricciones de integridad:
x y ( COMPONENTE (x,y)   COMPONENTE (y,x) )
Esquema
5. SGBD deductivos
PIEZA PROV
BDD codpieza
pz1
desc
tornillo
peso
10
codprov
pv1
nombre
Juan.....
zona
: pz3 tuerca 11 pv5 Carlos .... 3
pz8 arandela 8 pv3 Luis ...... 3
PRECIOS COMP
codprov codpieza precio pieza1 pieza2
pv1 pz3 10 pz1 pz3
pv1 pz8 20 pz3 pz8
pv3 pz8 30
pv5 pz1 50
Reglas deductivas:
1 precios3 (x, y,z) precios (x, y, z)  prov (x, w, 3)

4 precios_ext (x,n,y,d,p) prov (x, n,_)pieza (y, d,_)precios (x, y, p)

5. SGBD deductivos
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
Generación de la información derivada

Paso1 (F*) aplicando las reglas deductivas al
conjunto de hechos (F)
Paso 2 Evaluación de la consulta en F  F*

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

FF1* Reglas F1*

PIEZA
PRECIOS_EXT
4
PROV
PRECIOS3
1
PRECIOS
Generación de la misma
PRECIOS_EXT PRECIOS3
información derivada en
cada iteración.

COMP COMPONENTE
pieza1pieza2
pieza2 pieza1 pieza2
pieza1 3
pz1
pz1 pz3 pz3 pz1 pz3
pz3
pz3 pz8 pz8 2
pz3 pz8
pz1 pz8
COMPONENTE
pieza1 pieza2
Generación de la misma
pz1 pz3 información derivada en
pz3 pz8 cada iteración.

5. SGBD deductivos
Estrategia bottom-up
Problemas:
 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

F Reglas F1*
PIEZA
PRECIOS
PROV
COMP COMPONENTE
pz1 pz3 3 pz1 pz3

pz3 pz8 pz3 pz8

COMP
pieza1pieza2
pieza1
pieza2 COMPONENTE
pz1
pz1 pz3 pz3 pieza1 pieza2
pz3
pz3 pz8 pz8 2
pz1 pz8
COMPONENTE
pieza1 pieza2
pz1 pz3
pz3 pz8

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 { H: existe una regla H  B en Dreglas y

una sustitución  para las variables de B,
tal que B es cierto en Mant }
hasta M = Mant
Paso 4: generar cualquier sustitución de las variables de Q tal que cualquier hecho
en Q 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.

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

1 {comp(pz1, pz3), comp(pz3, pz8)
{comp(pz1, pz3), comp(pz3, pz8)}
componente(pz1, pz3), componente(pz3, pz8)}
PROV PIEZA  PRECIOS

{comp(pz1, pz3), comp(pz3, pz8)
2 {comp(pz1, pz3), comp(pz3, pz8) componente(pz1, pz3), componente(pz3, pz8) }
componente(pz1, pz3), componente(pz3, pz8)}
{componente(pz1, pz3), componente(pz3, pz8)
componente (pz1, pz8)}

{comp(pz1, pz3), comp(pz3, pz8) {comp(pz1, pz3), comp(pz3, pz8)
componente(pz1, pz3), componente(pz3, pz8) componente(pz1, pz3), componente(pz3, pz8)
3
componente(pz1, pz8)} componente(pz1, pz8)} 
{componente(pz1, pz3), componente(pz3, pz8)

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 { H: existe una regla H  B en Dreglas y
una sustitución  para las variables de B,
tal que B es cierto en Mant y al menos un
hecho de B  está en Mdif }
Mdif  M - Mant
hasta Mdif = 
Paso 4: generar cualquier sustitución de las variables de Q tal que cualquier
hecho en Q sea cierto en M

Paso 1 Dreglas = {2,3 } Método SEMINAIVE
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),
1
{comp(pz1, pz3), comp(pz3, pz8)} {componente(pz1, pz3), componente(pz3, pz8)
componente(pz3, pz8) }

2 {comp(pz1, pz3), comp(pz3, pz8)} 
{comp(pz1, pz3), comp(pz3, pz8) componente (pz1, pz8)
{componente(pz1, pz3),
componente(pz1, pz3),
componente(pz3, pz8)
componente(pz3, pz8) }

3 {comp(pz1, pz3), comp(pz3, pz8) {comp(pz1, pz3), comp(pz3, pz8)
componente(pz1, pz3), componente(pz1, pz3),
componente(pz1, pz8) componente(pz1, pz8)
componente(pz1, pz8) } componente(pz1, pz8) }

D:
PIEZA PROV
codpieza desc peso codprov nombre zona
pz1 tornillo 10 pv1 Juan..... 1
pz3 tuerca 11 pv5 Carlos .... 3
pz8 arandela 8 pv3 Luis ...... 3
PRECIOS COMP
codprov codpieza precio pieza1 pieza2
pv1 pz3 10 pz1 pz3
pv1 pz8 20 pz3 pz8
pv3 pz8 30
pv5 pz1 50
Reglas deductivas:
1 precios3 (x, y,z) precios (x, y, z)  prov (x, w, 3)

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  PRECIOS3 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_EXT  COMPONENTE = COMPONENTE

ant ant

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
Reglas deductivas con
Naive y Seminaive: algoritmos definidos para

D:
negación
Hechos: q(1), r(1)
Reglas deductivas: 1. s(x)  r(x)
2. p(x)  q(x)  s(x)
reglas deductivas definidas

Paso 1: Dreglas= {1,2}
Paso 2: M = {q(1), r(1)} Algoritmo Naive
Paso 3:
Iteración. 1ª:
M = {q(1), r(1), s(1), p(1)}

Iteración 2ª:
M = {q(1), r(1), s(1), p(1)} Solución incorrecta

5. SGBD deductivos
aplicar el algoritmo (paso 3) por
Solución
niveles de reglas (estratificación de
la BDI)
p
Nivel 1 r q (hechos) 2 2
+ -
Nivel 2 s q s
Nivel 3 p + 1
r
Paso2:
En el Paso 3, en cada
Nivel 1 M = {q(1), r(1)} nivel se aplican sólo las
reglas que definen los
Paso3: predicados del nivel.
Nivel 2 Iteración. 1ª: M = {q(1), r(1), s(1)}
Nivel 3 Iteración 1ª: M = {q(1), r(1), s(1)}
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
cuenta las constantes de la consulta del usuario
Solución
Naive y Seminaive: algoritmos que no tienen en
Algoritmos muy complejos
¿cuáles son las componentes de la pieza pz1?

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)}
2. componente(pz1,y)  com(pz1,z) , componente(z,y) Reglas instanciadas por

3. componente (pz1,y)  comp (pz1,y) la consulta del usuario

5. SGBD deductivos
Generación de consultas derivadas
Estrategia top-down Paso 1 aplicando las reglas deductivas a la
consulta original
Evaluación de subconsultas sobre

relaciones básicas en la base de
Paso 2
datos explícita y propagación de
respuestas a la consulta original
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

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
3’ hecho
componente (z’, w)  comp ( z, z’)

 comp (pz1, z)
comp (z, w)  comp(pz1, z)
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

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)
SELECT recursiva que
AS (SELECT * FROM comp define la vista (relación
derivada)
UNION
SELECT C.pieza1, CP.pieza2
FROM comp C, componente CP
WHERE C.pieza2 = CP.pieza1)

Ly BD

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Ly BD

Загружено:

Авторское право:

Доступные форматы

Lógica

Matilde Celma Giménez

Departamento de Sistemas Informáticos y Computación / Universidad Politécnica de Valencia

Departamento de Sistemas Informáticos y Computación / Universidad Politécnica de Valencia 2

La idea básica que subyace al uso de la lógica para el

Departamento de Sistemas Informáticos y Computación / Universidad Politécnica de Valencia 3

- definición de lenguajes de consulta

- estudio del concepto de independencia del dominio

- comprobación y restauración de la integridad.

- diseño de bases de datos

Departamento de Sistemas Informáticos y Computación / Universidad Politécnica de Valencia 4

Modelo Relacional de Datos

Departamento de Sistemas Informáticos y Computación / Universidad Politécnica de Valencia 5

 esquema de tupla: t = {(A1, D1), (A2, D2), …, (An, Dn)}

• tupla t de esquema {(A1, D1), (A2, D2), …, (An, Dn)}:

Departamento de Sistemas Informáticos y Computación / Universidad Politécnica de Valencia 6

a21 a22 a23 ……… a2n representación representación del

Departamento de Sistemas Informáticos y Computación / Universidad Politécnica de Valencia 7

• Valor No Nulo (NOT NULL)

Departamento de Sistemas Informáticos y Computación / Universidad Politécnica de Valencia 8

Operadores del Álgebra Relacional:

Departamento de Sistemas Informáticos y Computación / Universidad Politécnica de Valencia 9

Departamento de Sistemas Informáticos y Computación / Universidad Politécnica de Valencia 11

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 El CRT, CRD y SQL son

Aproximación algebraica Aproximación lógica

Departamento de Sistemas Informáticos y Computación / Universidad Politécnica de Valencia 13

Formalización lógica de una base de datos

 Interpretación de un lenguaje de 1er orden

 Teoría de un lenguaje de 1er orden

Departamento de Sistemas Informáticos y Computación / Universidad Politécnica de Valencia 14

Departamento de Sistemas Informáticos y Computación / Universidad Politécnica de Valencia 15

Departamento de Sistemas Informáticos y Computación / Universidad Politécnica de Valencia 16

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 }  {=}

Restricciones de Integridad (RI)

Departamento de Sistemas Informáticos y Computación / Universidad Politécnica de Valencia 17

Dominio D Unión de los dominios de definición de las

D = {di : di  i (Di), Di es un dominio de S}

Asignación K : C  D / K = { (c, d): c  C, d  D, c  d}

Departamento de Sistemas Informáticos y Computación / Universidad Politécnica de Valencia 18

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

Departamento de Sistemas Informáticos y Computación / Universidad Politécnica de Valencia 19

Dominio D Unión de los dominios de definición de las relaciones del

D = {di : di  i (Di), Di es un dominio de S}

Asignación E : P  i:1..n ( 2Di ) / E(pk)  (2Dk), E(pk) = Ext(p)

En la definición de la interpretación I de L, hemos definido el dominio como la

Departamento de Sistemas Informáticos y Computación / Universidad Politécnica de Valencia 20

Constantes: dom_P dom_A dom_C

Predicados: { Profesor(.), Alumno(.), Curso(.), Enseña(.,.), Matriculado(.,.)}  {=}

x ( curso (x)  $ y enseña (y,x) ) formada de L

Departamento de Sistemas Informáticos y Computación / Universidad Politécnica de Valencia 21

D = {A, B, C, a, b, c, d, CS100, CS200, P100, P200}

E (Profesor) E (Alumno) E (Curso) E (Matriculado) E (Enseña)

A a CS100 a CS100 A CS100

Departamento de Sistemas Informáticos y Computación / Universidad Politécnica de Valencia 22

D = {A, B, C, a, b, c, d, CS100, CS200, P100, P200}

E (Profesor) E (Alumno) E (Curso) E (Matriculado) E (Enseña)