按照SQL Server DAG 的手动故障转移中的步骤操作

要验证两个可用性组是否已准备好进行故障转移，请使用以下在 SQLCMD 模式下运行的 T-SQL 查询：

:CONNECT TDPRD071  
SELECT ag.name, drs.database_id, db_name(drs.database_id) as database_name,  
       drs.group_id, drs.replica_id, drs.last_hardened_lsn  
FROM sys.dm_hadr_database_replica_states drs  
INNER JOIN sys.availability_groups ag ON drs.group_id = ag.group_id;

:CONNECT TDDR071  
SELECT ag.name, drs.database_id, db_name(drs.database_id) as database_name,  
       drs.group_id, drs.replica_id, drs.last_hardened_lsn  
FROM sys.dm_hadr_database_replica_states drs  
INNER JOIN sys.availability_groups ag ON drs.group_id = ag.group_id;

如文章中所示，从全局主节点运行上述查询的结果屏幕截图显示了与 DAG 中每个 AG 的连接。

但是，当我在 DAG 的全局主节点上运行查询时，得到的结果仅来自与转发器的连接。因此，显示的两组结果仅来自与 AG02 的连接。

但是，如果我单独运行这两个查询（均来自全局主数据库），它们将根据情况正确连接到 AG01 或 AG02。

请问您有什么建议可以解释我为什么会出现这种行为吗？

谢谢。

我们目前有一台运行在 Oracle Linux 上的 MySQL 8 服务器。它运行在德克萨斯州一个托管数据中心的虚拟机上。

大约 95% 的时间花在 SELECT 操作上，大约 5% 的时间花在 INSERT 和 UPDATE 上。

我们正在努力在单独的位置（MO）添加另一个 mysql 服务器，主要是为了实现冗余和灾难恢复目的。

我的想法是，在两个位置之间建立一个隧道，并使用主位置作为主服务器来设置 MySQL 复制。这样，如果发生灾难，我可以切换到从服务器。但有一个缺点，那就是除非发生意外，否则这台专用的从服务器就一直闲置在那里，可能没有任何好处。

我正在考虑如何利用它，也许更新我的应用程序以使用从属服务器来处理一些繁重的查询/报告。

我原本以为这是一个很棒的计划，直到我开始阅读有关 MySQL 集群的文章。我们实在没有办法搭建集群所需的第三台专用 MySQL 服务器。

我的问题是：

假设您在 2 个位置有 2 个 mysql 节点，您将如何最好地利用它们？

我们的应用服务器所有东西都在 Docker 容器中运行。为了构建 MySQL 集群而不是复制，在应用服务器中添加一个 MySQL 实例（在 Docker 容器中）会不会是个疯狂的想法？

如果集群确实可行（通过应用服务器上的 MySQL 实例），我的理解是写入速度可能会变慢，因为写入操作要等到集群中所有节点都写入完毕才能完成？这可能意味着，如果集群节点分布在多个位置，写入速度会显著降低，因为两个站点之间会存在一些延迟？

任何建议都将受到赞赏。

我可能需要更改 Postgresql 配置中 lc_messages、lc_monetary、lc_numeric 和 lc_time 的区域设置。但是，在执行此操作之前，我需要了解它们具体会影响哪些内容。Postgresql 文档列出了受影响的内容，但仍然留下了很多问题。例如，文档中说upper和lower函数会受到影响。这是所有设置都受影响吗？还是只有部分设置受影响？文档中还说 to_char() 会受到影响。具体是如何影响的？

我想提前知道此更改是否需要更改应用程序代码，那么是否有好的资源可以帮助我生成要测试的功能/场景列表？

在 MySQL 8 服务器社区版中，下面是SQL查询和命令MySQL Shell的示例：

SELECT * FROM planet;
DESC planet;
SHOW DATABASES;
SHOW tables;

正如您所见，必须在句子末尾声明;字符（或\g根据情况声明字符）。\G

但我确实错误地意识到，无需执行use命令即可更改数据库。 ;

因此，下面两个命令可以和平地工作：

use <datababase>
use <datababase>;

只是好奇：

问题

• 为什么use命令不需要;执行？

老实说，我不确定这是否是这种情况下的独特命令，但为什么它与其他命令不同？

我找不到有关其SNAPSHOT ISOLATION功能的详细信息。我在 SQL Server 2019 上测试了以下查询（禁用了 ADR）：

SET TRANSACTION ISOLATION LEVEL SNAPSHOT;
BEGIN TRAN;
WAITFOR DELAY '00:00:20'; -- insert of one record to dbo.MARA_CT in different session
SELECT
    *
FROM dbo.MARA_CT AS mc;
WAITFOR DELAY '00:00:20'; -- insert of one record to dbo.Album in different session
SELECT
    *
FROM dbo.Album AS a;
WAITFOR DELAY '00:00:20';
SELECT
    *
FROM dbo.MARA_CT AS mc;
SELECT
    *
FROM dbo.Album AS a;
COMMIT;

正如评论中所述，我在 中插入了一行，dbo.MARA_CT而在第二个 中WAITFOR DELAY，我在 中插入了一条记录dbo.Album。根据Microsoft文档：

The term "snapshot" reflects the fact that all queries in the transaction see the same version, or snapshot, of the database, based on the state of the database at the moment in time when the transaction begins.

我的查询得到的结果如下：

1. dbo.MARA_CT 包含在第一个 WAITFOR DELAY‘00:00:20’期间插入的记录。
2. dbo.Album 不包含在第二个 WAITFOR DELAY‘00:00:20’期间插入的记录。

在我看来，查询中任何表的“首次接触”都会为整个事务创建一个“快照”，而不是捕获事务开始时数据库的状态。关于SNAPSHOT ISOLATION，我还有其他问题：

1. SNAPSHOT ISOLATION 会存储数据库中所有行从事务开始的所有版本，还是仅存储查询中使用的表的版本？这是如何工作的？

2. 如果启用了 RCSI，并且我们随后启用了 SNAPSHOT ISOLATION，SQL Server 是否会在 tempdb 中存储任何新值/版本？

3. 在我的案例中，使用数据库快照的目的SNAPSHOT ISOLATION是测试新版本的过程和视图（新模式）。即使涉及的表不断进行插入、更新和删除操作，新旧过程都需要返回相同数量的记录并使用相同的数据。我曾考虑使用数据库快照，但现在发现它SNAPSHOT ISOLATION可能更有优势，因为数据库上已经启用了 RCSI。

在 MySQL 8 服务器社区中，可以执行MySQL Shell以下命令导出 SQL 查询的输出（最基本的）：

SELECT * FROM cientifico INTO OUTFILE '/var/lib/mysql-files/cientifico-data.txt';

并且它按预期工作

但对于非 SQL 查询如下：

SHOW PROCESSLIST INTO OUTFILE '/var/lib/mysql-files/processlist.txt';

引发以下错误

错误 1064 (42000)：您的 SQL 语法有错误；请查阅与您的 MySQL 服务器版本相对应的手册，以了解在第 1 行附近“INTO OUTFILE '/var/lib/mysql-files/processlist.txt'”使用的正确语法

相同于：

SHOW DATABASES INTO OUTFILE '/var/lib/mysql-files/databases.txt';

给予

错误 1064 (42000)：您的 SQL 语法有错误；请查阅与您的 MySQL 服务器版本相对应的手册，以了解在第 1 行附近“INTO OUTFILE '/var/lib/mysql-files/databases.txt'”使用的正确语法

因此如果可能的话

问题

• 如何导出非 SQL 查询语句的输出？

我假设该INTO OUTFILE语法仅适用于 SQL 语句，但对于非 SQL 语句呢？

根据我在网上以及本网站找到的信息，我尝试了以下所有方法（1-5）来检索 SQL Server 的最后启动日期：

SELECT 0 as Id, SYSDATETIME() as DT
union
SELECT 1, sqlserver_start_time FROM sys.dm_os_sys_info  
union
SELECT 2, login_time FROM sys.dm_exec_sessions WHERE session_id = 1
union
SELECT 3, start_time from sys.traces where is_default = 1
union
SELECT 4, crdate FROM sysdatabases WHERE name='tempdb'
union
SELECT 5, create_date FROM sys.databases WHERE name = 'tempdb'

结果是：

0   2025-04-17 23:38:26.9364166
1   2025-04-13 19:09:42.2000000
2   2025-04-13 19:09:44.3166667
3   2025-04-13 19:09:46.5600000
4   2025-04-13 19:09:51.0900000
5   2025-04-13 19:09:51.0900000

问题：我一小时前刚启动了机器（以及随之启动的 SQL Server）。我预期的应该是 2025-04-17 22:38……，而不是 2025-04-13 19:09……。

该 SQL 服务器安装在 VMware 盒中。

在另一个 SQL Server 中，相同的版本和版本，我得到了正确的结果：

Id  DT
0   2025-04-18 14:34:49.3442637
1   2025-04-18 14:34:03.4333333
2   2025-04-18 14:34:05.1233333
3   2025-04-18 14:34:09.7400000
4   2025-04-18 14:34:14.6100000
5   2025-04-18 14:34:14.6100000

我不明白为什么虚拟机中的结果会出错。我每次工作时都会启动和关闭主机和虚拟机。

我这里遗漏了什么吗？

• SQL Server 开发版 2019

在 MySQL 8 服务器社区中，以下两个命令显示相同的结构：

SHOW PROCESSLIST;
SELECT * FROM information_schema.PROCESSLIST;

问题

• 什么时候使用SHOW PROCESSLISTvsSELECT * FROM information_schema.PROCESSLIST命令？

每个命令的存在都有特定的原因，对吗？

关于它们的输出，我只发现每个命令的State和列分别有两个区别：Info

State     | Info
----------------------------
init      | SHOW PROCESSLIST
executing | SELECT * FROM information_schema.PROCESSLIST

该列的区别Info很明显，因为它代表了执行的命令本身，但是：

• 为什么列不同State？

价值很明确，executing但是：

• 这个值代表什么init意思？

产品名称

OceanBase V4.2.5-社区版本

问题描述

obd部署集群：
三台机器1-1-1，16c64G，memory_limit=32G

导入csv文件，1亿条数据，按时间字段分区100个，未设置主键

我使用这种方法导入数据：
load data/ +parallel(9)load_batch_size(18) /

结果非常耗时

如何处理才能快速导入一亿条数据？

系统内置租户设置：

alter system set system_memory=‘15g’; 
alter resource unit sys_unit_config max_memory=‘15g’,min_memory=‘15g’; 
#Tuning Parameters 
alter system set enable_merge_by_turn= False; 
alter system set trace_log_slow_query_watermark=‘100s’; 
alter system set max_kept_major_version_number=1; 
alter system set enable_sql_operator_dump=True; 
alter system set _hash_area_size=‘3g’; 
alter system set memstore_limit_percentage=50; 
alter system set enable_rebalance=False; 
alter system set memory_chunk_cache_size=‘1g’; 
alter system set minor_freeze_times=5; 
alter system set merge_thread_count=20; 
alter system set cache_wash_threshold=‘30g’; 
alter system set _ob_enable_prepared_statement=true; 
##Adjust the log level and number of saved logs 
alter system set syslog_level=‘PERF’; 
alter system set max_syslog_file_count=100; 
alter system set enable_syslog_recycle=‘True’; 

自定义租户设置：

CREATE RESOURCE UNIT unit1 max_cpu = 9,max_memory = 3006477108,min_memory = 3006477108, max_iops = 10000,min_iops = 1280,max_session_num = 3000,max_disk_size = 214748364800 – 200 GB; 
set global NLS_DATE_FORMAT=‘YYYY-MM-DD HH24:MI:SS’; 
set global NLS_TIMESTAMP_FORMAT=‘YYYY-MM-DD HH24:MI:SS.FF’; 
set global NLS_TIMESTAMP_TZ_FORMAT=‘YYYY-MM-DD HH24:MI:SS.FF TZR TZD’; 
set global ob_sql_work_area_percentage=80; 
set global optimizer_use_sql_plan_baselines = true; 
set global optimizer_capture_sql_plan_baselines = true; 
alter system set ob_enable_batched_multi_statement=‘true’; 
##Set under the tenant to prevent transaction timeout
show variables like ‘%timeout%’; 
set global ob_query_timeout=72000000000; 
set global ob_trx_timeout=72000000000; 
set global max_allowed_packet=67108864; 
#Execute load data permission
set global secure_file_priv=’’; 
grant file on *.* to sqluser01;

我有一个简单的事务，具有隔离级别READ COMMITTED 表设置很简单

create table example.parent_tbl(
id int auto_increment primary key
);

create table example.child_tbl(
id int auto_increment primary key,
parent_id int not null,
update_dt timestamp default current_timestamp ON UPDATE current_timestamp,

foreign key (parent_id) references parent_tbl(id),
unique (parent_id)
);

select 
p.*
from example.parent_tbl p
where p.id not in (select parent_id from example.child_tbl)
limit 1
for update
skip locked; 

之后，我将使用 插入一条新parent_tbl.id记录child_tbl。

中的 ID 列child_tbl是唯一的。我有多个进程并行运行，偶尔其中一个进程会触发完整性异常，因为相同的 IDchild_tbl已经存在。

问题

为什么一个交易可以选择一个出现在的ID child_tbl？

这个逻辑似乎微不足道。

要么事务 A 持有提交前的行锁parent_tbl，要么事务 B 会跳过它。

或者

事务 A 已提交，事务 B 的 where 子句将过滤掉该行并将其跳过。

但事实告诉我事实并非如此！！！

通用查询日志显示了这种锁定机制的违反直觉的行为

服务器端日志

有两个进程并行运行，执行相同的操作。在本例中，它们分别是线程 60 和 61。

观察到两种结果。

1. 线程 61 将 id 113 插入到child_tbl中，并释放了行锁。线程 60 运行查询，但无法检测到线程 61 刚刚插入的 id 为 113 的行。

2. 线程 61 将 id 113 插入到child_tbl中，并且在它提交并释放行锁之前，另一个线程 60 运行查询并获取parent_tbl的相同行锁。

额外的

我对 PostgreSQL 进行了相同的测试，也遇到了异常。