ELFE - Cours 4

Contenu
Requêtes relationnelles en Datalog
Opérations de l’algèbre relationnelle
ELFE - Cours 4
Requêtes relationnelles en Datalog
Satisfaisabilité de formules booléennes en Datalog
Fonctionnalités supplémentaires en DES
Agregation
Groupage
Chemin le plus court : Datalog et SQL
C. Kuttler
Licence 3 informatique, Université Lille
Les formules booléennes en Datalog
Le problème
Premier codage de formules booléennes en Datalog
Qui est l’assassin ?
24 janvier 2013
2 / 35
1 / 35
Datalog et l’algèbre relationnelle
Exemple : schéma du TP5 BDD
I
I
I
I
I
les mêmes relations qu’on peut définir en algèbre relationnelle,
ou SQL, peuvent être définies en Datalog
I
Nous supposons un nom de relation (symbole de prédicat) r
en Datalog, pour chaque tableau R
I
Nous montrons comment exprimer, en Datalog, des requêtes
sur une base de données relationnelle, du type
SELECT-FROM-WHERE, ou des requêtes en algèbre
relationnelle
articles(aid : int, anom : string , acoul : string )
fournisseurs(fid : int, fnom : string , fad : string )
catalogue(fid : int, aid : int, prix : real)
declaration de types (create table) + ajout a la EDB (inserts) :
:− t y p e ( a r t i c l e s ( a i d : i n t , anom : s t r i n g , a c o u l : s t r i n g ) ) .
:− t y p e ( f o u r n i s s e u r s ( f i d : i n t , fnom : s t r i n g , f a d : s t r i n g ) ) .
:− t y p e ( c a t a l o g u e ( f i d : i n t , a i d : i n t , p r i x : r e a l ) ) .
a r t i c l e s ( 1 , ’ L e f t Handed Toaster Cover ’ , ’ rouge ’ ) .
a r t i c l e s ( 2 , ’Smoke S h i f t e r End ’ , ’ n o i r ’ ) .
...
f o u r n i s s e u r s ( 1 , ’ k i v e n t o u t ’ , ’ 59 rue du Chti ,
F−75001 P a r i s ’ ) .
f o u r n i s s e u r s ( 2 , ’ Big Red Tool and Die ’ , ’ 4 My Way,
Bermuda Shorts , OR 90305 , USA ’ ) .
...
catalogue (1 ,1 ,36.10).
catalogue (1 ,2 ,42.30).
3 / 35
4 / 35
Projection πAcoul (Articles)
Selection σ
Afficher toutes les couleurs d’articles
Afficher tous les articles rouges
c o u l e u r (C) :− a r t i c l e s ( , , C ) .
a r t r o u g e (Anom)
:− a r t i c l e s ( Aid , Anom , A c o u l ) , A c o u l= ’ rouge ’ .
Résultat :
DES> c o u l e u r (X)
{
c o u l e u r ( a r g e n t e ) , c o u l e u r ( cyan ) ,
c o u l e u r ( magenta ) , c o u l e u r ( n o i r ) ,
c o u l e u r ( opaque ) , c o u l e u r ( r o u g e ) ,
couleur ( superjaune ) , couleur ( vert )
}
I n f o : 8 t u p l e s computed .
a r t v e r t (Anom)
:− a r t i c l e s ( Aid , Anom , A c o u l ) , A c o u l= ’ v e r t ’ .
SQL :
CREATE VIEW a r t r o u g e as
SELECT anom FROM a r t i c l e s WHERE a c o u l= ’ rouge ’
CREATE VIEW a r t v e r t as
SELECT anom FROM a r t i c l e s WHERE a c o u l= ’ v e r t ’
CREATE VIEW c o u l e u r AS
SELECT a c o u l FROM c a t a l o g u e
5 / 35
Jointure
6 / 35
Produit cartésien
toutes les combinaisons de fournisseurs et articles.
Règle :
c a r t (Anom , Fnom ) :−
a r t i c l e s ( , Anom , ) , f o u r n i s s e u r s ( , Fnom , ) .
Qui vend quel article a quel prix ?
t o u t (Anom , Acoul , Fnom , P r i x )
:− a r t i c l e s ( Aid , Anom , A c o u l ) ,
c a t a l o g u e ( Fid , Aid , P r i x ) ,
f o u r n i s s e u r s ( Fid , Fnom , ) .
Requête et résultat :
DES> c a r t (X , Y)
{ c a r t ( ’ 7 Segment D i s p l a y ’
c a r t ( ’ 7 Segment D i s p l a y ’
...
c a r t ( ’Smoke S h i f t e r End ’
c a r t ( ’Smoke S h i f t e r End ’
I n f o : 54 t u p l e s computed .
SELECT anom , a c o u l , fnom , p r i x
FROM ( a r t i c l e s j o i n c a t a l o g u e u s i n g a i d )
j o i n f o u r n i s s e u r s using f i d
, ’ Alien Aircaft Inc . ’ ) ,
, ’ Autolux ’ ) ,
, ’ Vendrien ’ ) ,
, k i v e n t o u t )}
SELECT anom , fnom FROM a r t i c l e s , f o u r n i s s e u r s
7 / 35
8 / 35
Intersection
Différence
articles existant en rouge et en vert
les articles existant en rouge, mais pas en vert
r o u g e e t v e r t (X) :− a r t r o u g e (X ) , a r t v e r t (X ) .
r o u g e p a s v e r t (X) :−
a r t r o u g e (X ) , not ( a r t v e r t (X ) ) .
c r e a t e view r o u g e e t v e r t as
(
art rouge intersect art vert
)
CREATE VIEW r o u g e p a s v e r t AS
( a r t r o u g e MINUS a r t v e r t )
9 / 35
Union
Quantification existentielle
les articles rouges ou verts
r o u g e o u v e r t (X) :−
r o u g e o u v e r t (X) :−
10 / 35
Articles offerts par au moins un fournisseur
a r t r o u g e (X ) .
a r t v e r t (X ) .
vendu (Anom) :−
c a t a l o g u e ( , Aid , ) , a r t i c l e s ( Aid , Anom , ) .
CREATE VIEW r o u g e o u v e r t AS
( a r t r o u g e UNION a r t v e r t )
SELECT anom FROM a r t i c l e s a WHERE e x i s t s
( s e l e c t ∗ from c a t a l o g u e c where c . a i d=a . a i d )
11 / 35
12 / 35
Quantification universelle
Fonctionnalités supplémentaires de DES
Les opérations montrées jusqu’ici peuvent être faites avec
n’importe quel DATALOG.
Pour augmenter son attractivité, DES offre :
Il faut passer par la négation, et donc des strates d’ordre supérieur.
I
fonctions d’agrégation
I
group by
I
group by - having
I
jointures externes
13 / 35
Agrégation
14 / 35
Exemples
Profitez de la doc :
DES> / h e l p c o u n t
∗ Aggregate Functions :
c o u n t /1
Count b u t n u l l s w r t . i t s argument .
R e t u r n s an i n t e g e r
∗ Predicates :
c o u n t /3
A g g r e g a t e r e t u r n i n g t h e number o f t h e t u p l e s
i n a r e l a t i o n w r t . an argument , i g n o r i n g n u l l s
c o u n t /2
A g g r e g a t e r e t u r n i n g t h e number o f t h e t u p l e s
i n a r e l a t i o n ( c f . SQL ’ s COUNT( ∗ ) )
DES implémente les fonctions d’agrégation habituelles
I
count - COUNT (∗)
I
count(Var) - COUNT (Column)
I
min
I
max
I
sum
I
avg
Versions avec 1,2 ou 3 arguments a utiliser dans différents
contextes.
15 / 35
16 / 35
count/2
Exemple : count/3
Paramètres :
1. requête
2. compter cette variable
3. associer résultat a cette variable
Combien d’articles rouges ?
Combien d’articles ?
DES> c o u n t ( a r t i c l e s ( , , ) , C)
c o m b i e n r o u g e (R): −
c o u n t ( a r t i c l e s ( Aid , , ’ rouge ’ ) , Aid , R ) .
Info : Processing :
a n s w e r (C) :−
count ( a r t i c l e s ( , , ) , [ ] , C ) .
{
answer (13)
}
I n f o : 1 t u p l e computed .
Requête et résultat :
DES> c o m b i e n r o u g e (R)
{ combien rouge (5) }
I n f o : 1 t u p l e computed .
SQL :
SELECT count ( ∗ ) as R
FROM a r t i c l e s
WHERE a c o u l= ’ rouge ’
17 / 35
Prix moyen du fournisseur X (avg/3)
18 / 35
Prédicat de groupage de DES : syntaxe
p r i x m o y e n f i d (X , R) :−
avg ( c a t a l o g u e (X , , P ) , P , R ) .
group by /3 :
Requete : prix moyen du fournisseur 1
group by (
Relation A ,
[ Var 1 , . . . , V a r n ] ,
C
)
DES> p r i x m o y e n ( 1 , P)
SQL : prix moyen du fournisseur 1
SELECT avg ( p r i x )
FROM c a t a l o g u e
WHERE f i d = 1
19 / 35
% FROM
% a t t r i b u t s de g r o u p a g e
% HAVING / p r o j e c t i o n
20 / 35
Prix moyen par fournisseur (group by + avg/1)
Nombre d’articles par couleur (group by + count /1)
p r i x m o y e n ( Fid , Pmo) :−
g r o u p b y ( c a t a l o g u e ( Fid , Aid , P ) ,
[ Fid ] ,
Pmo=avg (P ) ) .
c o u l (C , R) :−
g r o u p b y ( a r t i c l e s (A , N, C ) ,
[C] ,
R=c o u n t ) .
DES> p r i x m o y e n ( F , P)
{ prixmoyen (1 ,19585.389166666668) ,
prixmoyen (2 ,8.333333333333334) ,
prixmoyen ( 3 , 6 . 7 5 ) ,
prixmoyen (4 ,42.699999999999996) ,
prixmoyen (5 ,234555.67)}
I n f o : 5 t u p l e s computed .
Requête et résultat :
DES> c o u l (C , R)
{ coul ( argente , 1 ) , . . .
coul ( vert ,2)}
I n f o : 8 t u p l e s computed .
SELECT f i d , avg ( p r i x )
FROM c a t a l o g u e
GROUP BY f i d
21 / 35
Couleur avec plus de 2 articles (group by-count-TEST)
22 / 35
Chemin le plus court en datalog
c o u l 2 (C) :−
group by (
a r t i c l e s (A , N, C ) ,
[C] ,
(R=count , R>2)
).
p a t h (X , Y , 1 ) :− edge (X , Y ) .
p a t h (X , Y , L ) :−
p a t h (X , Z , L0 ) ,
edge ( Z , Y) ,
c o u n t ( edge (A , B ) , Max ) ,
L0<Max ,
L i s L0 +1.
Résultat :
DES> c o u l 2 (X)
{ coul 2 ( rouge ) }
I n f o : 1 t u p l e computed .
% requete :
s h o r t e s t p a t h s (X , Y , L ) :−
min ( p a t h (X , Y , Z ) , Z , L ) .
SELECT a c o u l
FROM a r t i c l e s
GROUP BY a c o u l
HAVING count (∗) >2
La condition L < 0 assure la terminaison (elle interdit de boucler
infiniment dans un cycle).
23 / 35
24 / 35
CREATE OR REPLACE VIEW
s h o r t e s t p a t h s ( O r i g i n , D e s t i n a t i o n , L e n g t h ) AS
WITH RECURSIVE
p a t h ( O r i g i n , D e s t i n a t i o n , L e n g t h ) AS
(SELECT edge . ∗ , 1 FROM edge )
UNION
(SELECT
p a t h . O r i g i n , edge . D e s t i n a t i o n , p a t h . L e n g t h+1
FROM path , edge
WHERE p a t h . D e s t i n a t i o n=edge . O r i g i n
and p a t h . L e n g t h <
(SELECT COUNT( ∗ ) FROM Edge )
)
SELECT O r i g i n , D e s t i n a t i o n ,MIN( L e n g t h )
FROM p a t h
GROUP BY O r i g i n , D e s t i n a t i o n ;
La clause WHERE en SQL
I
renvoie, pour un tuple du tableau, soit vrai, soit faux
I
est donc une condition/formule booléenne
I
les formules booléennes ne sont pas triviales a coder
I
tester la satisfaisabilité d’une formule booléenne est un
problème difficile (connu sous SAT)
% r e q u e t e en SQL
SELECT ∗ FROM s h o r t e s t p a t h s ;
25 / 35
Satisfaisabilité d’une formule booléenne (SAT)
26 / 35
Formules booléennes et Datalog
I
I
la question s’il existe une interprétation, qui rend cette
formule vraie
I
Datalog sait aussi bien trouver que vérifier des solutions a des
problèmes.
Pour pouvoir résoudre une problème logique, il faut savoir
interprétation : association de valeurs aux variables
I
I
ce problème est NP-complet (algo en M1)
I
I
on peut vérifier rapidement une solution
I
I
I
on ne sait pas trouver les solutions efficacement, quand la
taille des formules augmente
Datalog nous rend la solution.
Ce que nous faisons :
I
I
27 / 35
d’abord l’exprimer en logique booléenne,
puis le coder en Datalog
un puzzle logique, puis son codage en logique, puis en Datalog
préliminaire : codage systématique d’un formule booléenne, en
Datalog
28 / 35
(A or not B) and (A or not C) and (B or C) and not A
Un meurtre (1/2)
bool ( 0 ) .
bool ( 1 ) .
Connaissances autour d’un meurtre :
M1 Si Jean n’a pas rencontré Pierre, alors soit Pierre est
l’assassin, ou Jean est un menteur.
p1 (A , B , C) :− A=1, b o o l (A ) , b o o l (B ) , b o o l (C ) .
p1 (A , B , C) :− B=0, b o o l (A ) , b o o l (B ) , b o o l (C ) .
M2 Si Pierre n’est pas l’assassin, alors Jean n’a pas rencontré
Pierre, et le délit a eu lieu après minuit.
p2 (A , B , C) :− A=1, b o o l (A ) , b o o l (B ) , b o o l (C ) .
p2 (A , B , C) :− C=0, b o o l (A ) , b o o l (B ) , b o o l (C ) .
M3 Si le délit a eu lieu après minuit, alors Pierre est l’assassin, ou
Jean n’est pas un menteur.
p3 (A , B , C) :− B=1, b o o l (A ) , b o o l (B ) , b o o l (C ) .
p3 (A , B , C) :− C=1, b o o l (A ) , b o o l (B ) , b o o l (C ) .
Modélisation en logique propositionnelle :
Variables propositionnelles :
p4 (A , B , C) :− A=0, b o o l (A ) , b o o l (B ) , b o o l (C ) .
r (A , B , C) :− p1 (A , B , C ) , p2 (A , B , C ) , p3 (A , B , C ) , p4 (A , B , C ) .
s a t (A , B , C) :− r (A , B , C ) , b o o l (A ) , b o o l (B) , b o o l (C ) .
I
A : Jean a rencontré Pierre
I
B : Pierre est l’assassin
I
C : Jean est un menteur
I
D : le délit a eu lieu après minuit.
29 / 35
Un meurtre (1/2)
Un meurtre (1/2)
Modélisation en logique propositionnelle :
Formalisation
Variables propositionnelles :
I
A : Jean a rencontré Pierre
I
B : Pierre est l’assassin
I
C : Jean est un menteur
I
D : le délit a eu lieu après minuit.
30 / 35
Conjonction des formules propositionnelles M1,M2 et M3
M1 not A ⇒ (B or C )
M2 not B ⇒ (not(A) and D)
M3 D ⇒ (B or not(C ))
Réécriture sans implication
Formalisation
Conjonction des formules propositionnelles M1,M2 et M3
M1 A or B or C
M1 not A ⇒ (B or C )
M2 B or (not(A) and D)
M2 not B ⇒ (not(A) and D)
M3 not(D) or B or not(C )
M3 D ⇒ (B or not(C ))
31 / 35
32 / 35
M1 A or B or C
M2 B or (not(A) and D)
M3 B or not(C ) or not(D)
La solution
bool ( 0 ) .
bool ( 1 ) .
m1(A , B , C) :− A=1,
m1(A , B , C) :− B=1,
m1(A , B , C) :− C=1,
b o o l (A ) , b o o l (B) , b o o l (C ) .
b o o l (A ) , b o o l (B) , b o o l (C ) .
b o o l (A) , b o o l (B) , b o o l (C ) .
I
A : Jean a rencontré Pierre
I
B : Pierre est l’assassin
I
C : Jean est un menteur
I
D : le délit a eu lieu après minuit.
DES> s o l (A , B , C ,D)
m2(A , B ,D) :− B=1,
b o o l (A ) , b o o l (B) , b o o l (D ) .
m2(A , B ,D) :− A=0,D=1, b o o l (A ) , b o o l (B) , b o o l (D ) .
{
m3(B , C ,D) :− B=1,
m3(B , C ,D) :− C=0,
m3(B , C ,D) :− D=0,
}
I n f o : 2 t u p l e s computed .
sol 1 (1 ,1 ,0 ,0) ,
sol 1 (1 ,1 ,1 ,0)
b o o l (B ) , b o o l (C ) , b o o l (D ) .
b o o l (B) , b o o l (C ) , b o o l (D ) .
b o o l (B ) , b o o l (C ) , b o o l (D ) .
s o l (A , B , C ,D) :− m1(A , B , C ) , m2(A , B , D) , m3(B , C , D ) .
33 / 35
Question
Pensez-vous qu’il est possible de coder la logique booléenne en
Datalog,
I
avec une seule clause non-récursive
I
et plusieurs faits ?
Si oui, on pourrait écrire le puzzle logique en SQL avec une
requête conjonctive.
Peut-on écrire un puzzle logique sous une telle forme ?
Si oui, les requêtes les plus simples en SQL seraient dures.
35 / 35
34 / 35