Approximation/Function Call Notation and Style

[davidkohn88]

Here's a general question that would be great to try and figure out:

Since it's looking like we could have a number of sketches and other data structures that can be used to perform approximations, how should we note the fact that you get approximate results out? prepending or appending approx_ to the function call seems like what we've sort of assumed, but I'm not sure if I like it.

for instance:

SELECT approx_percentile(tdigest(value), 0.01) FROM foo;
-- vs
SELECT percentile(tdigest(value), 0.01) FROM foo;
--vs
SELECT percentile_approx(tdigest(value), 0.01) FROM foo;

What about using our pipeline notation in #26? Or are there other operators that would make more sense?

SELECT tdigest(value) |> percentile(0.01) FROM foo;
--or
SELECT tdigest(value) -> percentile(0.01) FROM foo; -- mimic JSON type operators as this is a different operation than pipelining

One thing to note is that things like tdigest can also compute exact values, for instance, you can get a count directly out of a tdigest without having to store a separate count and it is an exact count, with count, or things where there are overloaded functions need some way of being distinguished. (Obviously most of these make more sense in the continuous aggregate context than in the normal query context where it would clearly be simpler to just do the count).

SELECT percentile_approx(tdigest(value), 0.01),  count_t(tdigest(value)) FROM foo;
-- with operator/pipelining it might be easier
SELECT tdigest(value) |> percentile(0.01), tdigest(value) |> count() FROM foo;
-- you could potentially distinguish between exact and approximate results using the operators as well
SELECT tdigest(value) *-> percentile(0.01), tdigest(value) -> count() FROM foo;
-- I thought about the ~> for this case, but it seems really hard to distinguish from the normal arrow in docs etc. 
SELECT tdigest(value) ~> percentile(0.01), tdigest(value) -> count() FROM foo;

Thoughts on what styles people prefer?

[feikesteenbergen]

As a comment in general, operators require functions which have names - so even if the pipeline notation is the one that looks cleanest, the functions do need to be named.

I'm looking at the functions in pg_proc and I see function names like float8_var_samp and stddev_samp, I'm not sure what that tells us, but if I'd have to vote, I'd choose the postfix:

percentile_approx

[davidkohn88]

Sure, but they don't need to be the main API and we will have to have the function available, but it doesn't need to be the one we document etc. But that is useful for how to name those functions!

[thedodd]

Agreed on percentile_approx, and I'm a big fan of the pipeline syntax. Overloading the JSON syntax might be a footgun for some folks.

[davidkohn88]

can you expand on what you mean with the footgun part of the overloading? One thing to note is that they are different types as inputs, though I suppose it is somewhat semantically different in some ways as with JSON you're getting an element whereas here you're actually doing some sort of work and there's a function call on the other side.