我有一个具有以下结构的行表，name TEXT, favorite_colors TEXT[], group_name INTEGER其中每一行都有每个人喜欢的颜色和该人所属组的列表。如何GROUP BY group_name获得每个组中最常见的颜色的列表？

您可以组合int[] && int[]设置重叠，int[] & int[]获取交点然后进行其他计数和排名吗？

从 PostgreSQL 9.6 升级到 11 时，以下查询停止工作：

with doc as (select * from documents where name = doc_id)

select jsonb_array_elements_text(permissions)
from users
where users.name = user_name

union

select 
  case 
    when doc.reader = user_name then 'read'
    when doc.owner = user_name then unnest(array['read','write'])
    else unnest(array[]::text[])
    end 
from doc;

将union照常拼值的两个列表，两个列表可具有零个，一个或多个元件。

第一个select可以返回零，一个或多个，因为这是users表中的内容。

第二个select总是从documents表中扫描一行，但根据case决定返回零、一行或多行。

PostgreSQL 9.6 按预期工作，PostgreSQL 11 说：

ERROR:  set-returning functions are not allowed in CASE
LINE 56:    else unnest(array[]::text[])
                 ^ …

加入

SELECT *
FROM a
  INNER JOIN (
    SELECT b.id, Count(*) AS Count
    FROM b
    GROUP BY b.id ) AS b ON b.id = a.id;

侧

SELECT *
FROM a,
  LATERAL (
    SELECT Count(*) AS Count
    FROM b
    WHERE a.id = b.id ) AS b;

我知道这里的 join 将被计算一次，然后与主请求与每个 FROM 的请求合并。

在我看来，如果 join 将几行旋转到一帧，那么效率会更高，但如果是 1 比 1，则为 LATERAL - 我认为对吗？

我有以下查询：

query =
    "SELECT
      data #>> '{id}'          AS id,
      data #>> '{name}'        AS name,
      data #>> '{curator}'     AS curator,
      data #>  '{$isValid}'    AS \"$isValid\",
      data #>  '{customer}'    AS customer,
      data #>  '{$createdTS}'  AS \"$createdTS\",
      data #>  '{$updatedTS}'  AS \"$updatedTS\",
      data #>  '{$isComplete}' AS \"$isComplete\",
      (count(keys))::numeric as \"numProducts\",
      created_at
    FROM
      appointment_intakes,
      LATERAL jsonb_object_keys(data #> '{products}') keys
    INNER JOIN
      appointment_intake_users
    ON
      appointment_intake_users.appointment_intake_id = appointment_intakes.id
    #{where_clause}
    GROUP BY id"

并导致以下错误：

对表“ appointment_intakes”的FROM子句条目的无效引用

添加后，该错误开始发生：

LATERAL jsonb_object_keys(data #> '{products}') keys

和

(count(keys))::numeric as \"numProducts\"

因为我需要计算产品数量。 …

我有一个 Postgres 表，其中文本列的内容用“|”分隔。

ID | ... | my_column
-----------------------
1  | ... | text|concatenated|as|such
2  | ... | NULL
3  | ... | NULL

我尝试取消嵌套（string_to_array（））此列以分隔行，效果很好，除了我的 NULL 值（> 90％的所有条目）被排除在外。我尝试了几种方法：

 SELECT * from "my_table", lateral unnest(CASE WHEN "this_column" is NULL
 THEN NULL else string_to_array("this_column", '|') END);

或者

如此处建议的：PostgreSQL 用空数组取消嵌套

我得到什么：

ID | ... | my_column
-----------------------
1  | ... | text
1  | ... | concatenated
1  | ... | as
1  | ... | such

但这就是我需要的：

ID | ... | …

语境

我正在研究 PostgreSQL 的lateral连接，特别是在 group by/limit 上执行连接。

当我查找单个记录时，该查询工作得非常好，但当我们查询多个记录时，性能很快就会下降。这是有道理的，因为我们有多个子查询运行单独的收集、过滤聚合、排序。问题是，我们应该考虑什么 Postgres 策略，或者我们如何重构下面的查询以使其在规模上具有性能？

询问

我们有三个主表，其中两个表之间有一个连接表：

|经理| >- |商店| >- |商店_产品| -< 产品

我们拥有给定商店记录的所有历史经理，并且我们拥有商店的完整产品目录（产品可能由多个商店销售）。

目标：给定一个商店 ID，查询最近的经理和最近销售的产品。

这是从商店到经理和产品的内部联接。Manager & Product 必须按日期 desc 排序并限制为 1（至少我相信这是获取最新日期的方法）。

SELECT 
    store.id as store_id,
    manager.id as manager_id,
    *
FROM 
    Stores as store,
    LATERAL (
        SELECT 
            * 
        FROM 
            Products as product 
        INNER JOIN Stores_Products store_product on store_product.product_id = product.id
        WHERE 
            store_product.store_id = store.id
        ORDER BY 
            store.date desc
        LIMIT 1
    ) p,
    LATERAL (
        SELECT 
            * …