Home -> Usenet -> comp.databases.theory -> Re: compound propositions

Re: compound propositions

From: David BL <davidbl_at_iinet.net.au>
Date: Tue, 16 Mar 2010 21:55:21 -0700 (PDT)
Message-ID: <cd2e6585-8e40-4922-866c-b9b70be9242b_at_p3g2000pra.googlegroups.com> 






On Mar 17, 1:18 am, paul c <toledobythe..._at_oohay.ac> wrote:



> The only comment I have right now is that I don't think


> databases have base relations!  Whether a relation is base seems to

> depend on a particular usage, such as within an algebraic expression. So

>    a relation might be 'base' in one program and not in another even

> though both involve the same database.





I wonder whether this might be connected with the issue of how to deal
with partial information, the view update problem, and the CWA.



Consider the following 3 predicates:


P1(S) =  Supplier S is on the northside
P2(S) =  Supplier S is on the southside
P3(S) =  S is a supplier





Assuming the CWA, we require P3 = P1 or P2.  Rather than think of P3
as derived, let P1, P2, P3 be represented using base relations R1, R2,
R3.  Then P3 = P1 or P2 becomes an *integrity constraint* - i.e. R3 =
R1 union R2.



It is not permissible to insert a tuple into R3, without adding a
tuple into either R1 or R2 at the same time (but we cannot know which
because of ambiguity).  A transaction is aborted if it fails to meet
the integrity constraint.  The ambiguity doesn't occur when inserting
a tuple into R1 or R2, but nevertheless it is necessary to also insert
a tuple into R3 or else the transaction will fail.   So what does
treating R3 as a base relation buy you?  Nothing good that I can see.



Now consider instead that we allow for partial information.  Consider
the predicates as follows:


P1'(S) =  It is known that supplier S is on the northside
P2'(S) =  It is known that supplier S is on the southside
P3'(S) =  It is known that S is a supplier





Let's assume the following


P1'(S)  =>  P1(S)
P2'(S)  =>  P2(S)
P3'(S)  =>  P3(S)
P1'(S)  =>  P3'(S)
P2'(S)  =>  P3'(S)





Note that we don't require   P3' = P1' or P2'.   Therefore we have a
very different integrity constraint from before:



R1' is subset of R3'


R2' is subset of R3'



Transactions can meet this constraint by following these rules:



    
  
  1.   Insert tuple into R1' => insert tuple into R3'
  
  2.   Insert tuple into R2' => insert tuple into R3'






In contrast to before, it is allowable to insert a tuple into R3'
without inserting a corresponding tuple into either R1' or R2'.
Received on Wed Mar 17 2010 - 05:55:21 CET












Original text of this message