从补丁 198 开始，Amazon Redshift 将不再支持创建新的 Python UDF。现有的 Python UDF 将继续正常运行至 2026 年 6 月 30 日。有关更多信息，请参阅[博客文章](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/)。
# 教程：配置手动工作负载管理 (WLM) 队列
使用 Amazon Redshift，您可以配置手动工作负载管理（WLM）队列，为不同类型的查询和用户确定资源优先级并分配资源。手动 WLM 队列允许您控制特定队列的内存和并发设置，确保关键工作负载获得必要的资源，同时防止低优先级查询垄断系统。以下各节将指导您完成在 Amazon Redshift 中创建和配置手动 WLM 队列的过程，以满足您的工作负载管理要求。
## 概述
我们建议您在 Amazon Redshift 中配置自动工作负载管理 (WLM)。有关自动 WLM 的更多信息，请参阅[工作负载管理](cm-c-implementing-workload-management.md)。但是，如果您需要多个 WLM 队列，则本教程将逐步指导您完成在 Amazon Redshift 中配置手动工作负载管理 (WLM) 的过程。通过配置手动 WLM，您可以改进集群中的查询性能和资源分配。
Amazon Redshift 将用户查询路由至队列以进行处理。WLM 将定义这些查询路由至队列的方式。预设情况下，Amazon Redshift 具有两个可用于查询的队列：一个面向超级用户，一个面向用户。超级用户队列无法进行配置且一次只能处理一个查询。您应保留此队列以仅作故障排除之用。用户队列可一次处理多达 5 个查询，但您可以在需要时通过更改队列的并发级别来配置此能力。
若您有多个用户正在对数据库运行查询，您可能会发现另一种配置将更高效。例如，如果一些用户运行资源密集型操作（如 VACUUM），则这些操作可能会对资源不太密集型查询（如报告）产生负面影响。您可考虑添加其他队列并针对不同的工作负载配置它们。
**估计时间：**75 分钟
**估算费用：**50 美分
### 先决条件
您将需要一个 Amazon Redshift 集群、示例 TICKIT 数据库和 Amazon Redshift RSQL 客户端工具。如果您还没有设置上述这些项，请访问 [Amazon Redshift 入门指南](https://docs.aws.amazon.com/redshift/latest/gsg/new-user.html)和 [Amazon Redshift RSQL](https://docs.aws.amazon.com/redshift/latest/mgmt/rsql-query-tool.html)。
### 各个部分
+ [第 1 节：了解默认队列处理行为](#tutorial-wlm-understanding-default-processing)
+ [第 2 节：修改 WLM 查询队列配置](#tutorial-wlm-modifying-wlm-configuration)
+ [第 3 节：根据用户组和查询组将查询路由到队列](#tutorial-wlm-routing-queries-to-queues)
+ [第 4 节：使用 wlm\$1query\$1slot\$1count 临时覆盖队列中的并发级别](#tutorial-wlm-query-slot-count)
+ [第 5 节：清理资源](#tutorial-wlm-cleaning-up-resources)
## 第 1 节：了解默认队列处理行为
在您开始配置手动 WLM 前，了解 Amazon Redshift 中队列处理的默认行为是很有用的。在此节中，您将创建两个从多个系统表中返回信息的数据库视图。然后，您将运行一些测试查询以了解预设情况下路由查询的方式。有关系统表的更多信息，请参阅[系统表和视图参考](cm_chap_system-tables.md)。
### 步骤 1：创建 WLM\$1QUEUE\$1STATE\$1VW 视图
在此步骤中，您将创建一个名为 WLM\$1QUEUE\$1STATE\$1VW 的视图。此视图返回以下系统表中的信息。
+ [STV\$1WLM\$1CLASSIFICATION\$1CONFIG](r_STV_WLM_CLASSIFICATION_CONFIG.md)
+ [STV\$1WLM\$1SERVICE\$1CLASS\$1CONFIG](r_STV_WLM_SERVICE_CLASS_CONFIG.md)
+ [STV\$1WLM\$1SERVICE\$1CLASS\$1STATE](r_STV_WLM_SERVICE_CLASS_STATE.md)
您将在整个教程中使用此视图来监控在更改 WLM 配置后队列将发生的情况。下表描述了 WLM\$1QUEUE\$1STATE\$1VW 视图返回的数据。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/tutorial-configuring-workload-management.html)
#### 创建 WLM\$1QUEUE\$1STATE\$1VW 视图
1. 打开 [Amazon Redshift RSQL](https://docs.aws.amazon.com/redshift/latest/mgmt/rsql-query-tool.html) 并连接到您的 TICKIT 示例数据库。如果您没有此数据库，请参阅[先决条件](#tutorial-wlm-prereq)。
1. 运行以下查询以创建 WLM\$1QUEUE\$1STATE\$1VW 视图。
```
create view WLM_QUEUE_STATE_VW as
select (config.service_class-5) as queue
, trim (class.condition) as description
, config.num_query_tasks as slots
, config.query_working_mem as mem
, config.max_execution_time as max_time
, config.user_group_wild_card as "user_*"
, config.query_group_wild_card as "query_*"
, state.num_queued_queries queued
, state.num_executing_queries executing
, state.num_executed_queries executed
from
STV_WLM_CLASSIFICATION_CONFIG class,
STV_WLM_SERVICE_CLASS_CONFIG config,
STV_WLM_SERVICE_CLASS_STATE state
where
class.action_service_class = config.service_class
and class.action_service_class = state.service_class
and config.service_class > 4
order by config.service_class;
```
1. 运行以下查询以查看该视图包含的信息。
```
select * from wlm_queue_state_vw;
```
下面是示例结果。
```
query | description | slots | mem | max_time | user_* | query_* | queued | executing | executed
------+-------------------------------------------+-------+-----+----------+--------+---------+--------+-----------+----------
0 | (super user) and (query group: superuser) | 1 | 357 | 0 | false | false | 0 | 0 | 0
1 | (querytype:any) | 5 | 836 | 0 | false | false | 0 | 1 | 160
```
### 步骤 2：创建 WLM\$1QUERY\$1STATE\$1VW 视图
在此步骤中，您将创建一个名为 WLM\$1QUERY\$1STATE\$1VW 的视图。此视图返回 [STV\$1WLM\$1QUERY\$1STATE](r_STV_WLM_QUERY_STATE.md) 系统表中的信息。
您将在整个教程中使用此视图来监控正在运行的查询。下表描述了 WLM\$1QUERY\$1STATE\$1VW 视图返回的数据。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/tutorial-configuring-workload-management.html)
#### 创建 WLM\$1QUERY\$1STATE\$1VW 视图
1. 在 RSQL 中，运行以下查询以创建 WLM\$1QUERY\$1STATE\$1VW 视图。
```
create view WLM_QUERY_STATE_VW as
select query, (service_class-5) as queue, slot_count, trim(wlm_start_time) as start_time, trim(state) as state, trim(queue_time) as queue_time, trim(exec_time) as exec_time
from stv_wlm_query_state;
```
1. 运行以下查询以查看该视图包含的信息。
```
select * from wlm_query_state_vw;
```
下面是示例结果。
```
query | queue | slot_count | start_time | state | queue_time | exec_time
------+-------+------------+---------------------+-----------+------------+-----------
1249 | 1 | 1 | 2014-09-24 22:19:16 | Executing | 0 | 516
```
### 步骤 3：运行测试查询
在此步骤中，您将在 RSQL 中通过多个连接运行查询，并查看系统表以确定路由查询以进行处理的方式。
在此步骤中，您将需要打开两个 RSQL 窗口：
+ 在 RSQL 窗口 1 中，您将运行用于监控队列状态的查询和使用已在本教程中创建的视图的查询。
+ 在 RSQL 窗口 2 中，您将运行长时间运行的查询以更改在 RSQL 窗口 1 中找到的结果。
#### 运行测试查询
1. 打开两个 RSQL 窗口。如果您已打开一个窗口，则只需打开另一个窗口。您可针对这两个连接使用同一用户账户。
1. 在 RSQL 窗口 1 中，运行以下查询。
```
select * from wlm_query_state_vw;
```
下面是示例结果。
```
query | queue | slot_count | start_time | state | queue_time | exec_time
------+-------+------------+---------------------+-----------+------------+-----------
1258 | 1 | 1 | 2014-09-24 22:21:03 | Executing | 0 | 549
```
此查询返回一个自引用结果。当前正在运行的查询是来自此视图的 SELECT 语句。对此视图的查询将始终至少返回一个结果。将此结果与在下一步中启动长时间运行的查询后产生的结果进行比较。
1. 在 RSQL 窗口 2 中，从 TICKIT 示例数据库运行以下查询。此查询应会运行约一分钟时间，因此您有时间来探究之前创建的 WLM\$1QUEUE\$1STATE\$1VW 视图和 WLM\$1QUERY\$1STATE\$1VW 视图的结果。在某些情况下，您可能会发现查询运行的时长不足以查询这两个视图。在这些情况下，您可以增加 `l.listid ` 上的筛选条件值使其运行时间更长。
**注意**
为了缩短查询执行时间并改进系统性能，Amazon Redshift 在领导节点的内存中缓存特定查询类型的结果。当启用结果缓存时，后续查询的运行速度会快得多。要阻止查询快速运行，请对当前会话禁用结果缓存。
要为当前会话禁用结果缓存，请将 [enable\$1result\$1cache\$1for\$1session](r_enable_result_cache_for_session.md) 参数设置为 `off`，如下所示。
```
set enable_result_cache_for_session to off;
```
在 RSQL 窗口 2 中，运行以下查询。
```
select avg(l.priceperticket*s.qtysold) from listing l, sales s where l.listid < 100000;
```
1. 在 RSQL 窗口 1 中，查询 WLM\$1QUEUE\$1STATE\$1VW 和 WLM\$1QUERY\$1STATE\$1VW 并将结果与之前的结果进行比较。
```
select * from wlm_queue_state_vw;
select * from wlm_query_state_vw;
```
以下是示例结果。
```
query | description | slots | mem | max_time | user_* | query_* | queued | executing | executed
------+-------------------------------------------+-------+-----+----------+--------+---------+--------+-----------+----------
0 | (super user) and (query group: superuser) | 1 | 357 | 0 | false | false | 0 | 0 | 0
1 | (querytype:any) | 5 | 836 | 0 | false | false | 0 | 2 | 163
query | queue | slot_count | start_time | state | queue_time | exec_time
------+-------+------------+---------------------+-----------+------------+-----------
1267 | 1 | 1 | 2014-09-24 22:22:30 | Executing | 0 | 684
1265 | 1 | 1 | 2014-09-24 22:22:36 | Executing | 0 | 4080859
```
请注意，之前的查询结果与本步骤中的结果之间存在以下区别：
+ WLM\$1QUERY\$1STATE\$1VW 中现在有两行。一个结果是用于对此视图运行 SELECT 操作的自引用查询。第二个结果是上一步中的长时间运行的查询。
+ WLM\$1QUEUE\$1STATE\$1VW 中的 executing 列已从 1 增加到 2。此列条目表示队列中有两个正在运行的查询。
+ executed 列在您每次在队列中运行一个查询时将会递增。
WLM\$1QUEUE\$1STATE\$1VW 视图可用于全面了解队列以及每个队列中正在处理的查询的数量。WLM\$1QUERY\$1STATE\$1VW 视图可用于更详细地了解当前正在运行的单个查询。
## 第 2 节：修改 WLM 查询队列配置
现在您了解了队列的默认工作方式，您将了解如何使用手动 WLM 配置查询队列。在此节中，您将为集群创建并配置新的参数组。您将创建另外两个用户查询并配置它们以基于查询的用户组或查询组标签接受查询。未路由至这两个队列之一的任何查询在运行时将会路由至默认队列。
**要在参数组中创建手动 WLM 配置**
1. 登录到 AWS 管理控制台并打开 Amazon Redshift 控制台，网址：[https://console.aws.amazon.com/redshiftv2/](https://console.aws.amazon.com/redshiftv2/)。
1. 在导航菜单上，选择 **Configurations（配置）**，然后选择 **Workload management（工作负载管理）**，以显示 **Workload management（工作负载管理）**页面。
1. 选择 **Create (创建)** 显示 **Create parameter group (创建参数组)** 窗口。
1. 为**参数组名称**和**描述**输入 **WLMTutorial**，然后选择**创建**以创建参数组。
**注意**
**参数组名称**会在创建时转换为全部小写格式。
1. 在 **Workload management**（工作负载管理）页面上，选择参数组 **wlmtutorial** 以显示详细信息页面，其中包含 **Parameters**（参数）和 **Workload management**（工作负载管理）选项卡。
1. 确认您正在 **Workload management**（工作负载管理）选项卡，然后选择 **Switch WLM mode**（切换 WLM 模式）以显示 **Concurrency settings**（并发设置）窗口。
1. 选择 **Manual WLM**（手动 WLM），然后选择 **Save**（保存）以切换到手动 WLM。
1. 选择 **Edit workload queues**（编辑工作负载队列）。
1. 选择 **Add queue**（添加队列）两次以添加两个队列。现在有三个队列：**队列 1**、**队列 2** 和**默认队列**。
1. 按如下方式输入每个队列的信息：
+ 对于**队列 1**，为**内存 (%)** 输入 **30**，为**主集群上的并发**输入 **2**，并为**查询组**输入 **test**。将其他设置保留为默认值。
+ 对于**队列 2**，为**内存 (%)** 输入 **40**，为**主集群上的并发**输入 **3**，并为**用户组**输入 **admin**。将其他设置保留为默认值。
+ 将默认队列的**主要并发**值设置为大于或等于 1 的值。不要对**默认队列**做出任何其它更改。WLM 将未分配的内存分配给默认队列。
1. 选择 **Save (保存)** 以保存您的设置。
接下来，将具有手动 WLM 配置的参数组与集群相关联。
**要将具有手动 WLM 配置的参数组与集群关联**
1. 登录到 AWS 管理控制台并打开 Amazon Redshift 控制台，网址：[https://console.aws.amazon.com/redshiftv2/](https://console.aws.amazon.com/redshiftv2/)。
1. 在导航菜单上，选择 **Clusters（集群）**，然后选择 **Clusters（集群）**以显示集群的列表。
1. 选择您的集群，例如 `examplecluster`，以显示集群详细信息。然后选择 **Properties**（属性）选项卡，以显示该集群的属性。
1. 在 **Database configurations**（数据库配置）部分中，选择 **Edit**（编辑）、**Edit parameter group**（编辑参数组）以显示参数组窗口。
1. 对于**参数组**，选择您之前创建的 **wlmtutorial** 参数组。
1. 选择 **Save changes**（保存更改）以关联参数组。
使用更改的参数组修改集群。但是，您需要重启集群才能将更改应用于数据库。
1. 选择您的集群，然后为 **Actions**（操作）选择 **Reboot**（重启）。
在重启集群后，状态将返回为 **Available**（可用）。
## 第 3 节：根据用户组和查询组将查询路由到队列
现在，您的集群已与一个新的参数组相关联，并且您已配置 WLM。接下来，运行一些查询，以了解 Amazon Redshift 如何将查询路由到队列进行处理。
### 步骤 1：在数据库中查看查询队列配置
首先，验证数据库具有您希望的 WLM 配置。
#### 查看查询队列配置
1. 打开 RSQL 并运行以下查询。此查询使用您在[步骤 1：创建 WLM\$1QUEUE\$1STATE\$1VW 视图](#tutorial-wlm-create-queue-state-view)中创建的 WLM\$1QUEUE\$1STATE\$1VW 视图。如果您在集群重启之前已将会话连接到数据库，则将需要进行重新连接。
```
select * from wlm_queue_state_vw;
```
下面是示例结果。
```
query | description | slots | mem | max_time | user_* | query_* | queued | executing | executed
------+-------------------------------------------+-------+-----+----------+--------+---------+--------+-----------+----------
0 | (super user) and (query group: superuser) | 1 | 357 | 0 | false | false | 0 | 0 | 0
1 | (query group: test) | 2 | 627 | 0 | false | false | 0 | 0 | 0
2 | (suser group: admin) | 3 | 557 | 0 | false | false | 0 | 0 | 0
3 | (querytype:any) | 5 | 250 | 0 | false | false | 0 | 1 | 0
```
将这些结果您与[步骤 1：创建 WLM\$1QUEUE\$1STATE\$1VW 视图](#tutorial-wlm-create-queue-state-view)中获得的结果进行比较。请注意，现在有另外两个队列。队列 1 现在是面向 test 查询组的队列，而队列 2 则是面向 admin 用户组的队列。
队列 3 现在是默认队列。列表中的最后一个队列始终是默认队列。这是在查询中未指定任何用户组或查询组的情况下默认将查询路由至的队列。
1. 运行以下查询以确认您的查询现在在队列 3 中运行。
```
select * from wlm_query_state_vw;
```
下面是示例结果。
```
query | queue | slot_count | start_time | state | queue_time | exec_time
------+-------+------------+---------------------+-----------+------------+-----------
2144 | 3 | 1 | 2014-09-24 23:49:59 | Executing | 0 | 550430
```
### 步骤 2：使用查询组队列运行查询
#### 使用查询组队列运行查询
1. 运行以下查询以将其路由至 `test` 查询组。
```
set query_group to test;
select avg(l.priceperticket*s.qtysold) from listing l, sales s where l.listid <40000;
```
1. 在另一个 RSQL 窗口中，运行以下查询。
```
select * from wlm_query_state_vw;
```
下面是示例结果。
```
query | queue | slot_count | start_time | state | queue_time | exec_time
------+-------+------------+---------------------+-----------+------------+-----------
2168 | 1 | 1 | 2014-09-24 23:54:18 | Executing | 0 | 6343309
2170 | 3 | 1 | 2014-09-24 23:54:24 | Executing | 0 | 847
```
查询已路由至 test 查询组，现在是队列 1。
1. 从队列状态视图中选择全部。
```
select * from wlm_queue_state_vw;
```
您将看到类似以下内容的结果。
```
query | description | slots | mem | max_time | user_* | query_* | queued | executing | executed
------+-------------------------------------------+-------+-----+----------+--------+---------+--------+-----------+----------
0 | (super user) and (query group: superuser) | 1 | 357 | 0 | false | false | 0 | 0 | 0
1 | (query group: test) | 2 | 627 | 0 | false | false | 0 | 1 | 0
2 | (suser group: admin) | 3 | 557 | 0 | false | false | 0 | 0 | 0
3 | (querytype:any) | 5 | 250 | 0 | false | false | 0 | 1 | 0
```
1. 现有，重置查询组并再次运行长时间运行的查询：
```
reset query_group;
select avg(l.priceperticket*s.qtysold) from listing l, sales s where l.listid <40000;
```
1. 针对视图运行查询以查看结果。
```
select * from wlm_queue_state_vw;
select * from wlm_query_state_vw;
```
以下是示例结果。
```
query | description | slots | mem | max_time | user_* | query_* | queued | executing | executed
------+-------------------------------------------+-------+-----+----------+--------+---------+--------+-----------+----------
0 | (super user) and (query group: superuser) | 1 | 357 | 0 | false | false | 0 | 0 | 0
1 | (query group: test) | 2 | 627 | 0 | false | false | 0 | 0 | 1
2 | (suser group: admin) | 3 | 557 | 0 | false | false | 0 | 0 | 0
3 | (querytype:any) | 5 | 250 | 0 | false | false | 0 | 2 | 5
query | queue | slot_count | start_time | state | queue_time | exec_time
------+-------+------------+---------------------+-----------+------------+-----------
2186 | 3 | 1 | 2014-09-24 23:57:52 | Executing | 0 | 649
2184 | 3 | 1 | 2014-09-24 23:57:48 | Executing | 0 | 4137349
```
结果应是查询现在正在队列 3 中再次运行。
### 步骤 3：创建数据库用户和组
在您可以在此队列中运行任何查询之前，需要在数据库中创建用户组并向该组添加用户。然后，您将使用新用户的凭证通过 RSQL 进行登录，然后运行查询。您需要作为超级用户（如管理员用户）运行查询来创建数据库用户。
#### 创建新的数据库用户和用户组
1. 在数据库中，通过在 RSQL 窗口中运行以下命令来创建名为 `adminwlm` 的新数据库用户。
```
create user adminwlm createuser password '123Admin';
```
1. 然后，运行以下命令来创建新用户组并将您的新 `adminwlm` 用户添加到该组。
```
create group admin;
alter group admin add user adminwlm;
```
### 步骤 4：使用用户组队列运行查询
接下来，您将运行一个查询并将该查询路由至用户组队列。当您想要将查询路由至配置为处理您要运行的查询类型的队列时，可执行此操作。
#### 使用用户组队列运行查询
1. 在 RSQL 窗口 2 中，运行以下查询以切换至 `adminwlm` 账户并以该用户的身份运行查询。
```
set session authorization 'adminwlm';
select avg(l.priceperticket*s.qtysold) from listing l, sales s where l.listid <40000;
```
1. 在 RSQL 窗口 1 中，运行以下查询以查看查询路由至的查询队列。
```
select * from wlm_query_state_vw;
select * from wlm_queue_state_vw;
```
以下是示例结果。
```
query | description | slots | mem | max_time | user_* | query_* | queued | executing | executed
------+-------------------------------------------+-------+-----+----------+--------+---------+--------+-----------+----------
0 | (super user) and (query group: superuser) | 1 | 357 | 0 | false | false | 0 | 0 | 0
1 | (query group: test) | 2 | 627 | 0 | false | false | 0 | 0 | 1
2 | (suser group: admin) | 3 | 557 | 0 | false | false | 0 | 1 | 0
3 | (querytype:any) | 5 | 250 | 0 | false | false | 0 | 1 | 8
query | queue | slot_count | start_time | state | queue_time | exec_time
------+-------+------------+---------------------+-----------+------------+-----------
2202 | 2 | 1 | 2014-09-25 00:01:38 | Executing | 0 | 4885796
2204 | 3 | 1 | 2014-09-25 00:01:43 | Executing | 0 | 650
```
此查询是在队列 2（`admin` 用户队列）中运行的。无论何时您以此用户的身份登录来运行查询，这些查询均将在队列 2 中运行，除非您指定要使用另一个查询组。所选队列取决于队列分配规则。有关更多信息，请参阅 [WLM 队列分配规则](cm-c-wlm-queue-assignment-rules.md)。
1. 现在，从 RSQL 窗口 2 中运行以下查询。
```
set query_group to test;
select avg(l.priceperticket*s.qtysold) from listing l, sales s where l.listid <40000;
```
1. 在 RSQL 窗口 1 中，运行以下查询以查看查询路由至的查询队列。
```
select * from wlm_queue_state_vw;
select * from wlm_query_state_vw;
```
以下是示例结果。
```
query | description | slots | mem | max_time | user_* | query_* | queued | executing | executed
------+-------------------------------------------+-------+-----+----------+--------+---------+--------+-----------+----------
0 | (super user) and (query group: superuser) | 1 | 357 | 0 | false | false | 0 | 0 | 0
1 | (query group: test) | 2 | 627 | 0 | false | false | 0 | 1 | 1
2 | (suser group: admin) | 3 | 557 | 0 | false | false | 0 | 0 | 1
3 | (querytype:any) | 5 | 250 | 0 | false | false | 0 | 1 | 10
query | queue | slot_count | start_time | state | queue_time | exec_time
------+-------+------------+---------------------+-----------+------------+-----------
2218 | 1 | 1 | 2014-09-25 00:04:30 | Executing | 0 | 4819666
2220 | 3 | 1 | 2014-09-25 00:04:35 | Executing | 0 | 685
```
1. 当您完成后，请重置查询组。
```
reset query_group;
```
## 第 4 节：使用 wlm\$1query\$1slot\$1count 临时覆盖队列中的并发级别
有时，用户可能会为某个特定查询临时需要更多资源。如果是这样的话，他们可以使用 wlm\$1query\$1slot\$1count 配置设置来临时覆盖查询队列中分配槽位的方式。*槽位* 是用于处理查询的内存和 CPU 的单位。您可在偶尔使用消耗集群中大量资源的查询时（例如，在数据库中执行 VACUUM 操作时）覆盖槽位计数。
您可能会发现用户经常需要针对特定类型的查询设置 wlm\$1query\$1slot\$1count。如果是，请考虑调整 WLM 配置并为用户提供更适合其查询需求的队列。有关通过使用槽位计数临时覆盖并发级别的更多信息，请参阅[wlm\$1query\$1slot\$1count](r_wlm_query_slot_count.md)。
### 步骤 1：使用 wlm\$1query\$1slot\$1count 覆盖并发级别
在本教程中，我们将运行同一个长时间运行的 SELECT 查询。我们将以 `adminwlm` 用户的身份运行查询，并使用 wlm\$1query\$1slot\$1count 增加查询的可用槽位数。
#### 使用 wlm\$1query\$1slot\$1count 覆盖并发级别
1. 提高对查询的限制以确保您有足够的时间来查询 WLM\$1QUERY\$1STATE\$1VW 视图并查看结果。
```
set wlm_query_slot_count to 3;
select avg(l.priceperticket*s.qtysold) from listing l, sales s where l.listid <40000;
```
1. 现在，可使用管理员用户查询 WLM\$1QUERY\$1STATE\$1VW，以查看查询的运行情况。
```
select * from wlm_query_state_vw;
```
下面是示例结果。
```
query | queue | slot_count | start_time | state | queue_time | exec_time
------+-------+------------+---------------------+-----------+------------+-----------
2240 | 2 | 1 | 2014-09-25 00:08:45 | Executing | 0 | 3731414
2242 | 3 | 1 | 2014-09-25 00:08:49 | Executing | 0 | 596
```
请注意，查询的槽位计数是 3。此计数表示查询正在使用所有三个槽位来处理查询，并将队列中的所有资源分配给查询。
1. 现在，运行以下查询。
```
select * from WLM_QUEUE_STATE_VW;
```
下面是示例结果。
```
query | description | slots | mem | max_time | user_* | query_* | queued | executing | executed
------+-------------------------------------------+-------+-----+----------+--------+---------+--------+-----------+----------
0 | (super user) and (query group: superuser) | 1 | 357 | 0 | false | false | 0 | 0 | 0
1 | (query group: test) | 2 | 627 | 0 | false | false | 0 | 0 | 4
2 | (suser group: admin) | 3 | 557 | 0 | false | false | 0 | 1 | 3
3 | (querytype:any) | 5 | 250 | 0 | false | false | 0 | 1 | 25
```
wlm\$1query\$1slot\$1count 配置设置仅对当前会话有效。如果会话过期或者另一用户运行查询，则使用 WLM 配置。
1. 重置槽位计数并重新运行测试。
```
reset wlm_query_slot_count;
select avg(l.priceperticket*s.qtysold) from listing l, sales s where l.listid <40000;
```
以下是示例结果。
```
query | description | slots | mem | max_time | user_* | query_* | queued | executing | executed
------+-------------------------------------------+-------+-----+----------+--------+---------+--------+-----------+----------
0 | (super user) and (query group: superuser) | 1 | 357 | 0 | false | false | 0 | 0 | 0
1 | (query group: test) | 2 | 627 | 0 | false | false | 0 | 0 | 2
2 | (suser group: admin) | 3 | 557 | 0 | false | false | 0 | 1 | 2
3 | (querytype:any) | 5 | 250 | 0 | false | false | 0 | 1 | 14
query | queue | slot_count | start_time | state | queue_time | exec_time
------+-------+------------+---------------------+-----------+------------+-----------
2260 | 2 | 1 | 2014-09-25 00:12:11 | Executing | 0 | 4042618
2262 | 3 | 1 | 2014-09-25 00:12:15 | Executing | 0 | 680
```
### 步骤 2：从不同的会话中运行查询
接下来，从不同会话中运行查询。
#### 从不同的会话中运行查询
1. 在 RSQL 窗口 1 和 2 中，运行以下查询以使用测试查询组。
```
set query_group to test;
```
1. 在 RSQL 窗口 1 中，运行以下长时间运行的查询。
```
select avg(l.priceperticket*s.qtysold) from listing l, sales s where l.listid <40000;
```
1. 由于长时间运行的查询仍在 RSQL 窗口 1 中运行，请运行以下查询。这些命令将增加槽位计数，以使用队列的所有槽位，然后开始运行长时间运行的查询。
```
set wlm_query_slot_count to 2;
select avg(l.priceperticket*s.qtysold) from listing l, sales s where l.listid <40000;
```
1. 打开第三个 RSQL 窗口并查询视图以查看结果。
```
select * from wlm_queue_state_vw;
select * from wlm_query_state_vw;
```
以下是示例结果。
```
query | description | slots | mem | max_time | user_* | query_* | queued | executing | executed
------+-------------------------------------------+-------+-----+----------+--------+---------+--------+-----------+----------
0 | (super user) and (query group: superuser) | 1 | 357 | 0 | false | false | 0 | 0 | 0
1 | (query group: test) | 2 | 627 | 0 | false | false | 1 | 1 | 2
2 | (suser group: admin) | 3 | 557 | 0 | false | false | 0 | 0 | 3
3 | (querytype:any) | 5 | 250 | 0 | false | false | 0 | 1 | 18
query | queue | slot_count | start_time | state | queue_time | exec_time
------+-------+------------+---------------------+---------------+------------+-----------
2286 | 1 | 2 | 2014-09-25 00:16:48 | QueuedWaiting | 3758950 | 0
2282 | 1 | 1 | 2014-09-25 00:16:33 | Executing | 0 | 19335850
2288 | 3 | 1 | 2014-09-25 00:16:52 | Executing | 0 | 666
```
请注意，第一个查询正在使用分配给队列 1 的槽位之一来运行查询。此外，请注意，队列中有一个查询正在等待（其中 `queued` 为 `1`，`state` 为 `QueuedWaiting`）。在第一个查询完成之后，第二个查询即会开始运行。此执行发生的原因在于：两个查询均已路由至 `test` 查询组，而且第二个查询必须等待有足够多的槽位才能开始进行处理。
## 第 5 节：清理资源
只要您的集群正在运行，就将继续产生费用。完成本教程后，请按照《Amazon Redshift 入门指南》**中的[查找其它资源并重置环境](https://docs.aws.amazon.com/redshift/latest/gsg/rs-gsg-clean-up-tasks.html)中的步骤操作，使您的环境返回上一个状态。
有关 WLM 的更多信息，请参阅 [工作负载管理](cm-c-implementing-workload-management.md)。