Nishant's questions

我正在进行批量更新，按顺序处理记录（用户 1、用户 2 等）。每条记录都有多个与其关联的更新查询。如果单个记录（在本例中为用户）存在数据问题，我需要跳过。理想情况下，我想并行处理它们，但还没有达到那个水平（有很多挑战）。

是否可以这样做：

1. 有一个交易。
2. 如果出现故障，与该记录关联的语句将回滚，而不影响其他记录。
3. 犯罪。

例如，我的 CSV 文件中有 4 个用户。如果 3 个是好的，1 个是坏的，则 3 个应该原子地提交（或中止）；1 应该因错误而被跳过。

观察到的：

do everything for user 1;
do everything for user 2;
--> if there is failure, it rolls back the *entire* transaction
do everything for user 3;

事实上，任何错误级别 >= 16 都会回滚整个事务。

预期的：

do everything for user 1;
do everything for user 2;
--> if there is failure, roll back this *block* only
do everything for user 3;
do everything for user 4;

这是任何编程语言的正常try-catch要求；但是，无法看到 SQL Server 等效项（涉及事务）。我读过有关检查点的内容，但不确定这是否是一个值得考虑的选项。

我们可以在 Linux 客户端（网络服务器等）中创建“服务器别名”，这样您就可以在不触及应用程序的 DB URL 字符串的情况下更改连接？

官方文档似乎在谈论在 Windows 中执行此操作的 GUI 方式，所以我想知道 Linux 是否存在类似的东西。这有很多好处，尤其是在应用程序的容器化期间。

我的高级目标是看看我是否可以创建某种级别的间接，以便应用程序始终将 DB 视为DSN=myDsn;Uid=myUsername;Pwd=myPwd;真正的驱动程序将其重定向到DSN=realDsn;Uid=realUsername;Pwd=realPwd;. 最初我在想类似的东西socat，但我不确定如何处理密码更改！“客户端的服务器别名”似乎做了这样的事情，因此问题。

我在 MSSQL Server 2019 ( SQLFiddle )中有以下架构/数据：

CREATE TABLE products(
    idn NUMERIC(9) PRIMARY KEY
);

CREATE TABLE sales(
    idn NUMERIC(9) PRIMARY KEY,
    pid VARCHAR(50) NOT NULL,
    type VARCHAR(10) NOT NULL
);

INSERT INTO products (idn) VALUES (1);
INSERT INTO sales (idn, pid, type) VALUES (1, 1, 'number');
INSERT INTO sales (idn, pid, type) VALUES (2, 'Colgate', 'word');

sales具有混合数据，即VARCHAR和NUMERIC。事务过滤器负责JOIN正确处理。

为什么以下SELECT失败（由于某种我无法控制的原因，生成的查询包含N字符串的文字。）？

SELECT 
    * 
FROM 
    products 
    INNER JOIN sales ON products.idn = sales.pid 
    AND sales.type = N'number' 
WHERE 
    products.idn in (1);

我不明白为什么投射NVARCHAR到NUMERIC是一个问题：

SELECT CAST (N'1' as NUMERIC);

如果我稍微修改查询，它可以工作：

SELECT 
    * 
FROM 
    products 
    INNER JOIN sales ON products.idn = sales.pid 
    AND sales.type = N 'number' 
WHERE
    -- Selecting the same data from `sales`.
    sales.pid in (1);

SELECT 
    * 
FROM 
    products 
    INNER JOIN sales ON products.idn = sales.pid
    -- Dropping the `N` prefix.
    AND sales.type = 'number' 
WHERE 
    products.idn in (1);

我想编写一个自动化脚本，从其备份文件中恢复 SQL Server DB。但是，这样做在 SQL 中并不是一个简单的过程，因为主查询需要额外的输入，而这些输入实际上可以使用另一个查询获得。我可以在一个查询中执行此操作吗？

SO上有一个问题；但解决方案不是很灵活。RESTORE FILELISTONLY的定义变化非常频繁。即便如此，该解决方案似乎也非常冗长。

没有更简单的方法将查询结果存储到变量中并使用它们吗？这是任何编程语言的小菜一碟。

获取逻辑名称：

RESTORE FILELISTONLY
FROM DISK = 'D:SourceBackUpFile.bak'
GO

恢复数据库：

RESTORE DATABASE DBName
FROM DISK = 'D:SourceBackUpFile.bak'
WITH RECOVERY
MOVE 'SourceMDFLogicalName' TO 'D:TargetMDFFile.mdf',
MOVE 'SourceLDFLogicalName' TO 'D:TargetLDFFile.ldf'

我想使用不带触发器的 SQL 查询来保留表的历史记录。最简单的方法是像下面这样触发一个SELECT并INSERT进入历史表：

INSERT INTO history (field1, field2) 
SELECT 
  field1, 
  field2 
FROM 
  current 
WHERE 
  field1 = condition

columns但是，是否可以在不对ieselect *等价物进行硬编码的情况下做到这一点？

我需要将此字符“●”插入到VARCHARMSSQL 数据库的列中，并将排序规则设置为SQL_Latin1_General_CP1_CI_AS（或至少模拟我的 Python + Windows MSSQL 驱动程序可能已经完成的操作）。我试图从我的客户那里插入它，但它被插入为?.

在 Python 中检查的十六进制值\xe2\x97\x8f是二进制 226、151、143。

排序规则说明 226 已定义，但 143 和 151 未定义。所以我最好是插入226？

我做这个练习的原因是我们的应用程序早先将这个字符插入到 DB 中。在这一点上，我不知道它是如何进入的，因为它通过一个带有 Windows MSSQL 驱动程序的 Python 应用程序，我们的数据库团队编写了一个脚本来纠正它，显然它被替换为“？”。

现在我只是想重现这个场景来问他们为什么它被替换为“？” 因为我们在应用程序中将其替换为空。由于我的应用程序已经修复了这个问题（我们删除了任何大于 127 的内容），我试图直接从后端模拟它以证明它正在被替换为“？” 这实际上是我的主张，我认为它已经完成，因为它在更新查询中说“整理”。

UPDATE pr_response
SET nur_respon =
REPLACE (nur_respon,
     SUBSTRING(nur_respon, PATINDEX('%[^ !-~]%' COLLATE Latin1_General_BIN, nur_respon), 1),
         '')
WHERE PATINDEX('%[^ !-~]%' COLLATE Latin1_General_BIN, nur_respon) > 0

这是删除 Non-ASCII-Data > 127 的好脚本吗？有人可以用简单的英语解释这个查询吗？

我们注意到这样的错误：

InterfaceError: ('HY104', 0, '[Microsoft][SQL Server Native Client 11.0]
Invalid precision value', 10226)

当我们插入一定长度的字符以及 Unicode 内容（如\u3000（表意空间））时，就会发生这种情况。仅当我们使用 Windows MSSQL 驱动程序并且查询已参数化时才会发生这种情况。

该列是一个VARCHAR(MAX). 所以它应该支持2GB。

• 这可能是什么原因？
• 为什么长度很重要？

如果我只插入这个 Unicode 字符，它不会引起问题！

我试图从理论的角度来看待这一点。切换到NVARCHAR目前不是我们的选择，但删除 Unicode 是。

根据 Solomon Rutzky 提出的问题，以下是更多详细信息：

1. 列排序规则是SQL_Latin1_General_CP1_CI_AS
2. 我开始看到错误的字符串长度是4019.
3. sqlalchemy.connectors.mxodbc, line 86, in error_handler是我得到初始错误的地方。这是来自追溯。
4. 它适用于单个 Unicode 字符。
5. 没有 Unicode 的 20000 个字符串可以正常工作。
6. 当我从这个软件（Web App）尝试这个时，它就变成了ASCII。我通过导出数据在 Dbeaver 中进行了测试。

我们正在尝试blob使用简单的脚本将（二进制数据）从一个数据库复制到另一个数据库。这是我们要做的步骤。

1. 使用 MSSQL Studio 客户端选择值。
2. 将其复制到剪贴板。
3. 使用 .将其粘贴到INSERT脚本中notepad。
4. 将其应用到目标数据库。

我们注意到该值现在是一个以ASCII它开头的值，0x255....它似乎是数据的hexadecimal表示binary。有没有办法在插入过程中将其转换回二进制？

有没有更好的方法来blob使用脚本复制数据？假设我们没有直接连接到目标数据库。

目前我们使用分页过滤器执行两个查询来获取计数和结果。虽然我们可以轻松地将这两者组合成一个网络调用（使用 sql 分隔符），但有没有办法在遵循DRY原则的单个查询中做到这一点？

-- count    
SELECT COUNT(*) FROM table;

-- result with pagination
SELECT *
FROM (SELECT ROW_NUMBER() OVER (ORDER BY tbl.idn) AS row, * FROM tbl)_tbl
WHERE row >= 1 AND row <= 10;

维护两个查询确实具有挑战性 - 单个查询减少了维护开销。

一个部分解决方案是获得所有在和Notes (VARCHAR)中存在不平衡的地方。但是我该如何为此编写查询呢？<>

例如：

Input: <html>Hello World</html>
Output: Valid HTML

Input: <html><Hello World</html>
Output: Invalid HTML

Input: <html><Hello World></html>
Output: Valid HTML (Marking it Valid is OK for my use case)
But hey isn't that a valid HTML? It could be <name attribute>

有没有更好的方法来检查“无效”HTML，其中“无效”被定义为 HTML 内容<后跟一些HTML Element按照规范无效的字符？

最初我以为我可以检查 for<name后跟一个(Space) 但 HTML 属性的语法为 as<name attribute并在最后关闭>。

如何检查SQL Server 中是否VARCHAR(MAX) column有？ASCII Control Characters

具体来说，我正在寻找0x01 SOH. 此代码是否有效，它是从他们检查LF字符的示例中复制的，即CHAR(13)

SELECT * FROM notes where content LIKE '%' + CHAR(1) + '%';

在任何情况下，我都希望得到一个通用查询，Control Characters而不是像这样的硬编码。

包含所有其他列的列上的非聚集索引是否几乎就像不同列上的聚集索引？它实际上会复制整个表格吗？

通常您可能不需要这样做，因为查找行可能比复制数据成本更低，但我是从理论上的角度问的。

我使用以下数据库系统MSSQL，PostgreSQL并且Oracle。它会依赖于不同的数据库吗？

假设我有一个表student和一个exam跟踪学生参加的所有考试的表，我如何找到所有通过或未参加任何类似于白名单的考试的学生？在此示例中，这意味着学生 1 和 2。

PS：passflagU表示状态未知，activeflagN表示考试已被删除，其余的标志是不言自明的。

说清楚一点，真正的用例其实是assessments，我需要找出没有pending评估的人可以参与，这样他们才能进行下一组程序。其他人则需要完成待处理的项目。

+-------------+------+
| student_idn | name |
+-------------+------+
| 1           | Mark |
| 2           | Jack |
| 3           | Jane |
| 4           | Jill |
+-------------+------+

+----------+-------------+------+--------+
| exam_idn | student_idn | pass | active |
+----------+-------------+------+--------+
| 1        | 1           | Y    | Y      |
| 2        | 1           | Y    | Y      |
| 3        | 1           | Y    | Y      |
| 4        | 2           | Y    | Y      |
| 5        | 2           | N    | N      |
| 6        | 3           | Y    | Y      |
| 7        | 3           | Y    | Y      |
| 8        | 3           | Y    | Y      |
| 9        | 3           | N    | Y      |
| 10       | 4           | U    | Y      |
+----------+-------------+------+--------+

我想出了下面的查询，但有没有更好的方法来做到这一点？我觉得这是 O(n) 或 O(nlogn) 取决于索引等不确定（任何人都知道最好的可能）因此应该接近最优？

SELECT
  *
FROM student
WHERE NOT EXISTS (SELECT
  *
FROM exam
WHERE exam.student_idn = student.student_idn
AND pass <> 'Y'
AND active = 'Y')

查找表（或代码表，有些人称之为）通常是可以为特定列给出的可能值的集合。

例如，假设我们有一个名为party（用于存储有关政党的信息）的查找表，它有两列：

• party_code_idn，它保存系统生成的数值，并且（缺乏业务领域含义）用作真实键的代理。
• party_code, 是表的真实或“自然”键，因为它维护具有业务领域内涵的值。

让我们说这样的表保留了以下数据：

 +----------------+------------+
 | party_code_idn | party_code |
 +----------------+------------+
 |              1 | Republican |
 |              2 | Democratic |
 +----------------+------------+

该party_code列保留值“Republican”和“Democratic”，作为表的真正键，设置了一个 UNIQUE 约束，但我选择添加party_code_idn并将其定义为表的 PK（尽管从逻辑上讲,party_code可以作为 PRIMARY KEY [PK])。

问题

从事务表中指向查找值的最佳实践是什么？我应该建立外键（FK）引用（a）直接指向自然和有意义的值还是（b）替代值？

选项（a），例如，

 +---------------+------------+---------+
 | candidate_idn | party_code |  city   |
 +---------------+------------+---------+
 |             1 | Democratic | Alaska  |
 |             2 | Republican | Memphis |
 +---------------+------------+---------+

具有以下属性¹：

1. 最终用户可读 (+)
2. 易于跨系统导入导出(+)
3. 很难更改值，因为它需要在所有引用表中进行修改 (-)
4. 添加新价值并不昂贵（=）

我认为这几乎就像“按值传递”，以应用程序编程术语中的函数调用进行类比。

选项 (b)，例如，

 +---------------+----------------+---------+
 | candidate_idn | party_code_idn |  city   |
 +---------------+----------------+---------+
 |             1 |              1 | Alaska  |
 |             2 |              2 | Memphis |
 +---------------+----------------+---------+

具有以下属性：

1. 最终用户不可读 (-)
2. 难以导入导出，因为我们需要取消引用它 (-)
3. 易于更改值，因为我们仅将引用存储在事务表中(+)
4. 添加新价值并不昂贵（=）

如果与应用程序编程用语中的函数调用相比，它与“通过引用传递”非常相似。

导入-导出也可以以不同的方式完成，即，只需再次填充查找表，然后重新播种代理列。我希望我做对了，这是我刚刚听说的一种可能性。

_{1. 注意+,-并=指出这些属性的好处。}

问题

非常重要的是：如果我们只使用后一种方法，查找（或代码）表和 FK 引用之间是否有区别？我认为它们的工作方式相同。

相关资源

• 查找表有多重要？

• 代码或查找表的最佳实践

• 查找表最佳实践数据库表或枚举

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

如果需要将项目作为item_id添加到Order表中，如何在 DB 中施加额外的约束，表明Item应该是“可用的”（在那个时间点）？项目手动确定为“可用”，在此场景中无法从数据库中的其他字段派生。

一种模式设计（我更喜欢）是添加一个具有“可用”和“不可用”字段的类型列。但是如何检查外键约束item_id不仅应该是Item表中的主键，它的类型也应该是“可用”？

这个Stack Overflow使用检查约束的答案似乎很接近，但这是唯一的方法吗？我觉得这对于 RDBMS 来说是一件微不足道的事情，还是这不是一个规范化的数据？

另一种模式设计（我不喜欢）是有一个名为“菜单”的表，它只能有可用的项目。问题是这张桌子在本质上会变得非常动态，并且它会根据物品的可用性不断变化。而且，我只是根据其状态从 Items 中创建一个子表，这似乎不是一个好主意。

以编程方式很容易做到这一点；但是，我如何在 RDBMS 中实现这一点？我喜欢数据库足够智能来处理这个问题的想法。