标签: postgresql

我有一个存储过程，RETURNS SETOF ct_custom_type我在里面做

RETURN QUERY EXECUTE 'some dynamic query'

我想这样做：如果这个“动态查询”返回 >= 10 行，我想返回它们，但如果它只返回 < 10 行，我不想返回任何东西（空集ct_custom_type）。

我试过：

RETURN QUERY EXECUTE 'some dynamic query'

GET DIAGNOSTICS variable = ROW_COUNT;
IF variable < 10 THEN

    # I don't know what to do here or how to accomplish this

END IF;

如果我RETURN QUERY SELECT 0, 0, ''::text;在IF块中执行（因为ct_custom_type是 的复合类型(integer, integer, text)，它只是将这个“空行”添加到先前的查询结果中，但在这种情况下我不想返回任何内容，我可以这样做RETURN;，但它会返回先前的结果，我想丢弃它。

我有这样的：

EXECUTE 'dynamic query';

GET DIAGNOSTICS variable = ROW_COUNT; …

我有 ：

CREATE TABLE ketoan_vn.Customers
(
  CustomerId character varying(10) NOT NULL,
  CustomerName character varying(150),
  CONSTRAINT Customers_PK_CustomerID PRIMARY KEY (CustomerId)
);

我在表 ketoan_vn.Customers 中插入了 2 行：

INSERT INTO ketoan_vn.customers(
            customerid, customername)
    VALUES ('C0001','Marry'),
    ('C0002','Tom');

然后我删除了 ketoan_vn.Customers ：

drop table ketoan_vn.Customers

现在我想恢复被删除的表的数据。PostgreSQL 9.1 可以做到这一点吗？

我需要创建一个database model包含一个字段来存储 20 位唯一值的字段。许多客户端将通过 API 使用它。

该值必须为 20 位长、数字且唯一。最好的方法似乎是创建一个自动增量big-int字段，但 big-int 支持的值最大为 9223372036854775807（19 位）。使用numeric(20,0)是无用的，因为尽管数字支持更大的值，但 Postgres 8.4 不允许我创建sequence并引发错误

CREATE SEQUENCE my_sequence_name INCREMENT BY 1 NO MINVALUE NO MAXVALUE START WITH 10000000000000000101;

错误：值“10000000000000000101”超出 bigint 类型的范围

为了数据完整性，我必须在 POstgresql 中处理这个问题。处理这个问题的有效方法是什么？

我正在使用 Postgresql 8.4 和 Django 1.3

更新：我想最好澄清一下......我试图找到一种在 DBMS 中解决这个问题的方法。因此，除非我别无选择，否则将避免任何非数据库解决方案。休息是我的问题的原因：

我正在制作一个与银行通信以进行 3D 安全操作的 API。银行 API 需要一个20 位的唯一数字标识符来进行交易，所以我决定创建一个 ID 值，我可以将它用于银行 API 和我将使用该表等的API。

说明10000000000000000101是因为，银行 API 希望它是一个有效的20 位数字 …

我将 PostgreSQL 9.1 与 Ruby on Rails 应用程序一起使用。

我正在尝试列出属于同一项目 ID (proj_sous_projet_id = 2) 的每个“费用”（在我的历史表中：hist_version_charges）的最后一个版本。

这使我使用 max() 聚合函数并将结果应用于同一个表上的 JOIN 函数，因为如果 SELECT 子句中的列未出现在 GROUP BY 子句中，则 PostgreSQL 没有授权使用它们，但使用最大值() 显然我对包含最大值的行感兴趣！

这是我的查询：

SELECT h_v_charges.*, 
       max(last_v.version) as lv 
FROM hist_versions_charges h_v_charges 
    JOIN hist_versions_charges last_v 
      ON h_v_charges.version = lv 
    AND h_v_charges.proj_charge_id = last_v.proj_charge_id 
GROUP BY last_v.proj_sous_projet_id, 
         last_v.proj_charge_id 
HAVING last_v.proj_sous_projet_id = 2 
ORDER BY h_v_charges.proj_charge_id ASC;

我得到的错误信息：

ERROR:  column "lv" does not exist
LINE 1: ..._versions_charges last_v ON h_v_charges.version = lv AND h_v...
                                                             ^
********** Error ********** …

我有一个有点奇怪的问题。

有没有办法手动强制 PostgreSQL 进入恢复模式？我无法在文档中找到任何内容。

我一直在使用监控 PostgreSQL 数据库的脚本，需要做一些测试。

我正在尝试调试 PostgreSQL 9.1.13 数据库上的慢查询，我有点不知所措。ORM 框架生成的确切查询是：

SELECT "core_product"."sales_price", "core_product"."recommended_price", "core_productgroup"."name", "core_product"."number", "core_product"."name", "core_product"."description", "core_product"."cost_price", "core_product"."bar_code", "core_product"."accessible"
FROM "core_product" INNER JOIN "core_productgroup" ON ( "core_product"."product_group_id" = "core_productgroup"."id" )
WHERE "core_productgroup"."company_id" = 1056
ORDER BY "core_product"."id" ASC
LIMIT 200;

此查询需要 28 秒才能返回 200 行，这对于我们的用例来说太慢了。

首次尝试了解性能瓶颈可能在哪里。我首先尝试删除LIMIT 200预期它会更慢。但是没有LIMIT 200查询只需要 2 秒就返回大约 293000 行。

如何更快地返回所有 293000 个匹配行而不是仅返回前 200 行？

我尝试使用EXPLAIN查看两个查询的查询计划有何不同。事实证明，这两个几乎相同的查询具有完全不同的查询计划。与LIMIT：

                                                   QUERY PLAN                                                   
----------------------------------------------------------------------------------------------------------------
 Limit  (cost=10.69..52229.70 rows=200 width=76)
   ->  Nested Loop  (cost=10.69..17054740.55 rows=65320 width=76)
         Join Filter: (core_product.product_group_id = core_productgroup.id) …

考虑一个包含 id 和 name 属性的表测试。

那个值。

Id   |   Name
1    |   Raj
2    |   Kumar

从上面的示例表中，我只知道 id，因此我需要通过 Id 交换名称，如下所示，

Id   |   Name
1    |   Kumar
2    |   Raj

我遇到了一个问题，SELECT查询很慢，因为当最终结果的数量为 0并且LIMIT指定了一个子句时，它不使用索引。

如果结果数大于 0，则 Postgres 使用索引并在 ~ 1ms 内返回结果。据我所知，这似乎总是正确的。

如果结果数为 0 且没有LIMIT使用，则 Postgres 使用索引，结果在 ~ 1ms 内返回

如果结果数为 0 并且LIMIT指定了 a，则 Postgres 会执行顺序扫描，结果大约需要 13,000 毫秒。

为什么 PostgreSQL 在最后一种情况下不使用索引？

基数：

总计约 2100 万行。
~ 300 万行WHERE related_id=1
~ 300 万行WHERE related_id=1 AND platform=p1
2 行WHERE related_id=1 AND platform=p2
0 行WHERE related_id=1 AND platform=p3
~ 800 万行WHERE platform=p2

Postgres 版本：9.4.6

表架构：

CREATE TYPE platforms AS ENUM ('p1', …

我正在尝试查询一个表，其中包含一段时间内记录的学生成绩集合。我想生成一个结果集，获取学生 id、一年级、一年级日期、最后一年级、最后一年级日期。

我想我需要使用MIN和MAX函数和一些子查询来实现这一点，但我只是没有得到我需要的结果。

有没有一种有效的方法可以在 PostgreSQL 上实现以下结果？

数据库示例：

user_id | grade | grade_date
1       | A     | 01/05/2016
1       | B     | 01/15/2016
1       | C     | 01/31/2016
2       | A     | 01/05/2016
2       | B     | 01/15/2016
2       | C     | 01/31/2016
3       | A     | 01/05/2016
3       | B     | 01/15/2016
3       | C     | 01/31/2016
4       | A     | 01/05/2016
4       | B     | 01/15/2016
4       | C     | 01/31/2016

我的目标是：

user_id | first_grade …

有一个名为Item(id, name, cost)and的表Orders(id, bill_id, item_id, units)，用于跟踪所下的订单，其中相同的bill_id表示它属于单个订单。

如果需要在Order表中添加item_id，如何在 DB 中施加一个额外的约束，表明Item应该是“可用的”（在那个时间点）？在这种情况下，项目被手动确定为“可用”并且不能从数据库中的其他字段派生。