主页 / user-535725

Lobster25's questions

Martin Hope
Lobster25
Asked: 2024-11-24 03:14:06 +0000 UTC
  • 6

有 2 个表：t1 包含主要时间段，t2 - 其中需要排除的时间间隔。

CREATE TABLE t1 (
    start_date DATE NOT NULL,
    finish_date DATE NOT NULL
);

INSERT INTO t1 (start_date, finish_date)
VALUES ('2023-04-02', '2023-07-31');


CREATE TABLE t2 (
    exception_start_date DATE NOT NULL,
    exception_finish_date DATE NOT NULL
);

INSERT INTO t2 (exception_start_date, exception_finish_date)
VALUES 
('2023-04-15', '2023-05-01'),
--('2023-06-01', '2023-07-01');

从 t2 开始的时间间隔始终完全位于 t1 内，并且彼此不相交。它们的数量可以是无限的

如果只有一个异常，解决方案很简单，可能如下所示：

with cte as (
select *
from t1 join t2
on t1.start_date < t2.exception_start_date and t1.finish_date > t2.exception_finish_date
)
select start_date as start_date, dateadd(day, -1, exception_start_date) as finish_date
from cte
union all
select dateadd(day, 1, exception_finish_date) as start_dt, finish_date as finish_date
from cte

请告诉我如何实现相同的逻辑，但在一个时间间隔内无限数量的异常？

ps 任何 DBMS 的语法

sql
Martin Hope
Lobster25
Asked: 2024-07-24 03:30:08 +0000 UTC
  • 9

刚开始学习Python，我遇到了一个对我来说并不明显的现象。

当用字典变量填充字典的值时，结果发现改变这个变量后，字典中的值也改变了。

var_dict_value = {'one' : 1, 'two' : 2}

var_dict = {}
var_dict ['first'] = var_dict_value

print(var_dict) 
# {'first': {'one': 1, 'two': 2}}


print('chg var_dict_value to 7777')
var_dict_value['one'] = 7777

print(var_dict)
# {'first': {'one': 7777, 'two': 2}}

由此我可以得出结论，当引用一个变量时，我们不是使用它的值，而是将它作为指向值的指针（我在某个地方听到过关于如何在Python中一切都是对象的巧妙说法，但这并不意味着任何事情）对我来说他没有说）。

但是普通变量（不是字典）的类似情况给出了不同的效果 - 在更改其定义中涉及的变量后，变量的值不会改变

a = 5
b = a

print(f'a = {a}, b = {b}')
# a = 5, b = 5

a = 10
print(f'a = {a}, b = {b}')
# a = 10, b = 5

因此问题是：

  1. 这两种情况的根本区别是什么？为什么在第一种情况下，值（在字典中）在更改变量后发生变化，但在第二种情况下 - 不是
  2. 在字典的情况下如何“常量”一个值？即如何保证当var_dict_value改变时，var_dict中的数据不改变？
python
Martin Hope
Lobster25
Asked: 2024-03-25 16:19:35 +0000 UTC
  • 6

来自Postgers 文档：“您不能在 PL/pgSQL 函数中使用 COMMIT。该函数在某些外部事务中运行，因此 COMMIT 将意味着该函数的终止。”

通过 Google 和科学研究，我意识到 Postgres 中的函数执行的代码是原子的。我们也无法在其中显式声明事务；我们会收到错误。

请告诉我：

  1. 如果可能的话，请详细说明事务性在 PL/pgSQL 函数中通常如何工作？
  2. 我感兴趣的具体问题是：这些隐式“外部”事务的隔离级别是什么？首先，从并行事务和行上施加的锁的变化的可见性的角度来看，这是有趣的（如果 Postgres 这样做，我表面上熟悉 MVCC 概念）。
sql