Subject: Aggregate expression syntax

From: Thom Brown <[email-masked]>
Date: Tue, 20 Jan 2015 13:50:22 +0000

Hi all,

Looking at the syntax for aggregate expressions in the docs, it seems the
first three forms could perhaps be merged since the ALL and DISTINCT
keywords are effectively optional.

Currently:

aggregate_name (expression [ , ... ] [ order_by_clause ] ) [ FILTER ( WHERE
filter_clause ) ]
aggregate_name (ALL expression [ , ... ] [ order_by_clause ] ) [ FILTER (
WHERE filter_clause ) ]
aggregate_name (DISTINCT expression [ , ... ] [ order_by_clause ] ) [
FILTER ( WHERE filter_clause ) ]

Proposed:

aggregate_name ( [ ALL | DISTINCT ] expression [ , ... ] [ order_by_clause
] ) [ FILTER ( WHERE filter_clause ) ]

I've also found a precedent for this on the SELECT statement page:

[ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select ]

Patch attached with the proposed change.

Opinions?

Thom
diff --git a/doc/src/sgml/syntax.sgml b/doc/src/sgml/syntax.sgml
index 4b81b08..4f8a43b 100644
--- a/doc/src/sgml/syntax.sgml
+++ b/doc/src/sgml/syntax.sgml
@@ -1574,9 +1574,7 @@ sqrt(2)
     syntax of an aggregate expression is one of the following:
 
 <synopsis>
-<replaceable>aggregate_name</replaceable> (<replaceable>expression</replaceable> [ , ... ] [ <replaceable>order_by_clause</replaceable> ] ) [ FILTER ( WHERE <replaceable>filter_clause</replaceable> ) ]
-<replaceable>aggregate_name</replaceable> (ALL <replaceable>expression</replaceable> [ , ... ] [ <replaceable>order_by_clause</replaceable> ] ) [ FILTER ( WHERE <replaceable>filter_clause</replaceable> ) ]
-<replaceable>aggregate_name</replaceable> (DISTINCT <replaceable>expression</replaceable> [ , ... ] [ <replaceable>order_by_clause</replaceable> ] ) [ FILTER ( WHERE <replaceable>filter_clause</replaceable> ) ]
+<replaceable>aggregate_name</replaceable> ( [ ALL | DISTINCT ] <replaceable>expression</replaceable> [ , ... ] [ <replaceable>order_by_clause</replaceable> ] ) [ FILTER ( WHERE <replaceable>filter_clause</replaceable> ) ]
 <replaceable>aggregate_name</replaceable> ( * ) [ FILTER ( WHERE <replaceable>filter_clause</replaceable> ) ]
 <replaceable>aggregate_name</replaceable> ( [ <replaceable>expression</replaceable> [ , ... ] ] ) WITHIN GROUP ( <replaceable>order_by_clause</replaceable> ) [ FILTER ( WHERE <replaceable>filter_clause</replaceable> ) ]
 </synopsis>
@@ -1591,14 +1589,12 @@ sqrt(2)
    </para>
 
    <para>
-    The first form of aggregate expression invokes the aggregate
-    once for each input row.
-    The second form is the same as the first, since
-    <literal>ALL</literal> is the default.
-    The third form invokes the aggregate once for each distinct value
-    of the expression (or distinct set of values, for multiple expressions)
-    found in the input rows.
-    The fourth form invokes the aggregate once for each input row; since no
+    The first form of aggregate expression with the <literal>ALL</literal>
+    keyword (the default) invokes the aggregate once for each input row.
+    Specifying <literal>DISTINCT</literal> invokes the aggregate once for
+    each distinct value of the expression (or distinct set of values, for
+    multiple expressions) found in the input rows.
+    The second form invokes the aggregate once for each input row; since no
     particular input value is specified, it is generally only useful
     for the <function>count(*)</function> aggregate function.
     The last form is used with <firstterm>ordered-set</> aggregate

-- 
Sent via pgsql-docs mailing list ([email-masked])
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-docs

---

From: Tom Lane <[email-masked]>
Date: Tue, 20 Jan 2015 09:48:41 -0500

> keywords are effectively optional.

Dunno, just seems harder to read to me...

			regards, tom lane

---

From: David G Johnston <[email-masked]>
Date: Tue, 20 Jan 2015 10:44:50 -0700 (MST)

Tom Lane-2 wrote
> Thom Brown &lt;

> thom@

> &gt; writes:

I'm generally for making the syntax part more succinct and addressing
learning concerns with examples.  The extra noise that needs to be filtered
out when trying to figure out why different structures exist makes it
difficult to read too.

That said, having at least a bare-minimum expression would be helpful:

aggregate_name ( expression )

And now decide whether to have a combined syntax block or keep building
things up like:

aggregate_name ( [ ALL | DISTINCT ] expression [ , ... ] [ order_by_clause]
)
aggregate_name ( argument_clause ) [ FILTER ( WHERE [ filter_clause ] ) ]

argument_clause := " [ ALL | DISTINCT ] expression [ , ... ] [
order_by_clause ] "

If we are going to repeat long and complex parts of the syntax naming them
will make reading subsequent syntax expressions easier and provide semantic
meaning to the reader.  The existing forms, while correct, are repetitive
and that is what is being targeted but combining them into a single syntax
block.  But if that is too hard to read and understand then maybe some other
means of simplification, like my example above, would work better.

David J.

--
View this message in context: http://postgresql.nabble.com/Aggregate-expression-syntax-tp5834726p5834768.html
Sent from the PostgreSQL - docs mailing list archive at Nabble.com.