从补丁 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
<a name="cm-c-defining-query-queues"></a>

通过手动 WLM，您可以通过修改 WLM 配置，为耗时查询和短时查询分别创建队列，来管理系统性能和用户体验。

当用户在 Amazon Redshift 中运行查询时，查询会路由到查询队列。每个查询队列都包含很多查询槽。每个队列都分配有一部分集群可用内存。队列的内存在队列的查询槽间分配。您可以允许 Amazon Redshift 通过自动 WLM 管理查询并发性。有关更多信息，请参阅 [实施自动 WLM](automatic-wlm.md)。

或者，您可以为每个查询队列配置 WLM 属性。这样可以指定如何在槽间分配内存，以及如何在运行时将查询路由到特定的队列。您还可以配置 WLM 属性以取消长时间运行的查询。

预设情况下，Amazon Redshift 配置以下查询队列：
+  **一个超级用户队列** 

  超级用户队列是专为超级用户预留的队列，无法进行配置。仅在需要运行影响系统的查询或用于故障排除目的时，才应使用该队列。例如，如果需要取消用户的耗时查询或向数据库添加用户，则可使用该队列。请不要使用它来执行常规查询。该队列不显示在控制台中，但在数据库的系统表中显示为第五队列。要在超级用户队列中运行查询，用户必须以超级用户身份登录并使用预定义的 `superuser` 查询组运行查询。
+  **一个默认用户队列** 

  默认队列初始配置为并发运行五个查询。在使用手动 WLM 时，您可以更改默认队列的并发、超时和内存分配属性，但不能指定用户组或查询组。默认队列必须是 WLM 配置中最后一个队列。未路由到其他队列的查询在默认队列中运行。

查询队列在 WLM 配置中定义。WLM 配置是参数组中的可编辑参数 (`wlm_json_configuration`)，可与一个或多个集群关联。有关更多信息，请参阅《Amazon Redshift 管理指南》**中的[配置工作负载管理](https://docs.aws.amazon.com/redshift/latest/mgmt/workload-mgmt-config.html)。

您可以向默认 WLM 配置添加其他查询队列，最多可添加八个用户队列。您可以为每个查询队列配置以下内容：
+ 并发扩展模式 
+ 并发级别 
+ 用户组 
+ 查询组 
+ 要使用的 WLM 内存百分比
+ WLM 超时
+ WLM 查询队列跳过
+ 查询监控规则

## 并发扩展模式
<a name="concurrency-scaling-mode"></a>

启用并发扩展后，Amazon Redshift 会在需要时自动增加额外的集群容量来处理增多的并发读取查询。不管查询在主集群上运行还是在并发扩展集群上运行，用户都将看到最新的数据。

您可以通过配置 WLM 队列来管理将哪些查询发送到并发扩展集群。为队列启用并发扩展后，符合条件的查询将发送到并发扩展集群，而不是排队等待。有关更多信息，请参阅 [并发扩展](concurrency-scaling.md)。

## 并发级别
<a name="cm-c-defining-query-queues-concurrency-level"></a>

队列中的查询以并发方式运行，直到它们达到为该队列定义的 WLM 队列插槽计数或*并发* 级别。达到并发级别后，后续查询将在队列中等待。

**注意**  
WLM 并发级别不同于一个集群可以拥有的并行用户连接数。有关更多信息，请参阅《Amazon Redshift 管理指南》**中的[连接到集群](https://docs.aws.amazon.com/redshift/latest/mgmt/connecting-to-cluster.html)。

在自动 WLM 配置（推荐）中，并发级别设置为**自动**。Amazon Redshift 为查询动态分配内存，这会随之确定同时运行多少个查询。此数量基于运行查询和排队查询所需的资源。自动 WLM 不可配置。有关更多信息，请参阅 [实施自动 WLM](automatic-wlm.md)。

在手动 WLM 配置中，Amazon Redshift 向每个队列静态分配固定数量的内存。队列的内存在查询槽之间均匀分配。举例来说，如果向队列分配了 20% 的集群内存并且有 10 个插槽，则每个查询将分配 2% 的集群内存。内存分配保持固定，不论并行运行的查询数量是多少。由于此固定内存分配，对于插槽计数为 5 时可完全在内存中运行的查询，如果将其插槽计数提高到 20，则可能需要将中间结果写入磁盘。在这个例子中，每个查询的队列内存份额从 1/5 减少到 1/20。额外的磁盘 I/O 会降低性能。

所有用户定义的队列的最大插槽计数为 50。这限制了所有队列的总插槽数，包括默认队列。唯一不受此限制的队列是预留的超级用户队列。

默认情况下，手动 WLM 队列的并发级别为 5。在某些情况下，更高的并发级别可能对您的工作负载有用，如下所示：
+ 如果有许多小型查询被迫等待耗时的查询，则可创建一个具有更高插槽计数的独立队列，并将小型查询分配给该队列。并发级别较高的队列，分配给每个查询槽的内存较少，不过较小的查询需要的内存较少。
**注意**  
如果您启用短查询加速 (SQA)，WLM 会自动让短时查询优先于长时查询，因此对于大多数工作流程，不需要单独的队列来进行短查询。有关更多信息，请参阅 [短查询加速](wlm-short-query-acceleration.md)。
+ 如果您有多个查询，每个查询访问单个切片上的数据，则可设置独立的 WLM 队列，以并发执行这些查询。Amazon Redshift 将并发查询分配给多个独立的切片，使多个查询能够在多个切片上并行执行。例如，如果某个查询是简单的聚合操作，且使用基于分配键的谓词，则该查询的数据将位于单个切片上。

### 手动 WLM 示例
<a name="cm-c-defining-query-queues-concurrency-level-example"></a>

 此示例是一个简单的手动 WLM 场景，显示了如何分配插槽和内存。您对以下三个队列实施手动 WLM：
+ *data-ingestion 队列* – 此队列设置用于提取数据。为该队列分配了 20% 的集群内存，并且该队列有 5 个插槽。因此，队列中可以同时运行 5 个查询，每个查询分配了 4% 的集群内存。
+ *data-scientist 队列* – 专为内存密集型查询设计。为该队列分配了 40% 的集群内存，并且该队列有 5 个插槽。因此可以同时运行 5 个查询，每个查询分配了 8% 的集群内存。
+ *default 队列* – 这是为组织中大多数用户设计的队列。包括销售和会计团队，他们会运行短时间或中等时间长度且并不复杂的查询。为该队列分配了 40% 的集群内存，并且该队列有 40 个插槽。此队列中可以同时运行 40 个查询，每个查询分配了 1% 的集群内存。这是可以为此队列分配的最大插槽数，因为所有队列的总数限制为 50。

如果您正在运行 WLM，并且工作负载需要并行运行 15 个以上的查询，我们建议您启用并发扩展。这是因为将查询槽数增加到 15 以上可能会导致系统资源争用，限制了单个集群的总吞吐量。利用并发扩展，您可以并行运行数百个查询，最多可达到配置的并发扩展集群数。并发扩展集群的数量由 [max\$1concurrency\$1scaling\$1clusters](r_max_concurrency_scaling_clusters.md) 控制。有关并发扩展的更多信息，请参阅[并发扩展](concurrency-scaling.md)。

有关更多信息，请参阅 [查询性能改进](query-performance-improvement-opportunities.md)。

## 用户组
<a name="cm-c-defining-query-queues-user-groups"></a>

您可以通过指定每个用户组的名称或使用通配符将一组用户组分配给某个队列。当所列用户组的成员运行某个查询时，该查询将在相应的队列中运行。您可以向队列分配任意数量的用户组。有关更多信息，请参阅 [根据用户组为队列分配查询](cm-c-executing-queries.md#cm-c-executing-queries-assigning-queries-to-queues-based-on-user-groups)。

## 用户角色
<a name="cm-c-defining-query-queues-user-roles"></a>

您可以通过指定每个用户角色的名称或使用通配符将一组用户角色分配给某个队列。当所列用户角色的成员运行某个查询时，该查询将在相应的队列中运行。您可以向队列分配任意数量的用户角色。有关更多信息，请参阅 [根据用户角色为队列分配查询](cm-c-executing-queries.md#cm-c-executing-queries-assigning-queries-to-queues-based-on-user-roles)。

## 查询组
<a name="cm-c-defining-query-queues-query-groups"></a>

您可以通过指定每个队列组的名称或使用通配符将一组查询组分配给某个队列。查询组只是一种标签。在运行时，您可以将查询组标签分配给一系列查询。分配给所列查询组的任意查询都将在相应的队列中运行。您可以向队列分配任意数量的查询组。有关更多信息，请参阅 [为查询组分配查询](cm-c-executing-queries.md#cm-c-executing-queries-assigning-a-query-to-a-query-group)。

## 通配符
<a name="wlm-wildcards"></a>

如果在 WLM 队列配置中启用了通配符，则可以单独地或使用 Unix shell 样式的通配符向队列分配用户组和查询组。模式匹配不区分大小写。

例如，“\$1”通配符字符匹配任意数量的字符。因此，如果您将 `dba_*` 添加到某个队列的用户组列表中，则属于名称以开头的 `dba_` 组的所有用户查询都将分配到该队列。示例包括 `dba_admin` 或 `DBA_primary`。“?”通配符匹配任意单个字符。因此，如果队列包括用户组 `dba?1`，则名为 `dba11` 和 `dba21` 的用户组匹配，但 `dba12` 不匹配。

默认情况下，通配符处于关闭状态。

## 要使用的 WLM 内存百分比
<a name="wlm-memory-percent"></a>

在自动 WLM 配置中，内存百分比设置为 **auto**。有关更多信息，请参阅 [实施自动 WLM](automatic-wlm.md)。

在手动 WLM 配置中，要指定分配给查询的可用内存量，您可以设置 `WLM Memory Percent to Use` 参数。默认情况下，会向每个用户定义队列分配相等的用户定义查询可用内存。例如，如果有四个用户定义队列，则会向每个队列分配 25% 的可用内存。超级用户队列有自己的分配内存，无法进行修改。要更改分配，您可以向每个队列分配整数比例的内存，总计最高为 100%。任意未分配的内存将由 Amazon Redshift 进行管理，如果有队列请求更多内存以进行处理，可以临时分配给该队列。

例如，如果配置了四个队列，则可以按以下方式分配内存：20%、30%、15%、15%。其余的 20% 未分配，由该服务管理。

## WLM 超时
<a name="wlm-timeout"></a>

WLM 超时 (`max_execution_time`) 已弃用。相反，使用 `query_execution_time` 创建查询监控规则 (QMR) 来限制经过的查询执行时间。有关更多信息，请参阅 [WLM 查询监控规则](cm-c-wlm-query-monitoring-rules.md)。

要限制允许查询在给定 WLM 队列中停留的时间，您可以为每个队列设置 WLM 超时。超时参数指定 Amazon Redshift 在取消或跳过查询前等待查询执行的时间量（单位为毫秒）。超时基于查询执行时间，不包括在队列中等待的时间。

WLM 尝试跳过 [CREATE TABLE AS](r_CREATE_TABLE_AS.md) (CTAS) 语句和只读查询，例如 SELECT 语句。无法跳过的查询将被取消。有关更多信息，请参阅 [WLM 查询队列跳过](wlm-queue-hopping.md)。

查询已进入“returning”状态时，WLM 超时不适用。要查看查询的状态，请参阅 [STV\$1WLM\$1QUERY\$1STATE](r_STV_WLM_QUERY_STATE.md) 系统表。COPY 语句和维护操作（例如 ALTER、ANALYZE 和 VACUUM）不受 WLM 超时约束。

WLM 超时功能类似于 [statement\$1timeout](r_statement_timeout.md) 配置参数。区别在于，`statement_timeout` 配置参数应用于整个集群，WLM 超时特定于 WLM 配置中的单个队列。

如果还指定了 [statement\$1timeout](r_statement_timeout.md)，则会使用 statement\$1timeout 和 WLM timeout (max\$1execution\$1time) 中的较小者。

## 查询监控规则
<a name="wlm-query-monitoring-rules"></a>

查询监控规则为 WLM 查询定义基于指标的性能界限，并指定在查询超出这些界限时需要采取的操作。例如，对于短时间运行查询专用的队列，您可创建取消运行超过 60 秒的查询的规则。要跟踪设计不佳的查询，您可创建记录包含嵌套循环的查询的其他规则。有关更多信息，请参阅 [WLM 查询监控规则](cm-c-wlm-query-monitoring-rules.md)。

# WLM 查询队列跳过
<a name="wlm-queue-hopping"></a>

使用 Amazon Redshift，您可以通过启用 WLM（工作负载管理）查询队列跳转来管理工作负载并发性和资源分配。该功能允许查询在资源可用时从指定队列临时“跳转”到更高优先级的队列，从而提高整体查询性能和系统利用率。以下各节将提供在 Amazon Redshift 中配置和使用 WLM 查询队列跳转的详细指导。

由于 [WLM 超时](cm-c-defining-query-queues.md#wlm-timeout)或[查询监控规则 (QMR) 跃点操作](cm-c-wlm-query-monitoring-rules.md#cm-c-wlm-defining-query-monitoring-rules)，可能会跳过查询。您只能在手动 WLM 配置中跳转查询。

当跳过查询时，WLM 会尝试根据 [WLM 队列分配规则](cm-c-wlm-queue-assignment-rules.md)将该查询路由到下一个匹配的队列。如果查询不与任何其他队列定义匹配，则查询会被取消。它不会分配给默认队列。

## WLM 超时操作
<a name="wlm-queue-hopping-summary"></a>

下表总结了具有 WLM 超时的不同类型查询的行为。

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/wlm-queue-hopping.html)

## WLM 超时队列跳过
<a name="wlm-timeout-queue-hopping"></a>

如果下列类型的查询超时，WLM 会跳过它们：
+ 只读查询，例如 WLM 状态为 `running` 的 SELECT 语句。要了解查询的 WLM 状态，请查看 [STV\$1WLM\$1QUERY\$1STATE](r_STV_WLM_QUERY_STATE.md) 系统表中的 STATE 列。
+ CREATE TABLE AS (CTAS) 语句。WLM 队列跳跃支持用户定义的和系统生成的 CTAS 语句。
+ SELECT INTO 语句。

不受 WLM 超时约束的查询将继续在原始队列中运行，直到完成为止。以下类型的查询不受 WLM 超时约束：
+ COPY 语句
+ 维护操作，例如 ALTER、ANALYZE 和 VACUUM
+ 只读查询，例如 WLM 状态达到 `returning` 的 SELECT 语句。要了解查询的 WLM 状态，请查看 [STV\$1WLM\$1QUERY\$1STATE](r_STV_WLM_QUERY_STATE.md) 系统表中的 STATE 列。

没有资格因 WLM 超时跳过的查询将在超时时被取消。下列类型的查询没有资格因 WLM 超时跳过：
+ INSERT、UPDATE 和 DELETE 语句
+ UNLOAD 语句
+ 用户定义的函数 (UDF)

## WLM 超时重新分配和重新启动的查询
<a name="wlm-timeout-reassigned-and-restarted-queries"></a>

当跳过查询并且找不到匹配的队列时，该查询将被取消。

当跳过查询并且找到匹配的队列时，WLM 会尝试将该查询重新分配给新队列。如果无法重新分配查询，则它会在新队列中重新启动，如下所述。

只有在满足以下所有条件时，才会重新分配查询：
+ 找到匹配的队列。
+ 新队列有足够多的空闲插槽来运行查询。如果 [wlm\$1query\$1slot\$1count](r_wlm_query_slot_count.md) 参数设置为大于 1 的值，则查询可能需要多个插槽。
+ 新队列具有至少与查询当前使用的一样多的可用内存。

如果重新分配查询，则查询将继续在新队列中执行。将会保留中间结果，这样对总体执行时间造成的影响可降至最低。

如果无法重新分配查询，则该查询会被取消并在新队列中重新启动。中间结果会被删除。查询会在队列中等待，然后在有足够多的插槽可用时开始运行。

## QMR 跳过操作
<a name="qmr-hop-action-queue-hopping"></a>

下表总结了具有 QMR 跃点操作的不同类型查询的行为。

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/wlm-queue-hopping.html)

要查明由 QMR 跳过的查询是否已重新分配、重新启动或取消，请查询 [STL\$1WLM\$1RULE\$1ACTION](r_STL_WLM_RULE_ACTION.md) 系统日志表。

## QMR 跳过操作重新分配和重新启动的查询
<a name="qmr-hop-action-reassigned-and-restarted-queries"></a>

当跳过查询并且找不到匹配的队列时，该查询将被取消。

当跳过查询并且找到匹配的队列时，WLM 会尝试将该查询重新分配给新队列。如果无法重新分配查询，则它会在新队列中重新启动或在原始队列中继续执行，如下所述。

只有在满足以下所有条件时，才会重新分配查询：
+ 找到匹配的队列。
+ 新队列有足够多的空闲插槽来运行查询。如果 [wlm\$1query\$1slot\$1count](r_wlm_query_slot_count.md) 参数设置为大于 1 的值，则查询可能需要多个插槽。
+ 新队列具有至少与查询当前使用的一样多的可用内存。

如果重新分配查询，则查询将继续在新队列中执行。将会保留中间结果，这样对总体执行时间造成的影响可降至最低。

如果无法重新分配查询，则该查询会重新启动或在原始队列中继续执行。如果无法重新启动查询，则该查询会被取消并在新队列中重新启动。中间结果会被删除。查询会在队列中等待，然后在有足够多的插槽可用时开始执行。

# 教程：配置手动工作负载管理 (WLM) 队列
<a name="tutorial-configuring-workload-management"></a>

使用 Amazon Redshift，您可以配置手动工作负载管理（WLM）队列，为不同类型的查询和用户确定资源优先级并分配资源。手动 WLM 队列允许您控制特定队列的内存和并发设置，确保关键工作负载获得必要的资源，同时防止低优先级查询垄断系统。以下各节将指导您完成在 Amazon Redshift 中创建和配置手动 WLM 队列的过程，以满足您的工作负载管理要求。

## 概述
<a name="tutorial-wlm-overview"></a>

我们建议您在 Amazon Redshift 中配置自动工作负载管理 (WLM)。有关自动 WLM 的更多信息，请参阅[工作负载管理](cm-c-implementing-workload-management.md)。但是，如果您需要多个 WLM 队列，则本教程将逐步指导您完成在 Amazon Redshift 中配置手动工作负载管理 (WLM) 的过程。通过配置手动 WLM，您可以改进集群中的查询性能和资源分配。

Amazon Redshift 将用户查询路由至队列以进行处理。WLM 将定义这些查询路由至队列的方式。预设情况下，Amazon Redshift 具有两个可用于查询的队列：一个面向超级用户，一个面向用户。超级用户队列无法进行配置且一次只能处理一个查询。您应保留此队列以仅作故障排除之用。用户队列可一次处理多达 5 个查询，但您可以在需要时通过更改队列的并发级别来配置此能力。

若您有多个用户正在对数据库运行查询，您可能会发现另一种配置将更高效。例如，如果一些用户运行资源密集型操作（如 VACUUM），则这些操作可能会对资源不太密集型查询（如报告）产生负面影响。您可考虑添加其他队列并针对不同的工作负载配置它们。

**估计时间：**75 分钟

**估算费用：**50 美分

### 先决条件
<a name="tutorial-wlm-prereq"></a>

您将需要一个 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)。

### 各个部分
<a name="tutorial-wlm-steps"></a>
+ [第 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 节：了解默认队列处理行为
<a name="tutorial-wlm-understanding-default-processing"></a>

在您开始配置手动 WLM 前，了解 Amazon Redshift 中队列处理的默认行为是很有用的。在此节中，您将创建两个从多个系统表中返回信息的数据库视图。然后，您将运行一些测试查询以了解预设情况下路由查询的方式。有关系统表的更多信息，请参阅[系统表和视图参考](cm_chap_system-tables.md)。

### 步骤 1：创建 WLM\$1QUEUE\$1STATE\$1VW 视图
<a name="tutorial-wlm-create-queue-state-view"></a>

在此步骤中，您将创建一个名为 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 视图
<a name="how-to-wlm-create-queue-state-view"></a>

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 视图
<a name="tutorial-wlm-create-query-state-view"></a>

在此步骤中，您将创建一个名为 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 视图
<a name="how-to-wlm-create-query-state-view"></a>

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：运行测试查询
<a name="tutorial-wlm-run-test-queries"></a>

在此步骤中，您将在 RSQL 中通过多个连接运行查询，并查看系统表以确定路由查询以进行处理的方式。

在此步骤中，您将需要打开两个 RSQL 窗口：
+ 在 RSQL 窗口 1 中，您将运行用于监控队列状态的查询和使用已在本教程中创建的视图的查询。
+ 在 RSQL 窗口 2 中，您将运行长时间运行的查询以更改在 RSQL 窗口 1 中找到的结果。

#### 运行测试查询
<a name="how-to-wlm-run-test-queries"></a>

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 查询队列配置
<a name="tutorial-wlm-modifying-wlm-configuration"></a>

现在您了解了队列的默认工作方式，您将了解如何使用手动 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 节：根据用户组和查询组将查询路由到队列
<a name="tutorial-wlm-routing-queries-to-queues"></a>

现在，您的集群已与一个新的参数组相关联，并且您已配置 WLM。接下来，运行一些查询，以了解 Amazon Redshift 如何将查询路由到队列进行处理。

### 步骤 1：在数据库中查看查询队列配置
<a name="tutorial-wlm-view-query-config"></a>

首先，验证数据库具有您希望的 WLM 配置。

#### 查看查询队列配置
<a name="how-to-wlm-view-query-config"></a>

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：使用查询组队列运行查询
<a name="tutorial-wlm-query-group"></a>

#### 使用查询组队列运行查询
<a name="how-to-wlm-query-group"></a>

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：创建数据库用户和组
<a name="tutorial-wlm-create-db-user-and-group"></a>

在您可以在此队列中运行任何查询之前，需要在数据库中创建用户组并向该组添加用户。然后，您将使用新用户的凭证通过 RSQL 进行登录，然后运行查询。您需要作为超级用户（如管理员用户）运行查询来创建数据库用户。

#### 创建新的数据库用户和用户组
<a name="how-to-wlm-create-db-user-and-group"></a>

1. 在数据库中，通过在 RSQL 窗口中运行以下命令来创建名为 `adminwlm` 的新数据库用户。

   ```
   create user adminwlm createuser password '123Admin';
   ```

1. 然后，运行以下命令来创建新用户组并将您的新 `adminwlm` 用户添加到该组。

   ```
   create group admin;
   alter group admin add user adminwlm;
   ```

### 步骤 4：使用用户组队列运行查询
<a name="tutorial-wlm-user-group-query"></a>

接下来，您将运行一个查询并将该查询路由至用户组队列。当您想要将查询路由至配置为处理您要运行的查询类型的队列时，可执行此操作。

#### 使用用户组队列运行查询
<a name="how-to-wlm-user-group-query"></a>

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 临时覆盖队列中的并发级别
<a name="tutorial-wlm-query-slot-count"></a>

有时，用户可能会为某个特定查询临时需要更多资源。如果是这样的话，他们可以使用 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 覆盖并发级别
<a name="tutorial-wlm-override-slot-count"></a>

在本教程中，我们将运行同一个长时间运行的 SELECT 查询。我们将以 `adminwlm` 用户的身份运行查询，并使用 wlm\$1query\$1slot\$1count 增加查询的可用槽位数。

#### 使用 wlm\$1query\$1slot\$1count 覆盖并发级别
<a name="how-to-wlm-override-slot-count"></a>

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：从不同的会话中运行查询
<a name="tutorial-wlm-run-queries-from-different-sessions"></a>

接下来，从不同会话中运行查询。

#### 从不同的会话中运行查询
<a name="how-to-wlm-run-queries-from-different-sessions"></a>

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 节：清理资源
<a name="tutorial-wlm-cleaning-up-resources"></a>

只要您的集群正在运行，就将继续产生费用。完成本教程后，请按照《Amazon Redshift 入门指南》**中的[查找其它资源并重置环境](https://docs.aws.amazon.com/redshift/latest/gsg/rs-gsg-clean-up-tasks.html)中的步骤操作，使您的环境返回上一个状态。

有关 WLM 的更多信息，请参阅 [工作负载管理](cm-c-implementing-workload-management.md)。