

기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.

# Amazon Keyspaces에서 쿼리의 `SELECT` 문과 함께 `IN` 연산자 사용
<a name="in.select"></a>

**SELECT IN**

`SELECT` 문을 사용하여 테이블의 데이터를 쿼리할 수 있습니다. 문은 테이블에서 하나 이상의 행에 대해 하나 이상의 열을 읽고 요청과 일치하는 행이 포함된 결과 집합을 반환합니다. `SELECT` 문에는 읽고 결과 집합에서 반환할 열을 결정하는 `select_clause`가 포함되어 있습니다. 절에는 데이터를 반환하기 전에 데이터를 변환하는 지침이 포함될 수 있습니다. 선택적 `WHERE` 절은 쿼리해야 하는 행을 지정하며 프라이머리 키의 일부인 열에 대한 관계로 구성됩니다. Amazon Keyspaces는 `WHERE` 절의 `IN` 키워드를 지원합니다. 이 섹션에서는 예제를 사용하여 Amazon Keyspaces가 `IN` 키워드로 `SELECT` 문을 처리하는 방법을 보여 줍니다.

이 예제는 Amazon Keyspaces가 `IN` 키워드가 포함된 `SELECT` 문을 *하위 쿼리*로 분류하는 방법을 보여 줍니다. 이 예제에서는 이름이 `my_keyspace.customers`인 테이블을 사용합니다. 테이블에는 프라이머리 키 열 `department_id` 1개, 클러스터링 열 `sales_region_id` 및 `sales_representative_id` 2개, `customer_name` 열에 고객 이름이 포함된 열 1개가 있습니다.

```
SELECT * FROM my_keyspace.customers;

         department_id | sales_region_id | sales_representative_id | customer_name
        ---------------+-----------------+-------------------------+--------------
          0            |        0        |            0            |    a
          0            |        0        |            1            |    b
          0            |        1        |            0            |    c
          0            |        1        |            1            |    d
          1            |        0        |            0            |    e
          1            |        0        |            1            |    f
          1            |        1        |            0            |    g
          1            |        1        |            1            |    h
```

이 테이블을 사용하면 다음 `SELECT` 문을 실행하여 `WHERE` 절의 `IN` 키워드로 관심 있는 부서 및 판매 리전의 고객을 찾을 수 있습니다. 다음 문은 이에 대한 예입니다.

```
SELECT * FROM my_keyspace.customers WHERE department_id IN (0, 1) AND sales_region_id IN (0, 1);
```

Amazon Keyspaces는 다음 출력과 같이 이 문을 네 개의 하위 쿼리로 나눕니다.

```
SELECT * FROM my_keyspace.customers WHERE department_id = 0 AND sales_region_id = 0;

 department_id | sales_region_id | sales_representative_id | customer_name
---------------+-----------------+-------------------------+--------------
  0            |        0        |           0             |    a
  0            |        0        |           1             |    b

SELECT * FROM my_keyspace.customers WHERE department_id = 0 AND sales_region_id = 1;

 department_id | sales_region_id | sales_representative_id | customer_name
---------------+-----------------+-------------------------+--------------
  0            |        1        |          0              |    c
  0            |        1        |          1              |    d

SELECT * FROM my_keyspace.customers WHERE department_id = 1 AND sales_region_id = 0;

 department_id | sales_region_id | sales_representative_id | customer_name
---------------+-----------------+-------------------------+--------------
  1            |        0        |          0              |    e
  1            |        0        |          1              |    f

SELECT * FROM my_keyspace.customers WHERE department_id = 1 AND sales_region_id = 1;

 department_id | sales_region_id | sales_representative_id | customer_name
---------------+-----------------+-------------------------+--------------
  1            |        1        |           0             |    g
  1            |        1        |           1             |    h
```

`IN` 키워드를 사용하면 Amazon Keyspaces는 다음과 같은 경우에 결과를 자동으로 페이지로 나눕니다.
+ 10회마다 하위 쿼리가 처리된 후
+ 1MB의 논리적 IO를 처리한 후
+ `PAGE SIZE`를 구성한 경우 Amazon Keyspaces는 집합 `PAGE SIZE`를 기반으로 처리할 쿼리 수를 읽은 후 페이지를 매깁니다.
+ `LIMIT` 키워드를 사용하여 반환되는 행 수를 줄이면 Amazon Keyspaces는 집합 `LIMIT`를 기반으로 처리할 쿼리 수를 읽은 후 페이지를 매깁니다.

 다음 테이블은 예제를 통해 이를 설명하는 데 사용됩니다.

페이지 매김에 대한 자세한 내용은 [Amazon Keyspaces의 결과 페이지 매김](paginating-results.md) 섹션을 참조하세요.

```
SELECT * FROM my_keyspace.customers;

         department_id | sales_region_id | sales_representative_id | customer_name
        ---------------+-----------------+-------------------------+--------------
          2            |        0        |          0              |    g
          2            |        1        |          1              |    h
          2            |        2        |          2              |    i
          0            |        0        |          0              |    a
          0            |        1        |          1              |    b
          0            |        2        |          2              |    c
          1            |        0        |          0              |    d
          1            |        1        |          1              |    e
          1            |        2        |          2              |    f
          3            |        0        |          0              |    j
          3            |        1        |          1              |    k
          3            |        2        |          2              |    l
```

이 테이블에서 다음 문을 실행하여 페이지 매김의 작동 방식을 확인할 수 있습니다.

```
SELECT * FROM my_keyspace.customers WHERE department_id IN (0, 1, 2, 3) AND sales_region_id IN (0, 1, 2) AND sales_representative_id IN (0, 1);
```

Amazon Keyspaces는 이 문을 24개의 하위 쿼리로 처리합니다. 이 쿼리에 포함된 모든 `IN` 용어의 Cartesian 제품의 카디널리티가 24이기 때문입니다.

```
 department_id | sales_region_id | sales_representative_id | customer_name
---------------+-----------------+-------------------------+--------------
  0            |        0        |          0              |    a
  0            |        1        |          1              |    b
  1            |        0        |          0              |    d
  1            |        1        |          1              |    e

---MORE---
 department_id | sales_region_id | sales_representative_id | customer_name
---------------+-----------------+-------------------------+--------------
  2            |        0        |          0              |    g
  2            |        1        |          1              |    h
  3            |        0        |          0              |    j

---MORE---
 department_id | sales_region_id | sales_representative_id | customer_name
---------------+-----------------+-------------------------+--------------
  3            |        1        |          1              |    k
```

이 예제는 `IN` 키워드와 함께 `SELECT` 문에서 `ORDER BY` 절을 사용하는 방법을 보여 줍니다.

```
SELECT * FROM my_keyspace.customers WHERE department_id IN (3, 2, 1) ORDER BY sales_region_id DESC;
        
         department_id | sales_region_id | sales_representative_id | customer_name
        ---------------+-----------------+-------------------------+--------------
          3            |        2        |          2              |    l
          3            |        1        |          1              |    k
          3            |        0        |          0              |    j
          2            |        2        |          2              |    i
          2            |        1        |          1              |    h
          2            |        0        |          0              |    g
          1            |        2        |          2              |    f
          1            |        1        |          1              |    e
          1            |        0        |          0              |    d
```

하위 쿼리는 쿼리에 파티션 키 및 클러스터링 키 열이 표시된 순서대로 처리됩니다. 아래 예제에서는 파티션 키 값 ”2“에 대한 하위 쿼리가 먼저 처리된 다음 파티션 키 값 ”3“ 및 ”1“에 대한 하위 쿼리가 처리됩니다. 지정된 하위 쿼리의 결과는 쿼리의 정렬 절(있는 경우) 또는 테이블 생성 중에 정의된 테이블의 클러스터링 순서에 따라 정렬됩니다.

```
SELECT * FROM my_keyspace.customers WHERE department_id IN (2, 3, 1) ORDER BY sales_region_id DESC;

         department_id | sales_region_id | sales_representative_id | customer_name
        ---------------+-----------------+-------------------------+--------------
          2            |        2        |          2              |    i
          2            |        1        |          1              |    h
          2            |        0        |          0              |    g
          3            |        2        |          2              |    l
          3            |        1        |          1              |    k
          3            |        0        |          0              |    j
          1            |        2        |          2              |    f
          1            |        1        |          1              |    e
          1            |        0        |          0              |    d
```