Re: Lucid statement of the MV vs RM position?

Marshall Spight wrote:
> Jon Heggland wrote:

>> Perhaps I still was unclear; let me try again. Obviously you can
>> postulate an aggregate operator that defined as iterated union, like SUM
>> is iterated addition. Tutorial D does just that, and calls it (perhaps
>> confusingly) UNION. You could call it GROUP instead, but Tutorial D does
>> not. It uses the name GROUP for a unary relation operator that is
>> shorthand for a particular extension/projection; alternatively a
>> summarisation using that iterated union aggregate operator. I honestly
>> don't see why this is so difficult to grasp.

Then I don't know how to convince you. Shall I show you the grammar? http://web.onetel.com/~hughdarwen/TheThirdManifesto/APPXI.pdf

> One the one hand, we have "iterated union." On the other hand,
> we have "shorthand for a particular extension/projection", which
> is not very specific, but *could* be a description of what we have
> in the first case.

Can you perform a union between two relations by first extending and then projecting one relation?

> Can you be more specific about the differences between the
> two?

I don't know how I can be more specific than I already have been. If you accept that GROUP is equivalent to a SUMMARIZE using the iterated union aggregate operator (do you?), it seems obvious to me that it cannot simultaneously be *the same as* that iterated union aggregate operator.

But I'll try another tack. There is an operator (invocation) that when applied to relation (1):

C | I
==+==

A | 1
B | 2
A | 3

produces relation (2):

C | AGG_I
==+------
A | 4
B | 2

Is that operator the aggregate operator SUM()? Certainly not; for one thing, SUM() produces a numerical value, not a relation. Rather, it is the relational operator SUMMARIZE, *using* the aggregate operator SUM as part of its invocation. Do you agree with this?

Likewise, there is an operator that from (1) produces (3):

C | AGG_I*
==+---------
A | { 1, 3 }
B | { 2 }

Likewise, that is also not an aggregate operator. Aggregate operators have identity. That means they are dyadic. The two operators above are monadic; they take one relation in, and produces another. It doesn't make sense to talk about identity with respect to them.

-- 
Jon

* In Tutorial D, AGG_I would be of type RELATION { I TypeOfI }, so the
value { 1, 3 } should rather be RELATION { TUPLE { I 3 }, TUPLE { I 1 } }.