使用CASE和GROUP BY进行数据透视的动态替代方法

时间:2013-03-19 17:16:49

标签: sql postgresql pivot crosstab window-functions

我有一个看起来像这样的表:

id    feh    bar
1     10     A
2     20     A
3      3     B
4      4     B
5      5     C
6      6     D
7      7     D
8      8     D

我希望它看起来像这样:

bar  val1   val2   val3
A     10     20 
B      3      4 
C      5        
D      6      7     8

我有这个查询:

SELECT bar, 
   MAX(CASE WHEN abc."row" = 1 THEN feh ELSE NULL END) AS "val1",
   MAX(CASE WHEN abc."row" = 2 THEN feh ELSE NULL END) AS "val2",
   MAX(CASE WHEN abc."row" = 3 THEN feh ELSE NULL END) AS "val3"
FROM
(
  SELECT bar, feh, row_number() OVER (partition by bar) as row
  FROM "Foo"
 ) abc
GROUP BY bar

这是一种非常狡猾的方法,如果要创建许多新列,它会变得难以处理。我想知道CASE语句是否可以更好地使这个查询更具动态性?此外,我很乐意看到其他方法。

6 个答案:

答案 0 :(得分:49)

如果您尚未安装附加模块tablefunc,请为每个数据库运行此命令一次

CREATE EXTENSION tablefunc;

回答问题

适合您案例的非常基本的交叉表解决方案:

SELECT * FROM crosstab(
  'SELECT bar, 1 AS cat, feh
   FROM   tbl_org
   ORDER  BY bar, feh')
 AS ct (bar text, val1 int, val2 int, val3 int);  -- more columns?

这里的特殊困难是,基表中没有类别cat)。对于基本的 1参数形式,我们可以提供一个虚拟列,其虚拟值作为类别。无论如何,该值都会被忽略。

这是极少数情况之一,crosstab()函数的第二个参数 ,因为所有{ {1}}值仅通过此问题的定义显示在右侧的悬空列中。订单可以通过确定。

如果我们有一个实际的类别列,其名称确定结果中值的顺序,我们需要NULL 2参数形式 。在这里,我借助窗口函数row_number()合成了一个类别列,以crosstab()为基础:

crosstab()

其余的几乎都是普通的。在这些密切相关的答案中找到更多解释和链接。

基础:
如果您不熟悉SELECT * FROM crosstab( $$ SELECT bar, val, feh FROM ( SELECT *, 'val' || row_number() OVER (PARTITION BY bar ORDER BY feh) AS val FROM tbl_org ) x ORDER BY 1, 2 $$ , $$VALUES ('val1'), ('val2'), ('val3')$$ -- more columns? ) AS ct (bar text, val1 int, val2 int, val3 int); -- more columns? 功能,请先阅读此内容!

高级:

正确的测试设置

这就是你应该如何提供一个测试用例:

crosstab()

动态交叉表?

不是动态,但是,@Clodoaldo commented。使用plpgsql很难实现动态返回类型。但方法 - 有一些限制

所以不要让其他内容进一步复杂化,我使用 更简单的 测试用例进行演示:

CREATE TEMP TABLE tbl_org (id int, feh int, bar text);
INSERT INTO tbl_org (id, feh, bar) VALUES
   (1, 10, 'A')
 , (2, 20, 'A')
 , (3,  3, 'B')
 , (4,  4, 'B')
 , (5,  5, 'C')
 , (6,  6, 'D')
 , (7,  7, 'D')
 , (8,  8, 'D');

呼叫:

CREATE TEMP TABLE tbl (row_name text, attrib text, val int);
INSERT INTO tbl (row_name, attrib, val) VALUES
   ('A', 'val1', 10)
 , ('A', 'val2', 20)
 , ('B', 'val1', 3)
 , ('B', 'val2', 4)
 , ('C', 'val1', 5)
 , ('D', 'val3', 8)
 , ('D', 'val1', 6)
 , ('D', 'val2', 7);

返回:

SELECT * FROM crosstab('SELECT row_name, attrib, val FROM tbl ORDER BY 1,2')
AS ct (row_name text, val1 int, val2 int, val3 int);

row_name | val1 | val2 | val3 ----------+------+------+------ A | 10 | 20 | B | 3 | 4 | C | 5 | | D | 6 | 7 | 8 模块

的内置功能

tablefunc模块为通用tablefunc调用提供了一个简单的基础结构,而不提供列定义列表。用crosstab()编写的许多函数(通常非常快):

crosstabN()

C - crosstab1()是预先定义的。一个小问题:他们需要并返回所有crosstab4()。所以我们需要转换text值。但它简化了电话:

integer

结果:

SELECT * FROM crosstab4('SELECT row_name, attrib, val::text  -- cast!
                         FROM tbl ORDER BY 1,2')

自定义 row_name | category_1 | category_2 | category_3 | category_4 ----------+------------+------------+------------+------------ A | 10 | 20 | | B | 3 | 4 | | C | 5 | | | D | 6 | 7 | 8 | 功能

对于 更多列 其他数据类型 ,我们创建自己的复合类型功能(一次)。
类型:

crosstab()

功能:

CREATE TYPE tablefunc_crosstab_int_5 AS (
  row_name text, val1 int, val2 int, val3 int, val4 int, val5 int);

呼叫:

CREATE OR REPLACE FUNCTION crosstab_int_5(text)
  RETURNS SETOF tablefunc_crosstab_int_5
AS '$libdir/tablefunc', 'crosstab' LANGUAGE c STABLE STRICT;

结果:

SELECT * FROM crosstab_int_5('SELECT row_name, attrib, val   -- no cast!
                              FROM tbl ORDER BY 1,2');

所有

的一个多态,动态函数

这超出了 row_name | val1 | val2 | val3 | val4 | val5 ----------+------+------+------+------+------ A | 10 | 20 | | | B | 3 | 4 | | | C | 5 | | | | D | 6 | 7 | 8 | | 模块所涵盖的内容。
为了使返回类型动态,我使用多态类型,并在此相关答案中详细介绍了该技术:

1参数形式:

tablefunc

使用此变量为2参数形式重载:

CREATE OR REPLACE FUNCTION crosstab_n(_qry text, _rowtype anyelement)
  RETURNS SETOF anyelement AS
$func$
BEGIN
   RETURN QUERY EXECUTE 
   (SELECT format('SELECT * FROM crosstab(%L) t(%s)'
                , _qry
                , string_agg(quote_ident(attname) || ' ' || atttypid::regtype
                           , ', ' ORDER BY attnum))
    FROM   pg_attribute
    WHERE  attrelid = pg_typeof(_rowtype)::text::regclass
    AND    attnum > 0
    AND    NOT attisdropped);
END
$func$  LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION crosstab_n(_qry text, _cat_qry text, _rowtype anyelement) RETURNS SETOF anyelement AS $func$ BEGIN RETURN QUERY EXECUTE (SELECT format('SELECT * FROM crosstab(%L, %L) t(%s)' , _qry, _cat_qry , string_agg(quote_ident(attname) || ' ' || atttypid::regtype , ', ' ORDER BY attnum)) FROM pg_attribute WHERE attrelid = pg_typeof(_rowtype)::text::regclass AND attnum > 0 AND NOT attisdropped); END $func$ LANGUAGE plpgsql; :为每个用户定义的复合类型定义了一种行类型,因此属性(列)列在系统目录pg_attribute中。获得它的快车道:将注册类型(pg_typeof(_rowtype)::text::regclass)投射到regtype并将此text投射到text

创建一次复合类型:

您需要为要使用的每种返回类型定义一次:

regclass

对于临时呼叫,您也可以只为相同(临时)效果创建临时表

CREATE TYPE tablefunc_crosstab_int_3 AS (
    row_name text, val1 int, val2 int, val3 int);

CREATE TYPE tablefunc_crosstab_int_4 AS (
    row_name text, val1 int, val2 int, val3 int, val4 int);

...

或者使用现有表格,视图或物化视图的类型(如果可用)。

呼叫

使用上述行类型:

1参数表格(无缺失值):

CREATE TEMP TABLE temp_xtype7 AS (
    row_name text, x1 int, x2 int, x3 int, x4 int, x5 int, x6 int, x7 int);

2参数形式(某些值可能丢失):

SELECT * FROM crosstab_n(
   'SELECT row_name, attrib, val FROM tbl ORDER BY 1,2'
 , NULL::tablefunc_crosstab_int_3);

这个一个函数适用于所有返回类型,而SELECT * FROM crosstab_n( 'SELECT row_name, attrib, val FROM tbl ORDER BY 1' , $$VALUES ('val1'), ('val2'), ('val3')$$ , NULL::tablefunc_crosstab_int_3);模块提供的crosstabN()框架需要为每个类型提供单独的函数。
如果按照上面的说明顺序命名了类型,则只需要替换粗体数字。要查找基表中的最大类别数:

tablefunc

如果您想要个别列,那就像动态一样。像demonstrated by @Clocoaldo这样的数组或简单的文本表示形式或包含在SELECT max(count(*)) OVER () FROM tbl -- returns 3 GROUP BY row_name LIMIT 1; json等文档类型中的结果可以动态地适用于任意数量的类别。

<强>声明:
当用户输入转换为代码时,它总是有潜在危险。确保这不能用于SQL注入。不接受来自不受信任的用户的输入(直接)。

致电原始问题:

hstore

答案 1 :(得分:15)

虽然这是一个老问题,但我希望通过PostgreSQL最近的改进添加另一个解决方案。该解决方案实现了从动态数据集返回结构化结果而不使用交叉表函数的相同目标。换句话说,这是重新检查无意和隐含假设的一个很好的例子我们从发现旧问题的新解决方案。 ;)

为了说明,您要求使用以下结构转置数据的方法:

id    feh    bar
1     10     A
2     20     A
3      3     B
4      4     B
5      5     C
6      6     D
7      7     D
8      8     D

采用以下格式:

bar  val1   val2   val3
A     10     20 
B      3      4 
C      5        
D      6      7     8

传统的解决方案是创建动态交叉表查询的一种聪明(且难以置信的知识)方法,在Erwin Brandstetter的答案中详细解释了这一点。

但是,如果您的特定用例足够灵活,可以接受稍微不同的结果格式,那么另一种解决方案可以很好地处理动态枢轴。这种技术,我在这里学到了

使用PostgreSQL的新jsonb_object_agg函数以JSON对象的形式即时构建数据透视数据。

我将使用Brandstetter先生&#34;更简单的测试用例&#34;说明:

CREATE TEMP TABLE tbl (row_name text, attrib text, val int);
INSERT INTO tbl (row_name, attrib, val) VALUES
   ('A', 'val1', 10)
 , ('A', 'val2', 20)
 , ('B', 'val1', 3)
 , ('B', 'val2', 4)
 , ('C', 'val1', 5)
 , ('D', 'val3', 8)
 , ('D', 'val1', 6)
 , ('D', 'val2', 7);

使用jsonb_object_agg功能,我们可以使用这种精湛的美感创建所需的旋转结果集:

SELECT
  row_name AS bar,
  json_object_agg(attrib, val) AS data
FROM tbl
GROUP BY row_name
ORDER BY row_name;

哪个输出:

 bar |                  data                  
-----+----------------------------------------
 A   | { "val1" : 10, "val2" : 20 }
 B   | { "val1" : 3, "val2" : 4 }
 C   | { "val1" : 5 }
 D   | { "val3" : 8, "val1" : 6, "val2" : 7 }

如您所见,此函数的工作原理是通过样本数据中的attribvalue列在JSON对象中创建键/值对,所有列都按row_name分组。< / p>

虽然这个结果集显然看起来不同,但我相信它实际上会满足许多(如果不是大多数)现实世界的用例,特别是那些数据需要动态生成的数据透视表,或者父应用程序使用结果数据的情况。 (例如,需要重新格式化以便在http响应中传输。)

这种方法的好处:

  • 更清晰的语法。我想每个人都会同意这种方法的语法比最基本的交叉表示例更清晰,更容易理解。

  • 完全动态。无需预先指定有关基础数据的信息。无论是列名还是数据类型都不需要提前知道。

  • 处理大量列。由于透视数据保存为单个jsonb列,因此不会遇到PostgreSQL的列限制(≤1,600列,I相信)。仍有一个限制,但我相信它与文本字段相同:每个JSON对象创建1 GB(如果我错了,请纠正我)。那是很多关键/价值对!

  • 简化数据处理。我相信在数据库中创建JSON数据将简化(并可能加快)父应用程序中的数据转换过程。 (您将注意到我们的示例测试用例中的整数数据已正确存储在生成的JSON对象中.PostgreSQL通过根据JSON规范自动将其内部数据类型转换为JSON来处理此问题。)这将有效地消除需求手动转换传递给父应用程序的数据:它们都可以委托给应用程序的本机JSON解析器。

差异(和可能的缺点):

  • 看起来与众不同。不可否认,这种方法的结果看起来不同。 JSON对象不如交叉表结果集漂亮;然而,差异纯粹是装饰性的。生成相同的信息 - 并且格式可能更多友好供父应用程序使用。

  • 缺少密钥。交叉表方法中缺少的值用空值填充,而JSON对象只是缺少适用的密钥。如果这是您的用例可接受的权衡,您将不得不自己决定。在我看来,任何在PostgreSQL中解决这个问题的尝试都会使这个过程变得非常复杂,并且可能会以其他查询的形式进行一些内省。

  • 不保留密钥顺序。我不知道这是否可以在PostgreSQL中解决,但这个问题大部分都是装饰性的,因为任何父应用程序都不太可能依靠关键顺序,或有能力通过其他方式确定正确的关键顺序。最坏的情况可能只需要对数据库进行额外查询。

<强>结论

我很好奇听到其他人(尤其是@ ErwinBrandstetter)对这种方法的看法,特别是因为它与性能有关。当我在安德鲁·本德的博客上发现这种方法时,就好像被击中头部一样。对PostrgeSQL中的难题采取新方法是多么美妙的方式。它完美地解决了我的用例,我相信它也会同样服务于其他许多用途。

答案 2 :(得分:6)

这是为了完成@Damian个好答案。在9.6的方便json_object_agg函数之前,我已经在其他答案中提出了JSON方法。使用以前的工具集只需要做更多的工作。

引用的两个可能的缺点实际上并非如此。如有必要,可以轻松纠正随机密钥顺序。丢失的密钥(如果相关)需要处理几乎无足轻重的代码:

select
    row_name as bar,
    json_object_agg(attrib, val order by attrib) as data
from
    tbl
    right join
    (
        (select distinct row_name from tbl) a
        cross join
        (select distinct attrib from tbl) b
    ) c using (row_name, attrib)
group by row_name
order by row_name
;
 bar |                     data                     
-----+----------------------------------------------
 a   | { "val1" : 10, "val2" : 20, "val3" : null }
 b   | { "val1" : 3, "val2" : 4, "val3" : null }
 c   | { "val1" : 5, "val2" : null, "val3" : null }
 d   | { "val1" : 6, "val2" : 7, "val3" : 8 }

对于了解JSON的最终查询使用者,没有任何缺点。唯一的一个是它不能作为表源使用。

答案 3 :(得分:5)

在你的情况下,我猜一个阵列是好的。 SQL Fiddle

select
    bar,
    feh || array_fill(null::int, array[c - array_length(feh, 1)]) feh
from
    (
        select bar, array_agg(feh) feh
        from foo
        group by bar
    ) s
    cross join (
        select count(*)::int c
        from foo
        group by bar
        order by c desc limit 1
    ) c(c)
;
 bar |      feh      
-----+---------------
 A   | {10,20,NULL}
 B   | {3,4,NULL}
 C   | {5,NULL,NULL}
 D   | {6,7,8}

答案 4 :(得分:2)

我很遗憾回到过去,但解决方案“Dynamic Crosstab”会返回错误的结果表。因此,valN值错误地“向左对齐”并且它们不对应于列名。当输入表中的值中有“空洞”时,例如“C”具有val1和val3但不具有val2。这会产生错误:val3值将在最终表中的val2列(即下一个空闲列)中进行调整。

CREATE TEMP TABLE tbl (row_name text, attrib text, val int); 
INSERT INTO tbl (row_name, attrib, val) VALUES ('C', 'val1', 5) ('C', 'val3', 7);

SELECT * FROM crosstab('SELECT row_name, attrib, val FROM tbl 
ORDER BY 1,2') AS ct (row_name text, val1 int, val2 int, val3 int);

row_name|val1|val2|val3
 C      |   5|  7 |

为了在右列中返回带有“holes”的正确单元格,交叉表查询需要交叉表中的第二个SELECT,类似于此"crosstab('SELECT row_name, attrib, val FROM tbl ORDER BY 1,2', 'select distinct row_name from tbl order by 1')"

答案 5 :(得分:0)

这并不是真正的动态,因为您仍然需要枚举与您预期的值一样多的列,但这样做很容易。一个问题是列需要一个有序的键来匹配,没有中断。此外,如果有重复的密钥,它会完全不正常,因此也需要重复数据删除。这些集合都必须预先分区以容纳适当的 N 集合。

对我来说它看起来很笨拙,所以不确定它是否物有所值。但我将此添加到社区狗堆中,希望它能为其他人提出更好的方法提供一些动力。

/** build a dataset **/
DROP TABLE IF EXISTS tmpT ;
CREATE TEMP TABLE tmpT AS
SELECT
 NULL::INT AS key
 ,NULL::INT AS ints
 ,NULL::VARCHAR(1) AS chars
 ,NULL::VARCHAR(3) AS unnest
LIMIT 0 ;

insert into tmpT (key, ints, chars, unnest)
values   (1 , 1   , 'o',  CHR( 130 - 10 ) )       
        ,(2 , 2   , 'n',  CHR( 130 - 11 ) )       
        ,(3 , 3   , 'm',            NULL  )       
        --,(4 , 4   , 'l',  CHR( 130 - 13 ) ) -- missing set       
        ,(5 , 5   , null, CHR( 130 - 14 ) )        
        ,(6 , null, 'j',  CHR( 130 - 15 ) )        
        ,(7 , 7   , null, CHR( 130 - 16 ) )         
        ,(8 , null, 'h',  CHR( 130 - 17 ) )        
        ,(9 , 9   , null, CHR( 130 - 18 ) )         
        ,(10, null, 'f' ,           NULL  )        
        ,(11, null, 'a',  CHR( 130 - 20 ) )        
        ,(12, 12  , null, CHR( 130 - 21 ) )         
 ; /** end of build a dataset **/

/** set up full set of pivotal column positions, to backfill any missing  **/
DROP TABLE IF EXISTS tGenSer ; 
CREATE TEMP TABLE tGenSer AS SELECT generate_series( 1, 1000 )::INT AS key ;

/** 然后是枢轴 **/

/* Pivot 10 columns */
SELECT *
FROM     /* name the columns*/
(    SELECT a a ,a b ,a c ,a d ,a e ,a f ,a g ,a h ,a i ,a j /*,a k ,a l ,a m ,a n ,a o ,a p ,a q ,a r ,a s ,a t*/ /* ,a u ,a v ,a w ,a x ,a y ,a z*/ FROM ( SELECT NULL::VARCHAR(3) AS a /**seed the typed columns **/) a  
    
    UNION /** union is just a helper, to assign names to unnamed columns **/
    
    /** 20 columns **/
    SELECT * FROM
    (
        /* enumerate columns, no name */
        SELECT t1.x[1 ] ,t1.x[2 ] ,t1.x[3 ] ,t1.x[4 ] ,t1.x[5 ] ,t1.x[6 ] ,t1.x[7 ] ,t1.x[8 ] ,t1.x[9 ] ,t1.x[10] 
        FROM ( SELECT  ARRAY( SELECT  a.ints::TEXT  AS v   
                        FROM tGenSer tg /**backfill missing keys**/ 
                        LEFT JOIN tmpT a ON tg.key = a.key ORDER BY tg.key 
                        ) AS x 
             ) t1
        
        UNION ALL
        
        SELECT t1.x[1 ] ,t1.x[2 ] ,t1.x[3 ] ,t1.x[4 ] ,t1.x[5 ] ,t1.x[6 ] ,t1.x[7 ] ,t1.x[8 ] ,t1.x[9 ] ,t1.x[10] 
        FROM ( SELECT  ARRAY( SELECT  a.chars::TEXT AS v 
                        FROM tGenSer tg /**backfill missing keys**/ 
                        LEFT JOIN tmpT a ON tg.key = a.key ORDER BY tg.key 
                        ) AS x 
            ) t1
        
        UNION ALL
        
        SELECT t1.x[1 ] ,t1.x[2 ] ,t1.x[3 ] ,t1.x[4 ] ,t1.x[5 ] ,t1.x[6 ] ,t1.x[7 ] ,t1.x[8 ] ,t1.x[9 ] ,t1.x[10] 
        FROM ( SELECT  ARRAY( SELECT  a.unnest      AS v 
                        FROM tGenSer tg /**backfill missing keys**/ 
                        LEFT JOIN tmpT a ON tg.key = a.key 
                        ORDER BY tg.key 
                        ) AS x 
           ) t1
     ) a
)b
WHERE ( a,b,c,d,e,f,g,h,i,j) IS DISTINCT FROM ( NULL ,NULL ,NULL ,NULL ,NULL ,NULL ,NULL ,NULL ,NULL ,NULL )        

;
    

结果:

+---+---+--+--+--+--+--+--+--+--+
| a | b |c |d |e |f |g |h |i |j |
+---+---+--+--+--+--+--+--+--+--+
| x | w |  |  |t |s |r |q |p |  |
| o | n |m |  |  |j |  |h |  |f |
| 1 | 2 |3 |  |5 |  |7 |  |9 |  |
+---+---+--+--+--+--+--+--+--+--+