标签: count

以下查询需要 497 ms 才能运行，如果我删除 AND 部分之后只需要 320 ms。有没有办法加快这个速度？我在“messages”表上的唯一索引是“messages_id”上的PK。'hidden' 字段是一个位字段（非空），'message_type_id' 是一个 int 字段（非空），而 message_id 是一个 int 字段（PK）。

SELECT COUNT(*)
FROM messages
WHERE message_type_id = 1
AND (hidden = 0 OR message_id = @message_id)

提前致谢！

所以我有一个真正的休息日什么的，但对于我的生活，我无法弄清楚这一点。我想分tier1由total获得总数的百分比。我是这样想的：

(tier1 / total) as per

但没有运气。我将这些 CAST 作为 int 并且仍然没有。我会得到一个错误并且查询不会执行，或者我会得到一个值 0。

这是我正在尝试使用的内容：

SELECT count(student_id) as total
,(SELECT count(fall_september_tier) FROM national_assessments.aimsweb WHERE general_outcome_measure = 'PSF' AND fall_september_tier = 1) as tier1
,(SELECT count(fall_september_tier) FROM national_assessments.aimsweb WHERE general_outcome_measure = 'PSF' AND fall_september_tier = 2) as tier2
,(SELECT count(fall_september_tier) FROM national_assessments.aimsweb WHERE general_outcome_measure = 'PSF' AND fall_september_tier = 3) as tier3
FROM national_assessments.aimsweb
WHERE general_outcome_measure = 'PSF' AND fall_september_tier IS NOT NULL

我也有这个想法，但没有运气：

SELECT tier1,total, tier1/total as test …

我编写了一个 python 脚本来在不同数据库（从 SQL Server 到 Postgres）的表之间选择和插入行。该表有大约 2000000000 行，传输停止在它中间的某个地方。我尝试选择具有偏移量的行作为已传输的行数。但是 count(*) 占用了太多的服务器资源，当我尝试时服务器变得无响应。（内存使用量在很短的时间内从 100MB 上升到 ~8GB）

我想知道是否有办法从它停止的地方提取转移。转移我目前在 Postgres 中拥有的行数大约需要 3 天时间。

谢谢。

另外，我知道大概的行数。所以也许我可以做这样的事情：如果有大约 12392320 行，删除第 12390000 行之后的所有内容，然后从 12390001 开始。这样的事情可能吗？

我在以下查询中使用 Postgres：

select count(*) from image;

此表上的主键是非递增的；它是存储在表中的图像的唯一序列号。我们的应用程序经常尝试摄取已经记录在数据库中的图像，因此主键/序列号确保它们只记录一次。

现在我们想知道是否应该使用递增的主键。我们在数据库中有 1,259,369 张图像，运行计数查询大约需要 7 分钟。

我们的应用程序永远不会从该表中删除图像 - 因此递增的主键将允许我们检查最后一个 ID 的值，该值等于表中的行数。

我正在尝试确定图像数据库中至少贡献了五张图像的贡献者总数。以下查询将按贡献者提供图像计数，但这只是难题的一部分。我相信这对于比我有更多知识的人来说很简单:)

SELECT count(*) AS i_count,contributor_id FROM images GROUP BY contributor_id ORDER BY i_count DESC

我在 SQL Server 数据库中有两张表，一张有两列，一张有四列：

1. tbl_email_list

   1. email_list_id int (PK)
   2. email_list_name varchar

2. tbl_email-details

   1. email_uniq_id int (PK)
   2. email_list_id int (FK)
   3. email_address varchar
   4. blacklist bit

我想在一个应该返回的查询中检索数据

1. 来自 tbl_email_list 的所有电子邮件列表；
2. 与特定 email_list_id 关联的 email_address 总数；
3. 列入白名单的电子邮件地址总数（其中黑名单=0）；
4. 列入黑名单的电子邮件地址总数（其中 blacklist=1）。

我在 PostgreSQL 9.4 中有这个表：

CREATE TABLE user_operations( 
    id SERIAL PRIMARY KEY, 
    operation_id integer, 
    user_id integer )

该表由~1000-2000不同的操作组成，每个操作对应于所有用户80000-120000集合S的某个子集（每个子集由大约元素组成）：

S = {1, 2, 3, ... , 122655}

参数：

work_mem = 128MB
table_size = 880MB

我也有一个关于operation_id.

问题：user_id对于operation_id集合的重要部分（20％-60％）查询所有不同的最佳计划是什么，例如：

SELECT DISTINCT user_id FROM user_operation WHERE operation_id < 500

可以在表上创建更多索引。目前，查询的计划是：

HashAggregate  (cost=196173.56..196347.14 rows=17358 width=4) (actual time=1227.408..1359.947 rows=598336 loops=1)
  ->  Bitmap Heap Scan on user_operation  (cost=46392.24..189978.17 rows=2478155 width=4) (actual time=233.163..611.182 rows=2518122 loops=1)
        Recheck Cond: …

我对数据库进行基准测试以找出最适合我的项目的数据库，我发现这count(*)在 PostgeSQL 中非常慢。我不明白这是 PostgeSQL 的正常行为还是我做错了什么。

我有一个包含 ~200M 记录的表。MySQL表定义：

CREATE TABLE t1 (
  id int(11) NOT NULL AUTO_INCREMENT,
  t2_id int(11) NOT NULL,
....  
  PRIMARY KEY (id),
  KEY index_t2 (t2_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

请求（返回~30M）：

SELECT COUNT(*) FROM t1 WHERE t2_id = 7;

运行：

25,797ms MySQL (v5.7.11)

1,222,168ms PostgeSQL (v9.5)

解释：

MySQL：

*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: t1
   partitions: NULL
         type: ref
possible_keys: index_t2
          key: index_t2
      key_len: 4
          ref: const
         rows: 59438630
     filtered: 100.00
        Extra: Using …

我正在使用 Oracle 数据库 10g。有一个包含有关客户信息的表格：

 +----+------+---------------------+
 | id | name |    registered_at    |
 +----+------+---------------------+
 |  1 | Ivan | 2016/08/01 15:09:01 |
 |  2 | Alex | 2016/08/01 16:30:21 |
 |  3 | John | 2016/08/01 16:31:05 |
 |  4 | Hugo | 2016/08/01 15:08:00 |
 |  5 | Anna | 2016/08/01 15:42:23 |
 +----+------+---------------------+

如何按regitered_at给定间隔（以分钟为单位）按列计算记录？

例如：间隔 = 10 分钟，日期时间范围从2016/08/01 15:00:00到2016/08/01 17:00:00. 结果应该是这样的：

+---------------------+---------------------+-----+
|        start_       |         end_        | cnt |
+---------------------+---------------------+-----+
| 2016/08/01 15:00:00 …

在我的应用程序服务器中，我想使用LIMIT和对数据集进行分页OFFSET，并另外将数据集的总数返回给用户。

而不是对数据库进行两次远程调用：

select count(1) as total_count from foo;
select c1 from foo;

我认为在单个数据库调用中完成此操作会更明智：

select c1, count(1) over (partition by null) from foo;

但是，与不使用窗口函数相比，添加此窗口函数会导致执行时间长一个数量级。

我觉得这很令人惊讶，因为类似的时间select count(1) from foo只需要两倍的时间select c1 from foo。然而，将其转换为窗口函数会导致性能下降。

此外，使用以下使用子查询的替代方案非常快：

select c1, (select count(1) from foo) as total_count from foo;

我本来期望 postgresql 能够优化partition by null

我在 Oracle 中尝试过这一点，发现了类似的性能损失。

如何解释为什么这里会出现性能损失？对于核心 postgresql 开发人员来说，进行更改以优化这一点是否相对容易，甚至值得，例如通过将 PARTITION BY NULL 的窗口函数转换为子查询？

设置：

drop table foo;
create table foo (c1 int);

insert into foo
select i from …