标签: optimization

我有这个查询：

SELECT YEAR(datetime) AS Year, WEEK(datetime) AS Week, COUNT(*) AS total
FROM table
GROUP BY Year, Week;

结果是：

+------+------+-------+
| Year | Week | total |
+------+------+-------+
| 2016 |   49 |    14 |
| 2016 |   50 |    20 |
| 2016 |   51 |    19 |
| 2016 |   52 |    15 |
| 2017 |    1 |    13 |
| 2017 |    2 |    14 |
| 2017 |    3 |    12 |
| 2017 |    4 …

前段时间我使用了查询提示，但后来意识到大多数时候 SQL Server 比我更聪明。 构建额外的索引/重新组织数据或查询并获得比强制服务器使用计划要好得多的结果这通常效率低下，但对于某些数据子集来说速度足够快。但现在我处于一种我不知道如何更好地组织数据的情况。

我有两张桌子。第一个表 T1 是 (Id, CustomerId)，第二个表 T2 具有相同的列。我想在 CustomerId 上加入 T1 到 T2。并获得前 N 行。在这种情况下，优化器看到我只需要 N 个 top 并说，“嘿，我将使用循环并很快找到 N 个匹配项，尤其是当我使用索引查找时。” 但它不起作用，因为没有满足条件的数据。因此它使用 aloop join来连接一个 25m 的表和一个非常慢的 100k 表。

当我强制 SQL Server 使用合并联接时，我得到以下计划，该计划在一秒钟内执行：

我不想强迫它有两个原因：

• 首先，正如我之前所说，SQL Server 足够智能。
• 其次，我使用的是 ORM，并且很难在生成的查询中注入提示，所以我想避免它。

在这种情况下我该怎么办？

我有一个分区表，在现实生活中它有 8000 万行。

出于测试目的，我在这里创建并分区了这个表。

当我运行以下查询时：

select * from countries
where visit >= '20110101'
  and visit <= '20111231'

正如您在此处和下图的查询计划中看到的那样，它使用分区消除，所以我知道我在做一些正确的事情。

我知道分区通常不是为了加速我的查询，它是一个管理功能，但是，它可以加速对大表的查询。

我将首先说明我不想要的东西。我不想从我的表中删除任何分区。

我想要的是？

我想以最快的方式从分区中删除所有数据：

有什么比这更快的吗？ 不考虑批量删除

BEGIN TRANSACTION T1

DELETE 
FROM dbo.countries WITH (TABLOCKX)
WHERE visit >= '20110101'
  AND visit <= '20111231'

--COMMIT TRANSACTION T1

查询计划在这里

我们有两个表：

 CREATE TABLE `messages` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `created` int(10) unsigned DEFAULT '0',
  `user_id` int(11) DEFAULT '0',
....
  `subject_id` int(11) unsigned DEFAULT '0',
  PRIMARY KEY (`id`),
  UNIQUE KEY `id` (`id`),
  KEY `user_id` (`user_id`),
  KEY `created` (`created`),
  KEY `text_id` (`text_id`) USING BTREE,
  KEY `subject_id` (`subject_id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=237542180 DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT

第二个：

CREATE TABLE `users` (
  `id` int(12) NOT NULL AUTO_INCREMENT,
  `email` char(150) DEFAULT NULL,
  `reg_time` int(10) unsigned DEFAULT '0',
  `password` char(255) DEFAULT NULL,
...................
  `moderation` int(1) …

我有这个查询并且有效。但对我来说，它需要一些优化似乎很难看，因为我一遍又一遍地重复相同的动作。必须有更好的方法来合并所有这些

SELECT *
FROM
  (SELECT COUNT(*) AS a
   FROM order_item_histories
   WHERE order_status_id IN (5, 4, 15)) AS e,
  (SELECT COUNT(*) AS b
   FROM order_item_histories
   WHERE order_status_id IN (6)) AS f,
  (SELECT COUNT(*) AS c
   FROM order_item_histories
   WHERE order_status_id IN (4, 10, 9, 12, 7)) AS g,
  (SELECT COUNT(*) AS d
   FROM order_item_histories
   WHERE order_status_id IN (11, 16, 17, 13)) AS h

我有下表：

create table Order_Details
(
 ID int not null primary key
,Order_ID int
,Order_Description nvarchar(40)
)

我们在上表中插入了 27,500,000 行，当我在查询下面运行时，它需要 6-7 秒。

select ID,Order_ID, Order_Description 
from Order_Details
where Order_Description  like '%Football Size%'

我在Order_Description包含ID和应用了非聚集索引Order_ID。

还有其他方法可以优化查询并以更快的方式获得结果吗？

LTRIM与RTRIM结合使用时，您放置的操作顺序是否重要ISNULL？例如，以下面的示例为例，用户可能会在字段中输入一堆空格，但我们将其输入修剪为实际NULL值以避免存储空字符串。

我正在执行以下TRIM操作ISNULL：

DECLARE @Test1 varchar(16) = '    '

IF LTRIM(RTRIM(ISNULL(@Test1,''))) = ''
BEGIN
    SET @Test1 = NULL
END

SELECT @Test1

这适当地返回一个真NULL值。现在让我们ISNULL放在外面：

DECLARE @Test2 varchar(16) = '    '

IF ISNULL(LTRIM(RTRIM(@Test2)),'') = ''
BEGIN
    SET @Test2 = NULL
END

SELECT @Test2

这也返回一个NULL值。两者都适用于预期用途，但我很好奇 SQL 查询优化器处理此问题的方式是否有任何不同？

我有一个较早执行缓慢的查询。后来我发现它没有并行运行，这使得查询执行速度变慢。

查询涉及一个 big view，然后使用大量temp tablesand查询视图sub query。

我UDF从视图中删除了一个并使用inline functions并使用了一个标量TVF，然后它开始在parallel execution.

这几天一切顺利，有一天我注意到查询运行缓慢。于是查了一下执行计划，发现查询是在串行模式下执行的。我检查了查询的计划缓存，我看到了很多涉及该视图的缓存计划。我删除了不并行的计划，然后查询运行得很快。

现在我每天早上都这样做以强制查询并行运行。

额外细节：

1. SQL Server 2016 标准版
2. 查询通过 LINQ-SQL 从 dot net 应用程序生成。所以临时查询。

如何强制查询永远并行运行？

我正在重新编写我们的维护计划，目前重点是备份。在准备此计划时，我想尝试确保程序到位，以确保备份性能最佳。我知道实施以下内容，但是我想了解如何在该范围之外进行改进。

当前考虑：

• 备份压缩
• 大型数据库的多个数据文件 - 可能超过 100GB？
• 将备份写入另一个 I/O 子系统
• 定义参数值，包括 BLOCKSIZE、MAXTRANSFERSIZE 和 BUFFERCOUNT
• 清除旧文件
• 删除备份历史

除了上述之外，还有什么是有利于实施的。另外，在设置 BLOCKSIZE、MAXTRANSFERSIZE 和 BUFFERCOUNT 的值时，我是否应该考虑/如何定义正确的值？我很欣赏测试过程中的一些反复试验，但了解最佳实践会很有用。

为了了解我的日常工作，我将运行每小时事务日志备份、每日差异和每周完整备份。

谢谢

我正在尝试为我的公司优化汇总代码，但遇到了一个非常奇怪的问题。我将许多标量函数转换为 TVF，它们似乎都比原始函数运行得更快，这很棒。但是，在调用它们的查询中，它们最终的运行速度明显慢于原始查询。这是我的更新的基本概述：

SELECT col1, ..., colx,
    (CASE WHEN x <= 0 OR y <= 0 OR z <= 0 OR z = x 
          THEN output
        WHEN valX <= 0 
          THEN output
        WHEN minimum.min < 1.0 THEN 1.0
        ELSE minimum.min
        END) AS Q,
FROM Tbl1...tblx (series of inner joins)
CROSS APPLY dbo.inlinemin(val1, val2) AS minimum

这是原文的基本轮廓：

SELECT col1, ..., colx,
    (CASE WHEN x <= 0 OR y <= 0 OR z <= 0 OR z = x 
          THEN output
        WHEN valX …