In a message dated 3/22/2012 6:02:00 PM Central Daylight Time, 
[email protected] writes: 
> Question 1 ****************************
> Dr. Codd appears to be freeing us from having to indicate 'levels' with
> column structures. In his text:
> 
> "... Q1, Q2, ...,Qn denote immediate properties of each particular
> SUBORDINATION"
> 
> So in his construction, these might be reasonable values for Qx:
> 
> Q1: Quantity of SUB_P# in SUP_P#
> Q2: Joining method (threading, welding, painting)
> Q3: Resultant Weight
> 

Okay, I understand that.  In my table, I have a "Q1" table that indicates
the quantity of the subpart in the upper level part.


> 
> Question 2 *****************************
> 
> That's a thought of mine, extrapolating from yesterday's 'SQL Help'
> example and a few snippets from Dr. Codd. (Let's just say I'm hopeful).
> 
> " I claim to have a solution to the general bill-of-materials problem,
> one that is very concise, that protects the user from iterative and
> recursive programming, and that provides pertinent integrity constraints
> as well as manipulative power. However, the recursive join described in
> Chapter 5 is not a complete solution to this problem."
> 
> And then, maddeningly:
> 
> "The more complete solution will, of course, be published later."
> 

Wow, that's a cop-out.  Bad Codd...


> The recursive join of Chapter 5:
> 
> "The recursive join is an operator with one operand. This operand is a
> relation that represents a directed graph [map of parent-to-child
> relationships]. One of the columns of this relation plays a subordinate
> (SUB) role, while another plays a superior (SUP) role. Each tuple [row]
> represents an edge [connection] of a directed graph [parent-value-node
> to child-value-node], and by convention this edge is directed from the
> node identified by the SUP component down to the node identified by the
> SUB component. Because joins are normally applied to pairs of relations,
> it is convenient to think of the single operand as two identical
> relations. The recursive join acts on this pair of identical relations
> by matching each SUB value in one operand to a SUP value in the second
> operand. It yields all of the pairs of identifiers for nodes that are
> connected by paths in the acylic graph [a map of all the node
> interconnections], NO MATTER WHAT THE PATH LENGTHS [levels] ARE
> [emphasis mine]." [Codd 1990, Ch.5, Sect.5-10, p140]
> 


So in his Chapter 5, does he show the syntax of any recursive join?

Wait -- In another email that Bruce sent me, he scanned in pages from 
Chapter 5 for me.  Been a long time since I sat down and tried to wrap my 
head around such a tome, but I swear I'm going to try.  And there are NO 
examples of a self-join in there.  Come on, how do you run on and on about 
them and then not show a single example....

Karen

Reply via email to