Deductive Databases


















How do you evaluate facts, rules, and queries using database operations?

Suppose you are given this input to evaluate.

	Schemes:
	   f(A,B)
	   b(C,D)

	Facts:
	   f('1','1').
	   f('1','2').
	   f('2','3').

	Rules:
	   b(X,Y) :- f(X,Z), f(Z,Y).

	Queries:
	   b('1',X)?


















Schemes

What do you do with the Schemes?

	   f(A,B)
	   b(C,D)

	1. create empty relation 'f' with attributes A and B

	2. create empty relation 'b' with attributes C and D


















Facts

What do you do with the Facts?

	   f('1','1').
	   f('1','2').
	   f('2','3').

	for each fact, create a tuple in the appropriate relation

	      f
	     A B
	     1 1
	     1 2
	     2 3


















Rules

What do you do with the Rule?

	   b(X,Y) :- f(X,Z), f(Z,Y).

	Make new tuples in 'b' using tuples in 'f'.

What new tuples does the rule create in 'b' ?
(We'll see the details of how to do this in few minutes.)

	      b
	     C D
	     1 1
	     1 2
	     1 3


















Queries

What do you do with the Query?

	   b('1',X)?

	1. Use the relation with the same name as the query.
	2. Select the tuples that match the query.
	3. Project the positions of the variables in the query.
	4. Rename to match the names in the query.

	rename[X] project[D] select[C='1'] (b)

What would be the result of the Query?


















Relational Algebra for Rules

How do you use database operations to implement a rule?


What do you do with each predicate in the rule body?

	   b(X,Y) :- f(X,Z), f(Z,Y).

	      f
	     A B
	     1 1
	     1 2
	     2 3

	Process each predicate like a query (select, project, rename).

What's the result for the predicates in this rule?

	rename[XZ](f)  rename[ZY](f)
	     X Z           Z Y
	     1 1           1 1
	     1 2           1 2
	     2 3           2 3


How do you combine the relations from the rule body?
What's the result of the join?

	   b(X,Y) :- f(X,Z), f(Z,Y).

	X Z Y
	1 1 1
	1 1 2
	1 2 3


What do you do with the result of the Join?

	   b(X,Y) :- f(X,Z), f(Z,Y).

	X Z Y
	1 1 1
	1 1 2
	1 2 3

	Project using the variables from the rule's head

	project[XY](join-result)


What do you do with the result of the project?

	X Y
	1 1
	1 2
	1 3

	Union with the relation 'b'


What needs to be done before the Union with 'b'?

	   b(X,Y) :- f(X,Z), f(Z,Y).

	 b
	C D    X Y
	       1 1
	       1 2
	       1 3

	Rename to be union-compatible with 'b'

	rename[CD](project-result)


















Write relational algebra expressions for the rules.

	Schemes:
	   f(A,B)
	   a(C,D)
	   b(E,F)

	Rules:
	   a(X,Y) :- f(X,Y).
	   a(X,Y) :- f(X,Z), b(Z,Y).


















Classwork
You may work with a partner.

Write a relational algebra expression for the rule.

	Schemes:
	   g(A)
	   a(C,D)
	   b(E,F)

	Rules:
	   b(X,Y) :- g(Y), a(X,Y).


















Recursive Rules

How do you know which order you should use to execute recursive rules?

	Rules:
	   a(X,Y) :- f(X,Y).
	   b(X,Y) :- g(Y), a(X,Y).
	   a(X,Y) :- f(X,Z), b(Z,Y).

	no order for rule execution guarantees producing all the tuples

If there is no correct order, how do you execute the rules?

	Repeatedly execute the rules in any order.
	Quit when no new tuples are created.
	(when no tuples are added to any relations)

	Changes = TRUE;
	while Changes {
	   Changes = FALSE;
	   for each rule R {
	      execute the relational algebra for rule R
	      If rule R added tuples to any relation
	          Changes = TRUE;
	   }
	}

Why is this called a Fixed-Point algorithm?


















Rule Evaluation Example

Show the steps for evaluating the code.

	Schemes:
	   f(A,B)
	   g(A)
	   a(C,D)
	   b(C,D)
	Facts:
	   f('1','2').
	   f('2','3').
	   f('3','4').
	   f('3','2').
	   g('1').
	   g('2').
	   g('3').
	Rules:
	   a(X,Y) :- f(X,Z), b(Z,Y).
	   b(X,Y) :- g(Y), a(X,Y).
	   a(X,Y) :- f(X,Y).
	Queries:
	   b('2','3')? 

What are the relations and initial contents obtained from the Schemes and Facts?

	Schemes:
	   f(A,B)
	   g(A)
	   a(C,D)
	   b(C,D)

	Facts:
	   f('1','2').
	   f('2','3').
	   f('3','4').
	   f('3','2').
	   g('1').
	   g('2').
	   g('3').


















What happens on the first iteration?

	a(X,Y) :- f(X,Z), b(Z,Y).

	b(X,Y) :- g(Y), a(X,Y).

	a(X,Y) :- f(X,Y).

      f      g     a      b
     A B     A    C D    C D
     1 2     1    
     2 3     2    
     3 4     3    
     3 2          

Does the algorithm stop or continue?


















What happens on the second iteration?

	a(X,Y) :- f(X,Z), b(Z,Y).

	b(X,Y) :- g(Y), a(X,Y).

	g |X| a
	 X   Y 
	 1   2
	 2   3
	 3   2

	a(X,Y) :- f(X,Y).

      f      g     a      b
     A B     A    C D    C D
     1 2     1    1 2    
     2 3     2    2 3    
     3 4     3    3 4    
     3 2          3 2


















Classwork
You may work with a partner.

What happens on the third iteration?
Give the tuples added by the third iteration over the rules.
(Use only tuples from previous iterations
when applying the rules to create new tuples.)

	a(X,Y) :- f(X,Z), b(Z,Y).

	f |X| b
	 X Z Y
	 1 2 3
	 2 3 2
	 3 2 3

	b(X,Y) :- g(Y), a(X,Y).

	a(X,Y) :- f(X,Y).

      f      g     a      b
     A B     A    C D    C D
     1 2     1    1 2    1 2
     2 3     2    2 3    2 3
     3 4     3    3 4    3 2
     3 2          3 2    













                  
                  
                  


What happens on the fourth iteration?

	a(X,Y) :- f(X,Z), b(Z,Y).

	b(X,Y) :- g(Y), a(X,Y).

	g |X| a
	 X   Y 
	 1   2
	 2   3
	 3   2
	 1   3
	 2   2
	 3   3
 
	a(X,Y) :- f(X,Y).

      f      g     a      b
     A B     A    C D    C D
     1 2     1    1 2    1 2
     2 3     2    2 3    2 3
     3 4     3    3 4    3 2
     3 2          3 2    













                  
                  
                  


What happens on the fifth iteration?

	No changes to any relations.