PostgreSQL用户定义的聚合函数计数

Question

我正在定义时变整数，即时变整数段的数组，后者是与时间戳范围关联的整数值。

CREATE TYPE integerTS AS (val integer, p tsrange);
CREATE TYPE integerTT AS (traj integerTS[]);

这样的值的一个例子是

select integerTT(ARRAY[
integerTS(1, '2012-01-01 08:00:00', '2012-01-01 08:10:00'),
integerTS(2, '2012-01-01 08:10:00', '2012-01-01 08:20:00')
])

我可以定义最小，最大和总和函数，但是可以定义这些类型

WITH Values AS (
SELECT integerTT(ARRAY[
    integerTS(3, '2012-01-01 08:00:00', '2012-01-01 08:20:00')]) as val
UNION
SELECT integerTT(ARRAY[
    integerTS(2, '2012-01-01 08:10:00', '2012-01-01 08:30:00')])
UNION
SELECT integerTT(ARRAY[
    integerTS(1, '2012-01-01 08:20:00', '2012-01-01 08:40:00')])
)
SELECT min(val)
from Values

造成

integerTT(ARRAY[
    integerTS(3, '2012-01-01 08:00:00', '2012-01-01 08:10:00'),
    integerTS(2, '2012-01-01 08:10:00', '2012-01-01 08:20:00'),
    integerTS(1, '2012-01-01 08:20:00', '2012-01-01 08:40:00')])

但是，我无法为时变整数定义计数聚合函数。 我开始定义功能如下。

CREATE OR REPLACE FUNCTION count(tt1 integerTT, tt2 integerTT) RETURNS integerTT AS
$BODY$
DECLARE 
BEGIN
    -- 0 is a dummy value
    return integerTT(count(integerTS(0,getT(tt1)), integerTS(0,getT(tt2))));
END;
$BODY$ LANGUAGE plpgsql IMMUTABLE STRICT;

CREATE OR REPLACE FUNCTION count(ts1 integerTS, ts2 integerTS) RETURNS integerTS[] AS
$BODY$
DECLARE 
    intersection tsrange;
    result integerTS[];
BEGIN
    intersection := getT(ts1) * getT(ts2);
    IF isempty(intersection) THEN
        IF getT(ts1) << getT(ts2) THEN
            result := ARRAY[integerTS(1,getT(ts1)),integerTS(1,getT(ts2))];
        ELSE 
            result := ARRAY[integerTS(1,getT(ts2)),integerTS(1,getT(ts1))];
        END IF;
    ELSE 
        IF lower(getT(ts1)) < lower(intersection) THEN
        result := array_append(result,integerTS(1,tsrange(lower(getT(ts1)), lower(intersection))));
        END IF;
        IF lower(getT(ts2)) < lower(intersection) THEN
        result := array_append(result,integerTS(1,tsrange(lower(getT(ts2)), lower(intersection))));
        END IF;
        result := array_append(result,integerTS(2,intersection));   
        IF upper(intersection) < upper(getT(ts1)) THEN
        result := array_append(result,integerTS(1,tsrange(upper(intersection), upper(getT(ts1)))));
        END IF;
        IF upper(intersection) < upper(getT(ts2)) THEN
        result := array_append(result,integerTS(1,tsrange(upper(intersection), upper(getT(ts2)))));
        END IF;
    END IF;
    RETURN result;
END;
$BODY$ LANGUAGE plpgsql IMMUTABLE STRICT;

然后

WITH Values AS (
SELECT integerTT(ARRAY[
    integerTS(3, '2012-01-01 08:00:00', '2012-01-01 08:20:00')]) as val
UNION
SELECT integerTT(ARRAY[
    integerTS(2, '2012-01-01 08:10:00', '2012-01-01 08:30:00')])
UNION
SELECT integerTT(ARRAY[
    integerTS(1, '2012-01-01 08:20:00', '2012-01-01 08:40:00')])
)
SELECT count(val)
from Values

得出如下正确值

integerTT(ARRAY[
    integerTS(1, '2012-01-01 08:00:00', '2012-01-01 08:10:00'),
    integerTS(2, '2012-01-01 08:10:00', '2012-01-01 08:30:00'),
    integerTS(1, '2012-01-01 08:30:00', '2012-01-01 08:40:00')])

但是，当聚合函数定义如下时

CREATE AGGREGATE count (integerTT)
(
    sfunc = count,
    stype = integerTT
);

不起作用，因为它总是返回1和2个计数值。 例如

WITH Values AS (
SELECT integerTT(ARRAY[
    integerTS(3, '2012-01-01 08:00:00', '2012-01-01 08:20:00')]) as val
UNION
SELECT integerTT(ARRAY[
    integerTS(4, '2012-01-01 08:00:00', '2012-01-01 08:20:00')]) as val
UNION
SELECT integerTT(ARRAY[
    integerTS(5, '2012-01-01 08:00:00', '2012-01-01 08:20:00')]) as val
UNION
SELECT integerTT(ARRAY[
    integerTS(6, '2012-01-01 08:00:00', '2012-01-01 08:20:00')]) as val
UNION
SELECT integerTT(ARRAY[
    integerTS(7, '2012-01-01 08:00:00', '2012-01-01 08:20:00')]) as val
)
SELECT count(val)
from Values

退货

integerTT(ARRAY[
    integerTS(2, '2012-01-01 08:00:00', '2012-01-01 08:20:00')])

虽然它应该返回

integerTT(ARRAY[
    integerTS(5, '2012-01-01 08:00:00', '2012-01-01 08:20:00')])

如何定义时变计数？ 我正在使用PostgreSQL版本9.4.1。

Answer 1

虽然这不是您实际要求的答案，但这是我实际上要提供的答案。 评论太复杂了。

仅仅因为您可以创建一个类型，该类型是由整数和范围类型组成的复合类型的数组，甚至可以在该类型之上创建聚合函数，但这并不意味着这样做是一个好主意。

它更简单，更快，更不容易出错，并且需要更少的磁盘空间才能将integerTT实现为实际表 ：

CREATE tbl (
  tbl_id serial PRIMARY KEY
, batch_id int  -- to wrap a set of "integerTS"
, val integer   -- your "integerTS" decomposed
, p tsrange     -- your "integerTS" decomposed
);

然后使用现有的（快得多的）聚合函数编写普通的SQL查询。