问题[postgresql]

有一个按日期分区的表。

在一个请求中，我们将日期作为参数提供给 CTE 块并计算工作日，然后在主请求中使用它：

  WITH prm 
   AS (
      SELECT 
       :dateFrom::DATE AS d_f, 
       :dateTo::DATE d_t, 
       (SELECT wrk_day d_f_wrk FROM calendar WHERE on_date=:dateFrom)
      )
   SELECT * FROM prm,tab t WHERE t.open_date BETWEEN prm.d_f_wrk AND prm.d_t

所以，如果我们在条件的主查询中使用它

BETWEEN prm.d_f_wrk AND prm.d_t

然后对所有分区进行搜索。就过滤器中的查询而言，它是这样写的：

t.open_date>=$2 AND t.open_date<='2024-10-30'::DATE

如果你使用

BETWEEN prm.d_f AND prm.d_t

然后仅过滤必要的分区。就过滤器中的查询而言，它是这样写的：

t.open_date>='2024-10-01'::DATE AND t.open_date<='2024-10-30'::DATE

如何将计算出的日期从 CTE 或以其他方式以相同日期参数的形式传递到主查询，以便分区过滤器仅过滤掉必要的日期？

另外，原则上，按分区过滤不起作用；如果日期是从另一个请求中获取的，则滑翔机会遍历所有分区。

> EXPLAIN analyze SELECT * 
FROM calendar wc, tab t 
WHERE t.open_date =wc.wrk_day  
 AND wc.on_date ='2024-10-30'
 
QUERY PLAN                                                                                                                                       |
-------------------------------------------------------------------------------------------------------------------------------------------------+
Hash JOIN  (cost=2.38..9602.67 ROWS=1099 width=85) (actual TIME=85.080..89.473 ROWS=41 loops=1)                                                  |
  Hash Cond: (t.open_date = wc.wrk_day)                                                                                                |
  ->  Append  (cost=0.00..8758.21 ROWS=316133 width=69) (actual TIME=0.590..54.404 ROWS=315957 loops=1)                                          |
        ->  Seq Scan ON t_2024_02_01 t_1  (cost=0.00..0.00 ROWS=1 width=596) (actual TIME=0.060..0.061 ROWS=0 loops=1)           |
        ->  Seq Scan ON t_2024_02_02 t_2  (cost=0.00..0.00 ROWS=1 width=596) (actual TIME=0.012..0.012 ROWS=0 loops=1)           |
        ->  Seq Scan ON t_2024_02_03 t_3  (cost=0.00..0.00 ROWS=1 width=596) (actual TIME=0.008..0.008 ROWS=0 loops=1)           |
        ->  Seq Scan ON t_2024_02_04 t_4  (cost=0.00..0.00 ROWS=1 width=596) (actual TIME=0.007..0.007 ROWS=0 loops=1)           |
...
...
->  Hash  (cost=2.37..2.37 ROWS=1 width=16) (actual TIME=0.021..0.021 ROWS=1 loops=1)                                                         |
        Buckets: 1024  Batches: 1  Memory Usage: 9kB                                                                                            |
        ->  INDEX Scan USING calendar_pkey ON calendar wc  (cost=0.15..2.37 ROWS=1 width=16) (actual TIME=0.008..0.009 ROWS=1 loops=1)|
              INDEX Cond: (on_date = '2024-10-30'::DATE)

如果您在条件中明确指定日期，则会选择必要的分区

EXPLAIN analyze 
SELECT * 
FROM calendar wc, tab t 
WHERE t.open_date=wc.wrk_day  
 AND wc.on_date ='2024-10-30' AND t.open_date>='2024-10-29' AND t.open_date<'2024-11-01'
 
QUERY PLAN                                                                                                                                      |
------------------------------------------------------------------------------------------------------------------------------------------------+
Hash JOIN  (cost=2.38..33.53 ROWS=3 width=85) (actual TIME=0.037..0.320 ROWS=41 loops=1)                                                        |
  Hash Cond: (t.open_date = wc.wrk_day)                                                                                               |
  ->  Append  (cost=0.00..28.90 ROWS=845 width=69) (actual TIME=0.012..0.225 ROWS=845 loops=1)                                                  |
        ->  Seq Scan ON t_2024_10_29 t_1  (cost=0.00..1.61 ROWS=41 width=69) (actual TIME=0.011..0.016 ROWS=41 loops=1)         |
              FILTER: ((open_date >= '2024-10-29'::DATE) AND (open_date < '2024-11-01'::DATE))                                            |
        ->  Seq Scan ON t_2024_10_30 t_2  (cost=0.00..1.87 ROWS=58 width=69) (actual TIME=0.005..0.011 ROWS=58 loops=1)         |
              FILTER: ((open_date >= '2024-10-29'::DATE) AND (open_date < '2024-11-01'::DATE))                                            |
        ->  Seq Scan ON t_2024_10_31 t_3  (cost=0.00..21.19 ROWS=746 width=69) (actual TIME=0.006..0.135 ROWS=746 loops=1)      |
              FILTER: ((open_date >= '2024-10-29'::DATE) AND (open_date < '2024-11-01'::DATE))                                            |
  ->  Hash  (cost=2.37..2.37 ROWS=1 width=16) (actual TIME=0.015..0.016 ROWS=1 loops=1)                                                         |
        Buckets: 1024  Batches: 1  Memory Usage: 9kB                                                                                            |
        ->  INDEX Scan USING calendar_pkey ON calendar wc  (cost=0.15..2.37 ROWS=1 width=16) (actual TIME=0.012..0.013 ROWS=1 loops=1)|
              INDEX Cond: (on_date = '2024-10-30'::DATE)                                                                                        |
Planning TIME: 0.408 ms                                                                                                                         |
Execution TIME: 0.356 ms                                                                                                                        |
 
15 ROW(s) fetched.

假设有两个事务：T1 和 T2。

BEGIN; -- Т1

UPDATE table
SET amount = 1
WHERE id = 1;

SELECT xmin, xmax FROM table
WHERE id = 1; 
-- получаем: xmin = xid транзакции Т1, xmax = 0

让我们开始第二笔交易：

BEGIN; -- T2

UPDATE table
SET amount = 2
WHERE id = 1; 
-- ожидание завершения транзакции Т1 

我们完成第一笔交易：

COMMIT;

我们继续第二个：

SELECT xmin, xmax FROM table
WHERE id = 1; 
-- получаем: xmin и xmax равный идентификатору (xid) транзакции Т2.

问题：为什么事务 T1 在更新后开始看到 xmax = 0，而事务 T2 在更新后开始看到 xmax = xid(T2)？我想强调的是，这些值相对于更新数据的事务是可见的。

PS 我之前不知何故没有注意到这一点，并且总是认为如果事务更改了一行，那么相对于其自身，它会在新行中看到 xmax = 0，因为这是一个新元组，而且还没有人更改它。

我研究了集群方法并遇到了 rsync 和 drdb 之类的东西。据我了解，drdb 会在两个方向上完全复制磁盘/文件夹上的数据。我在网上找不到关于是否可以将clickhouse和postgre数据完全插入到drdb中以实现被动集群中服务器之间同步的信息。我的任务是在两台物理服务器上进行被动集群。服务器上有 postgre、clickhouse、redis 和节点服务器等实体。所有元素仅与节点相关联。

我试图找到有关这方面的信息。看看这是否可以实施，如果可以，如何实施以及是否值得？

有表1格式：

(供应商 > 1) 1个月内，1个供应商只能有一个日期，月份可以跳过

表2格式：

（> 1 个供应商，> 每个供应商 1 个合同）

如何将第二个与第一个连接起来，以便第一个具有供应商和合同金额的结果列。如果缺少日期，我们将采用最后一个已知日期。

根据合同 111111，为期 03 个月 150，对于 222222 最后已知金额 200 根据合同 111111，对于 04 个月，最后已知金额 150，对于 222222 250

我开始使用 psql 数据库开发 tg 机器人，出现了一个问题：

如何在异步模式下正确使用psql数据库，从而不做大量昂贵的操作并合理使用资源。

大家好

我最近开始在aiogram 3中编写一个电报机器人。需要使用psql数据库。首先，我决定弄清楚如何在同步模式下工作，这里一切看起来都很简单 - 我们在起点创建一个永久连接，并为每个请求创建一个游标，在请求结束时关闭它。

在编写测试处理程序后，我决定尝试让机器人通过此处理程序，在短时间内通过对处理程序的 7-8 次调用以及对数据库的请求成功完成了这一任务。好吧，我并没有指望异步机器人中有同步解决方案。我开始研究异步模式工作的问题，然后问题出现了：

如何在异步模式下正确使用psql数据库，从而不做大量昂贵的操作并合理使用资源。

我阅读了在互联网上找到的一些资源、文档，并询问了 GPT。在整个示例中，为每个请求创建一个单独的连接。看来这并不是很理性。

我在一个处理程序中的典型情况是从消息中获取用户 ID，使用该 id 查询数据库并从表中提取具有该 id 的记录。大约有 10-12 个这样的处理程序。

我很高兴看到代码示例