Amazon Redshift 將不再支援從修補程式 198 開始建立新的 Python UDFs。現有 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，這些佇列如下：
+ *資料擷取佇列* – 這是針對擷取資料而設定的。這會分配 20％ 的叢集記憶體，並且具有 5 個插槽。隨後，5 個查詢可以在佇列中同時運行，並且每個查詢會分配到 4％ 的記憶體。
+ *資料科學家佇列* - 這是專為記憶體密集型查詢而設計的。這會分配 40％ 的叢集記憶體，並且具有 5 個插槽。隨後，5 個查詢可以同時運行，並且每個查詢會分配到 8％ 的記憶體。
+ *預設佇列* – 這是針對組織中大多數使用者所設計的。這包括銷售和會計群組，這些群組通常具有不複雜的簡短或中型執行查詢。它會分配到 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)。

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_tw/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_tw/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 預設有兩個用於查詢的佇列：一個給超級使用者使用，一個給使用者使用。超級使用者佇列無法設定，且一次只能處理一個佇列。只有為了故障排除的目的才需要保留此佇列。使用者佇列一次最多可以處理五個查詢，但您可以視需要變更佇列的並行層級以改變設定。

如果有多個使用者對資料庫執行查詢，您可能會發現另一種設定更有效率。例如，如果某些使用者執行資源密集型操作 (如 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_tw/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 SQL](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_tw/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 視窗：
+ 在第 1 個 RSQL 視窗中，您將使用您在本教學課程中已建立的檢視，執行查詢來監視佇列和查詢的狀態。
+ 在第 2 個 RSQL 視窗中，您將執行長時間執行的查詢來變更在第 1 個 RSQL 視窗中找到的結果。

#### 執行測試查詢
<a name="how-to-wlm-run-test-queries"></a>

1. 開啟兩個 RSQL 視窗。如果您已經開啟一個視窗，則只需再開啟第二個視窗。這兩個連線皆可使用相同的使用者帳戶。

1. 在第 1 個 RSQL 視窗中執行下列查詢。

   ```
   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. 在第 2 個 RSQL 視窗中，從 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;
   ```

   在第 2 個 RSQL 視窗中執行下列查詢。

   ```
   select avg(l.priceperticket*s.qtysold) from listing l, sales s where l.listid < 100000;
   ```

1. 在第 1 個 RSQL 視窗中，查詢 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 中的執行中欄位已從 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 管理主控台 ，並在 [https://console.aws.amazon.com/redshiftv2/](https://console.aws.amazon.com/redshiftv2/)：// 開啟 Amazon Redshift 主控台。

1. 在導覽選單中，選擇**組態**，然後選擇**工作負載管理**以顯示**工作負載管理**頁面。

1. 選擇 **Create (建立)** 以顯示 **Create parameter group (建立參數群組)** 視窗。

1. 在**參數群組名稱**和**描述**中輸入 **WLMTutorial**，然後選擇**建立**以建立參數群組。
**注意**  
**Parameter group name (參數群組名稱)** 會在建立時轉換成全部小寫的格式。

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 (新增佇列)** 兩次來新增兩個佇列。現在有三個佇列：**Queue 1 (佇列 1)**、**Queue 2 (佇列 2)** 和 **Default queue (預設佇列)**。

1. 輸入每個佇列的資訊如下：
   + 對於**佇列 1**，在**記憶體 (%)**輸入 **30**、在**主體的並行**輸入 **2**，以及在**查詢群組**輸入 **test**。將其他設定保留為其預設值。
   + 對於**佇列 2**，在**記憶體 (%)**輸入 **40**、在**主體的並行**輸入 **3**，以及在**使用者群組**輸入 **admin**。將其他設定保留為其預設值。
   + 將預設佇列的**主要值並行**設定為大於或等於 1 的值。不要對**預設佇列**做任何其他變更。WLM 會將未配置的記憶體指派給預設佇列。

1. 選擇 **Save (儲存)** 儲存設定。

接下來，將具備手動 WLM 組態的參數群組與叢集建立關聯。

**將具備手動 WLM 組態的參數群組與叢集建立關聯**

1. 登入 AWS 管理主控台 ，並在 [https://console.aws.amazon.com/redshiftv2/](https://console.aws.amazon.com/redshiftv2/)：// 開啟 Amazon Redshift 主控台。

1. 在導覽選單上，選擇**叢集**，然後選擇**叢集**來顯示您叢集的清單。

1. 選擇您的叢集，例如 `examplecluster`，以顯示叢集的詳細資訊。然後選擇**屬性**索引標籤以顯示該叢集的屬性。

1. 在**資料庫組態**區段中，選擇**編輯**、**編輯參數群組**，以顯示參數群組視窗。

1. 對於**參數群組**，請選擇先前建立的 **wlmtutorial** 參數群組。

1. 選擇**儲存變更**以關聯參數群組。

   叢集會使用變更的參數群組進行修改。但是，您需要重新啟動叢集，才能將變更套用到資料庫。

1. 選擇您的叢集，然後在**動作**選擇**重新啟動**。

叢集重新啟動之後，狀態會回到 **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
   ```

   查詢已路由到測試查詢群組，即現在的佇列 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. 在第 2 個 RSQL 視窗中，執行以下查詢切換到 `adminwlm` 帳戶，然後以該使用者的身分執行查詢。

   ```
   set session authorization 'adminwlm';
   select avg(l.priceperticket*s.qtysold) from listing l, sales s where l.listid <40000;
   ```

1. 在第 1 個 RSQL 視窗中，執行以下查詢來看看查詢被路由到哪個查詢佇列。

   ```
   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. 現在，從第 2 個 RSQL 視窗執行下列查詢。

   ```
   set query_group to test;
   select avg(l.priceperticket*s.qtysold) from listing l, sales s where l.listid <40000;
   ```

1. 在第 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   |      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. 在第 1 和第 2 個 RSQL 視窗中，執行下列查詢以使用 test 查詢群組。

   ```
   set query_group to test;
   ```

1. 在第 1 個 RSQL 視窗中執行下列長時間查詢。

   ```
   select avg(l.priceperticket*s.qtysold) from listing l, sales s where l.listid <40000;
   ```

1. 由於長時間執行的查詢仍在第 1 個 RSQL 視窗中進行，請執行下列命令。這些命令會提高槽計數來使用佇列的所有槽，然後開始執行長時間執行的查詢。

   ```
   set wlm_query_slot_count to 2;
   select avg(l.priceperticket*s.qtysold) from listing l, sales s where l.listid <40000;
   ```

1. 開啟第 3 個 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)。