기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다. # 지원되는 OpenSearch SQL 명령 및 함수 다음 참조 표에는 Amazon S3, Security Lake 또는 CloudWatch Logs의 데이터 쿼리용으로 OpenSearch Discover에서 지원되는 SQL 명령과 CloudWatch Logs Insights에서 지원되는 SQL 명령이 나와 있습니다. CloudWatch Logs Insights에서 지원되는 SQL 구문과 CloudWatch Logs 쿼리용으로 OpenSearch Discover에서 지원되는 SQL 구문은 동일하며, 다음 표에 CloudWatch Logs로 표시됩니다. **참고** OpenSearch는 OpenSearch에서 수집되어 인덱스에 저장된 데이터를 쿼리하기 위한 SQL 지원 기능도 제공합니다. 이 SQL 언어는 직접 쿼리에 사용되는 SQL과 다르며 [인덱스에서는 OpenSearch SQL](https://opensearch.org/docs/latest/search-plugins/sql/sql/index/)이라고 합니다. **Topics** + [ ## 명령 ](#supported-sql-data-retrieval) + [ ## 함수 ](#supported-sql-functions) + [ ## 일반 SQL 제한 사항 ](#general-sql-restrictions) + [ ## OpenSearch SQL을 사용하는 CloudWatch Logs Insights 사용자를 위한 추가 정보 ](#supported-sql-for-multi-log-queries) ## 명령 **참고** 필요에 따라, 예의 명령 열에서 쿼리하려는 데이터 소스에 따라 ``을 바꿉니다. 명령 예: `SELECT Body , Operation FROM ` Amazon S3 또는 Security Lake를 쿼리하는 경우 `SELECT Body , Operation FROM table_name`을 사용합니다. CloudWatch Logs를 쿼리하는 경우 `SELECT Body , Operation FROM `LogGroupA``를 사용합니다. | 명령 | 설명 | CloudWatch Logs | Amazon S3 | Security Lake | 명령 예제 | | --- | --- | --- | --- | --- | --- | | [SELECT 절](#supported-sql-select) | 예상 값을 표시합니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
SELECT 
    method,
    status 
FROM
| | [WHERE 절](#supported-sql-where) | 제공된 필드 기준에 따라 로그 이벤트를 필터링합니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
SELECT 
    * 
FROM 
    
WHERE 
    status = 100
| | [GROUP BY 절](#supported-sql-group-by) | 범주를 기반으로 로그 이벤트를 그룹화하고 통계를 기반으로 평균을 찾습니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
SELECT 
    method,
    status,
    COUNT(*) AS request_count,
    SUM(bytes) AS total_bytes 
FROM 
     
GROUP BY 
    method, 
    status
| | [HAVING 절](#supported-sql-having) | 그룹화 조건을 기준으로 결과를 필터링합니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
SELECT 
    method,
    status,
    COUNT(*) AS request_count,
    SUM(bytes) AS total_bytes 
FROM 
     
GROUP BY 
    method,
    status
HAVING 
    COUNT(*) > 5
| | [ORDER BY 절](#supported-sql-order-by) | order 절의 필드에 따라 결과를 정렬합니다. 오름차순 또는 내림차순으로 정렬할 수 있습니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
SELECT 
    * 
FROM 
     
ORDER BY 
    status DESC
| | [JOIN 절](#supported-sql-join) ( `INNER` \$1 `CROSS` \$1 `LEFT` `OUTER` ) | 공통 필드를 기반으로 두 테이블의 결과를 조인합니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨(조인에 `Inner` 및 `Left Outer` 키워드를 사용해야 함, SELECT 문에서는 하나의 JOIN 작업만 지원됨) | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨(조인에 내부, 왼쪽 외부 및 교차 키워드를 사용해야 함) | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨(조인에 내부, 왼쪽 외부 및 교차 키워드를 사용해야 함) | 
SELECT 
    A.Body,
    B.Timestamp
FROM 
     AS A 
INNER JOIN 
     AS B 
    ON A.`requestId` = B.`requestId`
| | [LIMIT 절](#supported-sql-limit) | 결과를 첫 번째 N개 행으로 제한합니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
SELECT 
    * 
FROM 
     
LIMIT 
    10
| | [CASE 절](#supported-sql-case) | 조건을 평가하고 첫 번째 조건이 충족되면 값을 반환합니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
SELECT
    method,
    status,
    CASE
        WHEN status BETWEEN 100 AND 199 THEN 'Informational'
        WHEN status BETWEEN 200 AND 299 THEN 'Success'
        WHEN status BETWEEN 300 AND 399 THEN 'Redirection'
        WHEN status BETWEEN 400 AND 499 THEN 'Client Error'
        WHEN status BETWEEN 500 AND 599 THEN 'Server Error'
        ELSE 'Unknown Status'
    END AS status_category,
    CASE method
        WHEN 'GET' THEN 'Read Operation'
        WHEN 'POST' THEN 'Create Operation'
        WHEN 'PUT' THEN 'Update Operation'
        WHEN 'PATCH' THEN 'Partial Update Operation'
        WHEN 'DELETE' THEN 'Delete Operation'
        ELSE 'Other Operation'
    END AS operation_type,
    bytes,
    datetime
FROM
| | [공통 테이블 표현식](#supported-sql-cte) | SELECT, INSERT, UPDATE, DELETE 또는 MERGE 문 내에 명명된 임시 결과 세트를 생성합니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/negative_icon.svg) 지원되지 않음 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
WITH RequestStats AS (
    SELECT 
        method,
        status,
        bytes,
        COUNT(*) AS request_count
    FROM 
        tableName
    GROUP BY 
        method,
        status,
        bytes
)
SELECT 
    method,
    status,
    bytes,
    request_count 
FROM 
    RequestStats 
WHERE 
    bytes > 1000
| | [EXPLAIN](#supported-sql-explain) | 실제로 실행하지 않고 SQL 문의 실행 계획을 표시합니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/negative_icon.svg) 지원되지 않음 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
EXPLAIN
SELECT 
    k,
    SUM(v)
FROM 
    VALUES 
        (1, 2),
        (1, 3) AS t(k, v)
GROUP BY 
    k
| | [LATERAL SUBQUERY 절](#supported-sql-lateral-subquery) | FROM 절의 하위 쿼리가 동일한 FROM 절의 이전 항목에서 열을 참조하도록 허용합니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/negative_icon.svg) 지원되지 않음 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
 SELECT 
    * 
FROM 
    tableName
LATERAL (
    SELECT 
        * 
    FROM 
        t2 
    WHERE 
        t1.c1 = t2.c1
)
| | [LATERAL VIEW 절](#supported-sql-lateral-view) | 기본 테이블의 각 행에 테이블 생성 함수를 적용하여 가상 테이블을 생성합니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/negative_icon.svg) 지원되지 않음 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
SELECT 
    * 
FROM 
    tableName
LATERAL VIEW 
    EXPLODE(ARRAY(30, 60)) tableName AS c_age
LATERAL VIEW 
    EXPLODE(ARRAY(40, 80)) AS d_age
| | [LIKE 조건자](#supported-sql-like-predicate) | 와일드카드 문자를 사용하여 문자열을 패턴과 매칭합니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
 SELECT 
    method,
    status,
    request,
    host 
FROM 
     
WHERE 
    method LIKE 'D%'
| | [OFFSET](#supported-sql-offset) | 쿼리에서 행을 반환하기 전에 건너뛸 행 수를 지정합니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 쿼리에서 LIMIT 절과 함께 사용할 때 지원됨 예제:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/supported-directquery-sql.html) | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
 SELECT 
    method,
    status,
    bytes,
    datetime 
FROM 
     
ORDER BY 
    datetime
OFFSET 
    10
| | [PIVOT 절](#supported-sql-pivot) | 행을 열로 변환하여 데이터를 행 기반 형식에서 열 기반 형식으로 바꿉니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/negative_icon.svg) 지원되지 않음 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
SELECT 
    * 
FROM 
    (
        SELECT 
            method,
            status,
            bytes
        FROM 
            
    ) AS SourceTable 
PIVOT 
(
    SUM(bytes) 
    FOR method IN ('GET', 'POST', 'PATCH', 'PUT', 'DELETE')
) AS PivotTable
| | [집합 연산자](#supported-sql-set) | 2개 이상의 SELECT 문(예: UNION, INTERSECT, EXCEPT)의 결과를 결합합니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
SELECT 
    method,
    status,
    bytes
FROM 
    
WHERE 
    status = '416'

UNION

SELECT 
    method,
    status,
    bytes
FROM 
    
WHERE 
    bytes > 20000
| | [SORT BY 절](#supported-sql-sort-by) | 쿼리 결과를 반환할 순서를 지정합니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
SELECT 
    method,
    status,
    bytes
FROM 
    
SORT BY 
    bytes DESC
| | [UNPIVOT](#supported-sql-unpivot) | 열을 행으로 변환하여 데이터를 열 기반 형식에서 행 기반 형식으로 바꿉니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/negative_icon.svg) 지원되지 않음 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
 SELECT 
    status,
    REPLACE(method, '_bytes', '') AS request_method,
    bytes,
    datetime 
FROM 
    PivotedData 
UNPIVOT 
(
    bytes 
    FOR method IN 
    (
        GET_bytes,
        POST_bytes,
        PATCH_bytes,
        PUT_bytes,
        DELETE_bytes
    )
) AS UnpivotedData
| ## 함수 **참고** 필요에 따라, 예의 명령 열에서 쿼리하려는 데이터 소스에 따라 ``을 바꿉니다. 명령 예: `SELECT Body , Operation FROM ` Amazon S3 또는 Security Lake를 쿼리하는 경우 `SELECT Body , Operation FROM table_name`을 사용합니다. CloudWatch Logs를 쿼리하는 경우 `SELECT Body , Operation FROM `LogGroupA``를 사용합니다. | 사용 가능한 SQL 문법 | 설명 | CloudWatch Logs | Amazon S3 | Security Lake | 명령 예제 | | --- | --- | --- | --- | --- | --- | | [문자열 함수](#supported-sql-string) | SQL 쿼리 내에서 문자열 및 텍스트 데이터를 조작하고 변환할 수 있는 내장 함수입니다. 변환 사례, 문자열 결합, 부분 추출, 텍스트 정리 등을 예로 들 수 있습니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
SELECT 
    UPPER(method) AS upper_method,
    LOWER(host) AS lower_host 
FROM
| | [날짜 및 시간 함수](#supported-sql-date-time) | 쿼리에서 날짜 및 타임스탬프 데이터를 처리하고 변환하는 내장 함수입니다. 예: **date\$1add**, **date\$1format**, **datediff**, **current\$1date**. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
SELECT 
    TO_TIMESTAMP(datetime) AS timestamp,
    TIMESTAMP_SECONDS(UNIX_TIMESTAMP(datetime)) AS from_seconds,
    UNIX_TIMESTAMP(datetime) AS to_unix,
    FROM_UTC_TIMESTAMP(datetime, 'PST') AS to_pst,
    TO_UTC_TIMESTAMP(datetime, 'EST') AS from_est 
FROM
| | [집계 함수](#supported-sql-aggregate) | 여러 행에서 계산을 수행하여 단일 요약 값을 생성하는 내장 함수입니다. 예: **sum**, **count**, **avg**, **max**, **min**. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg)지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
SELECT 
    COUNT(*) AS total_records,
    COUNT(DISTINCT method) AS unique_methods,
    SUM(bytes) AS total_bytes,
    AVG(bytes) AS avg_bytes,
    MIN(bytes) AS min_bytes,
    MAX(bytes) AS max_bytes 
FROM
| | [조건 함수](#supported-sql-conditional) | 지정된 조건을 기반으로 작업을 수행하거나 조건부로 표현식을 평가하는 내장 함수입니다. 예: **CASE**, **IF**. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
SELECT 
    CASE 
        WHEN method = 'GET' AND bytes < 1000 THEN 'Small Read'
        WHEN method = 'POST' AND bytes > 10000 THEN 'Large Write'
        WHEN status >= 400 OR bytes = 0 THEN 'Problem'
        ELSE 'Normal'
    END AS request_type 
FROM
| | [JSON 함수](#supported-sql-json) | 데이터 세트에서 JSON 구조를 조작할 수 있도록 SQL 쿼리(예: from\$1json, to\$1json, get\$1json\$1object, json\$1tuple) 내에서 JSON 형식 데이터를 구문 분석, 추출, 수정 및 쿼리하는 기본 제공 함수입니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
SELECT 
    FROM_JSON(
        @message, 
        'STRUCT<
            host: STRING,
            user-identifier: STRING,
            datetime: STRING,
            method: STRING,
            status: INT,
            bytes: INT
        >'
    ) AS parsed_json 
FROM
| | [배열 함수](#supported-sql-array) | SQL 쿼리에서 배열 유형 열 작업에 내장 함수를 사용하면 배열 데이터 액세스, 수정 및 분석과 같은 작업(예: 크기, 폭발, array\$1contains)을 수행할 수 있습니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
SELECT 
    scores,
    size(scores) AS length,
    array_contains(scores, 90) AS has_90 
FROM
| | [윈도우 함수](#supported-sql-window) | 현재 행(윈도우)과 관련된 지정된 행 세트에서 계산을 수행하여 순위, 합계 실행 및 이동 평균(예: ROW\$1NUMBER, RANK, LAG, LEAD)과 같은 작업을 활성화하는 내장 함수입니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
 SELECT 
    field1,
    field2,
    RANK() OVER (ORDER BY field2 DESC) AS field2Rank 
FROM
| | [변환 함수](#supported-sql-conversion) | SQL 쿼리 내에서 한 유형에서 다른 유형으로 데이터를 변환하여 데이터 유형 변환 및 형식 변환을 지원하는 내장 함수(예: CAST, TO\$1DATE, TO\$1TIMESTAMP, BINARY)입니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
SELECT 
    CAST('123' AS INT) AS converted_number,
    CAST(123 AS STRING) AS converted_string 
FROM
| | [조건자 함수](#supported-sql-predicate) | 조건을 평가하고 지정된 기준 또는 패턴(예: IN, LIKE, BETWEEN, IS NULL, EXISTS)에 따라 부울 값(true/false)을 반환하는 내장 함수입니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
SELECT 
    * 
FROM 
     
WHERE 
    id BETWEEN 50000 AND 75000
| | [맵 함수](#supported-sql-map) | 컬렉션의 각 요소에 지정된 함수를 적용하여 데이터를 새 값 세트로 변환합니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/negative_icon.svg) 지원되지 않음 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
SELECT 
    MAP_FILTER(
        MAP(
            'method', method,
            'status', CAST(status AS STRING),
            'bytes', CAST(bytes AS STRING)
        ),
        (k, v) -> k IN ('method', 'status') AND v != 'null'
    ) AS filtered_map 
FROM 
     
WHERE 
    status = 100
| | [수학 함수](#supported-sql-math) | 평균, 합계, 삼각함수 값 계산 등, 숫자 데이터에 대한 수학 연산을 수행합니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
SELECT 
    bytes,
    bytes + 1000 AS added,
    bytes - 1000 AS subtracted,
    bytes * 2 AS doubled,
    bytes / 1024 AS kilobytes,
    bytes % 1000 AS remainder 
FROM
| | [다중 로그 그룹 함수](#multi-log-queries) | 사용자가 SQL SELECT 문에서 여러 로그 그룹을 지정할 수 있도록 합니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 해당 사항 없음 | 해당 사항 없음 | 
SELECT 
    lg1.Column1,
    lg1.Column2 
FROM 
    `logGroups(logGroupIdentifier: ['LogGroup1', 'LogGroup2'])` AS lg1 
WHERE 
    lg1.Column3 = "Success"
| | [생성 함수](#supported-sql-generator) | 값 시퀀스를 생성하는 반복자 객체를 생성하여 대규모 데이터 세트에서 메모리를 효율적으로 사용할 수 있게 합니다. | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/negative_icon.svg) 지원되지 않음 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | ![\[alt text not found\]](http://docs.aws.amazon.com/ko_kr/opensearch-service/latest/developerguide/images/success_icon.svg) 지원됨 | 
SELECT 
    explode(array(10, 20))
| ## 일반 SQL 제한 사항 CloudWatch Logs, Amazon S3 및 Security Lake와 함께 OpenSearch SQL을 사용할 경우 다음 제한이 적용됩니다. 1. SELECT 문에는 하나의 JOIN 작업만 사용할 수 있습니다. 1. 중첩 하위 쿼리는 한 수준만 지원됩니다. 1. 세미콜론으로 구분된 여러 문 쿼리는 지원되지 않습니다. 1. 동일하지만 대/소문자만 다른 필드 이름을 포함하는 쿼리(예: field1과 FIELD1)는 지원되지 않습니다. 예를 들어 다음 쿼리는 지원되지 않습니다. ``` Select AWSAccountId, awsaccountid from LogGroup ``` 단, 다음 쿼리는 필드 이름(@logStream)이 두 로그 그룹에서 동일하기 때문에 지원됩니다. ``` Select a.`@logStream`, b.`@logStream` from Table A INNER Join Table B on a.id = b.id ``` 1. 함수와 표현식은 필드 이름에 대해 작동해야 하며 FROM 절에 지정된 로그 그룹이 있는 SELECT 문의 일부여야 합니다. 예를 들어 다음 쿼리는 지원되지 않습니다. ``` SELECT cos(10) FROM LogGroup ``` 다음 쿼리는 지원됩니다. ``` SELECT cos(field1) FROM LogGroup ``` ## OpenSearch SQL을 사용하는 CloudWatch Logs Insights 사용자를 위한 추가 정보 CloudWatch Logs는 Logs Insights 콘솔, API 및 CLI에서 OpenSearch SQL 쿼리를 지원합니다. SELECT, FROM, WHERE, GROUP BY, HAVING, JOINS 및 중첩 쿼리를 비롯한 대부분의 명령과 JSON, 수학, 문자열 및 조건 함수를 지원합니다. 단, CloudWatch Logs는 읽기 작업만 지원하므로 DDL 또는 DML 문은 허용되지 않습니다. 지원되는 명령 및 함수의 전체 목록은 이전 섹션의 표를 참조하세요. ### 다중 로그 그룹 함수 CloudWatch Logs Insights는 여러 로그 그룹을 쿼리하는 기능을 지원합니다. SQL에서는 `logGroups` 명령을 사용하여 이 사용 사례를 해결할 수 있습니다. 이 명령은 하나 이상의 로그 그룹과 관련한 CloudWatch Logs Insights의 데이터 쿼리에만 해당됩니다. 이 구문을 사용하면 각 로그 그룹에 대한 쿼리를 작성하고 `UNION` 명령과 결합하는 대신 명령에 지정하여 여러 로그 그룹을 쿼리할 수 있습니다. 구문: ``` `logGroups( logGroupIdentifier: ['LogGroup1','LogGroup2', ...'LogGroupn'] ) ``` 이 구문에서는 `logGroupIndentifier` 파라미터에 최대 50개의 로그 그룹을 지정할 수 있습니다. 모니터링 계정의 로그 그룹을 참조하려면 `LogGroup` 이름 대신 ARN을 사용합니다. 예제 쿼리: ``` SELECT LG1.Column1, LG1.Column2 from `logGroups( logGroupIdentifier: ['LogGroup1', 'LogGroup2'] )` as LG1 WHERE LG1.Column1 = 'ABC' ``` CloudWatch Logs를 쿼리할 때 `FROM` 문 뒤에 여러 로그 그룹이 포함된 다음 구문은 지원되지 않습니다. ``` SELECT Column1, Column2 FROM 'LogGroup1', 'LogGroup2', ...'LogGroupn' WHERE Column1 = 'ABC' ``` ### 제한 사항 SQL 또는 PPL 명령을 사용하는 경우 특정 필드를 백틱으로 묶어 쿼리합니다. 백틱은 특수 문자(비영숫자 및 비숫자)가 있는 필드에 필요합니다. 예를 들어 `@message`, `Operation.Export,` 및 `Test::Field`는 백틱으로 묶습니다. 알파벳으로만 된 이름의 열을 백틱으로 묶을 필요는 없습니다. 단순 필드가 있는 쿼리 예: ``` SELECT SessionToken, Operation, StartTime FROM `LogGroup-A` LIMIT 1000; ``` 백틱이 추가된 동일한 쿼리: ``` SELECT `SessionToken`, `Operation`, `StartTime` FROM `LogGroup-A` LIMIT 1000; ``` CloudWatch Logs에만 국한되지 않는 추가적인 일반 제한 사항은 [일반 SQL 제한 사항](#general-sql-restrictions) 섹션을 참조하세요. ### 샘플 쿼리 및 할당량 **참고** 다음은 CloudWatch 데이터를 쿼리하는 CloudWatch Logs Insights 사용자와 OpenSearch 사용자 모두에게 적용됩니다. CloudWatch Logs에서 사용할 수 있는 샘플 SQL 쿼리의 예는 Amazon CloudWatch Logs Insights 콘솔의 **저장된 쿼리 및 샘플 쿼리**를 참조하세요. OpenSearch Service에서 CloudWatch Logs를 쿼리할 때 적용되는 제한에 대한 자세한 내용은 Amazon CloudWatch Logs 사용 설명서의 [CloudWatch Logs 할당량](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch_limits_cwl.html)을 참조하세요. 제한에는 쿼리할 수 있는 CloudWatch Log 그룹 수, 실행할 수 있는 최대 동시 쿼리 수, 최대 쿼리 실행 시간 및 결과에 반환된 최대 행 수가 포함됩니다. CloudWatch Logs를 쿼리하는 데 사용하는 언어(즉, OpenSearch PPL, SQL 및 Logs Insights)에 관계없이 제한은 동일합니다. ### SQL 명령 **Topics** + [ #### 문자열 함수 ](#supported-sql-string) + [ #### 날짜 및 시간 함수 ](#supported-sql-date-time) + [ #### 집계 함수 ](#supported-sql-aggregate) + [ #### 조건 함수 ](#supported-sql-conditional) + [ #### JSON 함수 ](#supported-sql-json) + [ #### 배열 함수 ](#supported-sql-array) + [ #### 윈도우 함수 ](#supported-sql-window) + [ #### 변환 함수 ](#supported-sql-conversion) + [ #### 조건자 함수 ](#supported-sql-predicate) + [ #### 맵 함수 ](#supported-sql-map) + [ #### 수학 함수 ](#supported-sql-math) + [ #### 생성 함수 ](#supported-sql-generator) + [ #### SELECT 절 ](#supported-sql-select) + [ #### WHERE 절 ](#supported-sql-where) + [ #### GROUP BY 절 ](#supported-sql-group-by) + [ #### HAVING 절 ](#supported-sql-having) + [ #### ORDER BY 절 ](#supported-sql-order-by) + [ #### JOIN 절 ](#supported-sql-join) + [ #### LIMIT 절 ](#supported-sql-limit) + [ #### CASE 절 ](#supported-sql-case) + [ #### 공통 테이블 표현식 ](#supported-sql-cte) + [ #### EXPLAIN ](#supported-sql-explain) + [ #### LATERAL SUBQUERY 절 ](#supported-sql-lateral-subquery) + [ #### LATERAL VIEW 절 ](#supported-sql-lateral-view) + [ #### LIKE 조건자 ](#supported-sql-like-predicate) + [ #### OFFSET ](#supported-sql-offset) + [ #### PIVOT 절 ](#supported-sql-pivot) + [ #### 집합 연산자 ](#supported-sql-set) + [ #### SORT BY 절 ](#supported-sql-sort-by) + [ #### UNPIVOT ](#supported-sql-unpivot) #### 문자열 함수 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). **** | 함수 | 설명 | | --- | --- | | ascii(str) | str에서 첫 번째 문자의 숫자 값을 반환합니다. | | base64(bin) | 인수를 바이너리 bin에서 Base 64 문자열로 변환합니다. | | bit\$1length(expr) | 문자열 데이터의 비트 길이 또는 바이너리 데이터의 비트 수를 반환합니다. | | btrim(str) | str에서 선행 및 후행 공백 문자를 제거합니다. | | btrim(str, trimStr) | str에서 선행 및 후행 trimStr 문자를 제거합니다. | | char(expr) | expr과 동일한 바이너리를 가진 ASCII 문자를 반환합니다. n이 256보다 큰 경우 결과는 chr(n % 256)과 같습니다. | | char\$1length(expr) | 문자열 데이터의 문자 길이 또는 바이너리 데이터의 바이트 수를 반환합니다. 문자열 데이터의 길이는 후행 공백을 포함합니다. 바이너리 데이터의 길이는 바이너리 0을 포함합니다. | | character\$1length(expr) | 문자열 데이터의 문자 길이 또는 바이너리 데이터의 바이트 수를 반환합니다. 문자열 데이터의 길이는 후행 공백을 포함합니다. 바이너리 데이터의 길이는 바이너리 0을 포함합니다. | | chr(expr) | expr과 동일한 바이너리를 가진 ASCII 문자를 반환합니다. n이 256보다 큰 경우 결과는 chr(n % 256)과 같습니다. | | concat\$1ws(sep[, str \$1 array(str)]\$1) | null 값을 건너뛰고 sep로 구분된 문자열의 연결을 반환합니다. | | contains(left, right) | 부울을 반환합니다. right가 left 내에 있는 경우 값은 True입니다. 입력 표현식 중 하나가 NULL인 경우 NULL을 반환합니다. 그렇지 않을 경우 false를 반환합니다. left 또는 right 모두 STRING 또는 BINARY 유형이어야 합니다. | | decode(bin, charset) | 두 번째 인수 문자 집합을 사용하여 첫 번째 인수를 디코딩합니다. | | decode(expr, search, result [, search, result ] ... [, default]) | expr을 각 검색 값과 순서대로 비교합니다. expr이 검색 값과 같으면 디코딩에서 해당 결과를 반환합니다. 일치하는 항목이 없으면 기본값을 반환합니다. 기본값을 생략하면 null을 반환합니다. | | elt(n, input1, input2, ...) | n번째 입력을 반환합니다. 예를 들어 n이 2인 경우 input2를 반환합니다. | | encode(str, charset) | 두 번째 인수 문자 집합을 사용하여 첫 번째 인수를 인코딩합니다. | | endswith(left, right) | 부울을 반환합니다. left가 right로 끝나는 경우 값은 True입니다. 입력 표현식 중 하나가 NULL인 경우 NULL을 반환합니다. 그렇지 않을 경우 false를 반환합니다. left 또는 right 모두 STRING 또는 BINARY 유형이어야 합니다. | | find\$1in\$1set(str, str\$1array) | 쉼표로 구분된 목록(str\$1array)에서 지정된 문자열(str)의 인덱스(1 기반)를 반환합니다. 문자열을 찾을 수 없거나 지정된 문자열(str)에 쉼표가 포함된 경우 0을 반환합니다. | | format\$1number(expr1, expr2) | '\$1,\$1\$1\$1,\$1\$1\$1.\$1\$1'과 같은 숫자 expr1의 형식을 expr2 소수 자릿수로 반올림합니다. expr2가 0이면 결과에 소수점이나 소수 부분이 없는 것입니다. expr2에는 사용자 지정 형식도 허용됩니다. MySQL의 FORMAT처럼 작동합니다. | | format\$1string(strfmt, obj, ...) | printf 스타일 형식 문자열에서 형식이 지정된 문자열을 반환합니다. | | initcap(str) | 대문자로 된 각 단어의 첫 번째 문자와 함께 str을 반환합니다. 다른 모든 문자는 소문자입니다. 단어는 공백으로 구분됩니다. | | instr(str, substr) | str에서 substr의 첫 출현에 대해 (1 기반) 인덱스를 반환합니다. | | lcase(str) | 모든 문자가 소문자로 변경된 상태로 str을 반환합니다. | | left(str, len) | str 문자열에서 가장 왼쪽 len(len은 문자열 유형일 수 있음) 문자를 반환합니다. len이 0보다 작거나 같으면 빈 문자열이 결과로 반환됩니다. | | len(expr) | 문자열 데이터의 문자 길이 또는 바이너리 데이터의 바이트 수를 반환합니다. 문자열 데이터의 길이는 후행 공백을 포함합니다. 바이너리 데이터의 길이는 바이너리 0을 포함합니다. | | length(expr) | 문자열 데이터의 문자 길이 또는 바이너리 데이터의 바이트 수를 반환합니다. 문자열 데이터의 길이는 후행 공백을 포함합니다. 바이너리 데이터의 길이는 바이너리 0을 포함합니다. | | levenshtein(str1, str2[, threshold]) | 지정된 두 문자열 사이의 레벤슈타인 거리를 반환합니다. 임계값이 설정되어 있고 그보다 거리가 멀면 -1을 반환합니다. | | locate(substr, str[, pos]) | str의 위치 pos 뒤에서 substr의 첫 번째 출현 위치를 반환합니다. 지정된 pos 및 반환 값은 1 기반입니다. | | lower(str) | 모든 문자가 소문자로 변경된 상태로 str을 반환합니다. | | lpad(str, len[, pad]) | pad로 왼쪽 패딩된 str을 len 길이로 반환합니다. str이 len보다 길면 반환 값이 len 문자 또는 바이트로 단축됩니다. pad를 지정하지 않으면 str은 문자열인 경우 공백 문자로, 바이트 시퀀스인 경우 0으로 왼쪽에 패딩됩니다. | | ltrim(str) | str에서 선행 공백 문자를 제거합니다. | | luhn\$1check(str) | Luhn 알고리즘에 따라 숫자 문자열이 유효한지 확인합니다. 이 체크섬 함수는 신용카드 번호 및 정부 발행 신분증 번호에 광범위하게 적용되어 유효한 번호를 잘못 입력되거나 부정확한 번호와 구분합니다. | | mask(input[, upperChar, lowerChar, digitChar, otherChar]) | 지정된 문자열 값을 마스킹합니다. 이 함수는 문자를 'X' 또는 'x'로 바꾸고 숫자를 'n'으로 바꿉니다. 이 함수는 민감한 정보가 제거된 테이블의 복사본을 생성하는 데 유용할 수 있습니다. | | octet\$1length(expr) | 문자열 데이터의 바이트 길이 또는 바이너리 데이터의 바이트 수를 반환합니다. | | overlay(input, replace, pos[, len]) | input을 pos로 시작하고 길이가 len인 replace로 바꿉니다. | | position(substr, str[, pos]) | str의 위치 pos 뒤에서 substr의 첫 번째 출현 위치를 반환합니다. 지정된 pos 및 반환 값은 1 기반입니다. | | printf(strfmt, obj, ...) | printf 스타일 형식 문자열에서 형식이 지정된 문자열을 반환합니다. | | regexp\$1count(str, regexp) | 문자열 str에서 정규식 패턴 regexp가 일치하는 횟수를 반환합니다. | | regexp\$1extract(str, regexp[, idx]) | regexp 표현식과 일치하고 정규식 그룹 인덱스에 해당하는 str의 첫 번째 문자열을 추출합니다. | | regexp\$1extract\$1all(str, regexp[, idx]) | regexp 표현식과 일치하고 정규식 그룹 인덱스에 해당하는 str의 모든 문자열을 추출합니다. | | regexp\$1instr(str, regexp) | 문자열에서 정규식을 검색하여 일치하는 하위 문자열의 시작 위치를 나타내는 정수를 반환합니다. 위치는 0이 아닌 1 기반입니다. 일치하는 결과가 없는 경우 0을 반환합니다. | | regexp\$1replace(str, regexp, rep[, position]) | regexp와 일치하는 str의 모든 하위 문자열을 rep로 바꿉니다. | | regexp\$1substr(str, regexp) | 문자열 str 내의 정규식 regexp와 일치하는 하위 문자열을 반환합니다. 정규식을 찾을 수 없는 경우 결과는 null입니다. | | repeat(str, n) | 지정된 문자열 값을 n번 반복하는 문자열을 반환합니다. | | replace(str, search[, replace]) | 모든 search를 replace로 바꿉니다. | | right(str, len) | str 문자열에서 가장 오른쪽 len(len은 문자열 유형일 수 있음) 문자를 반환합니다. len이 0보다 작거나 같으면 빈 문자열이 결과로 반환됩니다. | | rpad(str, len[, pad]) | pad로 오른쪽 패딩된 str을 len 길이로 반환합니다. str이 len보다 길면 반환 값이 len 문자로 단축됩니다. pad를 지정하지 않으면 str은 문자열인 경우 공백 문자로, 바이너리 문자열인 경우 0으로 오른쪽에 패딩됩니다. | | rtrim(str) | str에서 후행 공백 문자를 제거합니다. | | sentences(str[, lang, country]) | str을 단어 배열로 분할합니다. | | soundex(str) | 문자열의 Soundex 코드를 반환합니다. | | space(n) | n개의 공백으로 구성된 문자열을 반환합니다. | | split(str, regex, limit) | regex와 일치하는 str을 분할하고 최대 limit 길이의 배열을 반환합니다. | | split\$1part(str, delimiter, partNum) | str을 구분 기호로 분할하고 분할의 요청된 부분(1 기반)을 반환합니다. 입력이 null이면 null을 반환합니다. partNum이 분할된 부분의 범위를 벗어나면 빈 문자열을 반환합니다. partNum이 0이면 오류가 발생합니다. partNum이 음수면 문자열 끝에서 역순으로 부분들이 계산됩니다. delimiter가 빈 문자열이면 str이 분할되지 않습니다. | | startswith(left, right) | 부울을 반환합니다. left가 right로 시작하는 경우 값은 True입니다. 입력 표현식 중 하나가 NULL인 경우 NULL을 반환합니다. 그렇지 않을 경우 false를 반환합니다. left 또는 right 모두 STRING 또는 BINARY 유형이어야 합니다. | | substr(str, pos[, len]) | pos에서 시작하고 길이가 len인의 하위 문자열 str 또는 pos에서 시작하고 길이가 len인 바이트 배열 조각을 반환합니다. | | substr(str FROM pos[ FOR len]]) | pos에서 시작하고 길이가 len인의 하위 문자열 str 또는 pos에서 시작하고 길이가 len인 바이트 배열 조각을 반환합니다. | | substring(str, pos[, len]) | pos에서 시작하고 길이가 len인의 하위 문자열 str 또는 pos에서 시작하고 길이가 len인 바이트 배열 조각을 반환합니다. | | substring(str FROM pos[ FOR len]]) | pos에서 시작하고 길이가 len인의 하위 문자열 str 또는 pos에서 시작하고 길이가 len인 바이트 배열 조각을 반환합니다. | | substring\$1index(str, delim, count) | 구분 기호 delim이 count회 나타나기 전에 str에서 하위 문자열을 반환합니다. count가 양수이면 최종 구분 기호 왼쪽에 있는 모든 항목(왼쪽부터 계산)이 반환됩니다. count가 음수이면 최종 구분 기호 오른쪽에 있는 모든 항목(오른쪽부터 계산)이 반환됩니다. 함수 substring\$1index는 delim을 검색할 때 대소문자를 구분하는 매칭을 수행합니다. | | to\$1binary(str[, fmt]) | 제공된 fmt에 따라 입력 str을 바이너리 값으로 변환합니다. fmt는 'hex', 'utf-8', 'utf8' 또는 'base64'의 대소문자를 구분하지 않는 문자열 리터럴일 수 있습니다. 기본적으로 변환을 위한 바이너리 형식은 fmt가 생략된 경우 'hex'입니다. 입력 파라미터 중 하나 이상이 NULL인 경우 함수는 NULL을 반환합니다. | | to\$1char(numberExpr, formatExpr) | formatExpr에 따라 numberExpr을 문자열로 변환합니다. 변환이 실패할 경우 예외가 발생합니다. 형식은 대소문자를 구분하지 않는 다음 문자로 구성됩니다. '0' 또는 '9': 0에서 9 사이의 예상 숫자를 지정합니다. 형식 문자열의 시퀀스 0 또는 9는 입력 값의 숫자 시퀀스와 일치하며, 형식 문자열의 해당 시퀀스와 동일한 길이의 결과 문자열을 생성합니다. 0/9 시퀀스가 10진수 값의 일치하는 부분보다 많은 숫자를 포함하고, 0으로 시작하고, 10진수 앞에 있는 경우 결과 문자열은 0으로 왼쪽 패딩됩니다. 그렇지 않으면 공백으로 채워집니다. '.' 또는 'D': 소수점의 위치를 지정합니다(선택 사항, 한 번만 허용). ',' 또는 'G': 그룹화(1,000) 구분 기호(,)의 위치를 지정합니다. 각 그룹화 구분 기호의 왼쪽과 오른쪽에 0 또는 9가 있어야 합니다. ' | | to\$1number(expr, fmt) | 문자열 형식 'fmt'에 따라 문자열 'expr'을 숫자로 변환합니다. 변환이 실패할 경우 예외가 발생합니다. 형식은 대소문자를 구분하지 않는 다음 문자로 구성됩니다. '0' 또는 '9': 0에서 9 사이의 예상 숫자를 지정합니다. 형식 문자열의 시퀀스 0 또는 9는 입력 문자열의 숫자 시퀀스와 일치합니다. 0/9 시퀀스가 0으로 시작하고 소수점 앞에 있는 경우 동일한 크기의 숫자 시퀀스만 매칭할 수 있습니다. 그렇지 않으면 시퀀스가 9로 시작하거나 소수점 뒤에 있는 경우 크기가 같거나 작은 숫자 시퀀스와 매칭할 수 있습니다. '.' 또는 'D': 소수점의 위치를 지정합니다(선택 사항, 한 번만 허용). ',' 또는 'G': 그룹화(1,000) 구분 기호(,)의 위치를 지정합니다. 각 그룹화 구분 기호의 왼쪽과 오른쪽에 0 또는 9가 있어야 합니다. 'expr'은 숫자 크기와 관련한 그룹화 구분 기호와 일치해야 합니다. ' | | to\$1varchar(numberExpr, formatExpr) | formatExpr에 따라 numberExpr을 문자열로 변환합니다. 변환이 실패할 경우 예외가 발생합니다. 형식은 대소문자를 구분하지 않는 다음 문자로 구성됩니다. '0' 또는 '9': 0에서 9 사이의 예상 숫자를 지정합니다. 형식 문자열의 시퀀스 0 또는 9는 입력 값의 숫자 시퀀스와 일치하며, 형식 문자열의 해당 시퀀스와 동일한 길이의 결과 문자열을 생성합니다. 0/9 시퀀스가 10진수 값의 일치하는 부분보다 많은 숫자를 포함하고, 0으로 시작하고, 10진수 앞에 있는 경우 결과 문자열은 0으로 왼쪽 패딩됩니다. 그렇지 않으면 공백으로 채워집니다. '.' 또는 'D': 소수점의 위치를 지정합니다(선택 사항, 한 번만 허용). ',' 또는 'G': 그룹화(1,000) 구분 기호(,)의 위치를 지정합니다. 각 그룹화 구분 기호의 왼쪽과 오른쪽에 0 또는 9가 있어야 합니다. ' | | translate(input, from, to) | from 문자열에 있는 문자를 to 문자열의 해당 문자로 대체함으로써 input 문자열을 변환합니다. | | trim(str) | str에서 선행 및 후행 공백 문자를 제거합니다. | | trim(BOTH FROM str) | str에서 선행 및 후행 공백 문자를 제거합니다. | | trim(LEADING FROM str) | str에서 선행 공백 문자를 제거합니다. | | trim(TRAILING FROM str) | str에서 후행 공백 문자를 제거합니다. | | trim(trimStr FROM str) | str에서 선행 및 후행 trimStr 문자를 제거합니다. | | trim(BOTH trimStr FROM str) | str에서 선행 및 후행 trimStr 문자를 제거합니다. | | trim(LEADING trimStr FROM str) | str에서 선행 trimStr 문자를 제거합니다. | | trim(TRAILING trimStr FROM str) | str에서 후행 trimStr 문자를 제거합니다. | | try\$1to\$1binary(str[, fmt]) | 동일한 작업을 수행하는 to\$1binary의 특수 버전이지만 변환을 수행할 수 없는 경우 오류를 발생시키는 대신 NULL 값을 반환합니다. | | try\$1to\$1number(expr, fmt) | 문자열 형식 fmt에 따라 문자열 'expr'을 숫자로 변환합니다. 문자열 'expr'이 예상 형식과 일치하지 않으면 NULL을 반환합니다. 형식은 to\$1number 함수와 동일한 의미 체계를 따릅니다. | | ucase(str) | 모든 문자가 대문자로 변경된 상태로 str을 반환합니다. | | unbase64(str) | 인수를 base 64 문자열 str에서 바이너리로 변환합니다. | | upper(str) | 모든 문자가 대문자로 변경된 상태로 str을 반환합니다. | **예시** ``` -- ascii SELECT ascii('222'); +----------+ |ascii(222)| +----------+ | 50| +----------+ SELECT ascii(2); +--------+ |ascii(2)| +--------+ | 50| +--------+ -- base64 SELECT base64('Feathers'); +-----------------+ |base64(Feathers)| +-----------------+ | RmVhdGhlcnM=| +-----------------+ SELECT base64(x'537061726b2053514c'); +-----------------------------+ |base64(X'537061726B2053514C')| +-----------------------------+ | U3BhcmsgU1FM| +-----------------------------+ -- bit_length SELECT bit_length('Feathers'); +---------------------+ |bit_length(Feathers)| +---------------------+ | 64| +---------------------+ SELECT bit_length(x'537061726b2053514c'); +---------------------------------+ |bit_length(X'537061726B2053514C')| +---------------------------------+ | 72| +---------------------------------+ -- btrim SELECT btrim(' Feathers '); +----------------------+ |btrim( Feathers )| +----------------------+ | Feathers| +----------------------+ SELECT btrim(encode(' Feathers ', 'utf-8')); +-------------------------------------+ |btrim(encode( Feathers , utf-8))| +-------------------------------------+ | Feathers| +-------------------------------------+ SELECT btrim('Feathers', 'Fe'); +---------------------+ |btrim(Alphabet, Al)| +---------------------+ | athers| +---------------------+ SELECT btrim(encode('Feathers', 'utf-8'), encode('Al', 'utf-8')); +---------------------------------------------------+ |btrim(encode(Feathers, utf-8), encode(Al, utf-8))| +---------------------------------------------------+ | athers| +---------------------------------------------------+ -- char SELECT char(65); +--------+ |char(65)| +--------+ | A| +--------+ -- char_length SELECT char_length('Feathers '); +-----------------------+ |char_length(Feathers )| +-----------------------+ | 9 | +-----------------------+ SELECT char_length(x'537061726b2053514c'); +----------------------------------+ |char_length(X'537061726B2053514C')| +----------------------------------+ | 9| +----------------------------------+ SELECT CHAR_LENGTH('Feathers '); +-----------------------+ |char_length(Feathers )| +-----------------------+ | 9| +-----------------------+ SELECT CHARACTER_LENGTH('Feathers '); +----------------------------+ |character_length(Feathers )| +----------------------------+ | 9| +----------------------------+ -- character_length SELECT character_length('Feathers '); +----------------------------+ |character_length(Feathers )| +----------------------------+ | 9| +----------------------------+ SELECT character_length(x'537061726b2053514c'); +---------------------------------------+ |character_length(X'537061726B2053514C')| +---------------------------------------+ | 9| +---------------------------------------+ SELECT CHAR_LENGTH('Feathers '); +-----------------------+ |char_length(Feathers )| +-----------------------+ | 9| +-----------------------+ SELECT CHARACTER_LENGTH('Feathers '); +----------------------------+ |character_length(Feathers )| +----------------------------+ | 9| +----------------------------+ -- chr SELECT chr(65); +-------+ |chr(65)| +-------+ | A| +-------+ -- concat_ws SELECT concat_ws(' ', 'Fea', 'thers'); +------------------------+ |concat_ws( , Fea, thers)| +------------------------+ | Feathers| +------------------------+ SELECT concat_ws('s'); +------------+ |concat_ws(s)| +------------+ | | +------------+ SELECT concat_ws('/', 'foo', null, 'bar'); +----------------------------+ |concat_ws(/, foo, NULL, bar)| +----------------------------+ | foo/bar| +----------------------------+ SELECT concat_ws(null, 'Fea', 'thers'); +---------------------------+ |concat_ws(NULL, Fea, thers)| +---------------------------+ | NULL| +---------------------------+ -- contains SELECT contains('Feathers', 'Fea'); +--------------------------+ |contains(Feathers, Fea)| +--------------------------+ | true| +--------------------------+ SELECT contains('Feathers', 'SQL'); +--------------------------+ |contains(Feathers, SQL)| +--------------------------+ | false| +--------------------------+ SELECT contains('Feathers', null); +-------------------------+ |contains(Feathers, NULL)| +-------------------------+ | NULL| +-------------------------+ SELECT contains(x'537061726b2053514c', x'537061726b'); +----------------------------------------------+ |contains(X'537061726B2053514C', X'537061726B')| +----------------------------------------------+ | true| +----------------------------------------------+ -- decode SELECT decode(encode('abc', 'utf-8'), 'utf-8'); +---------------------------------+ |decode(encode(abc, utf-8), utf-8)| +---------------------------------+ | abc| +---------------------------------+ SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic'); +----------------------------------------------------------------------------------+ |decode(2, 1, Southlake, 2, San Francisco, 3, New Jersey, 4, Seattle, Non domestic)| +----------------------------------------------------------------------------------+ | San Francisco| +----------------------------------------------------------------------------------+ SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic'); +----------------------------------------------------------------------------------+ |decode(6, 1, Southlake, 2, San Francisco, 3, New Jersey, 4, Seattle, Non domestic)| +----------------------------------------------------------------------------------+ | Non domestic| +----------------------------------------------------------------------------------+ SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle'); +--------------------------------------------------------------------+ |decode(6, 1, Southlake, 2, San Francisco, 3, New Jersey, 4, Seattle)| +--------------------------------------------------------------------+ | NULL| +--------------------------------------------------------------------+ SELECT decode(null, 6, 'Fea', NULL, 'thers', 4, 'rock'); +-------------------------------------------+ |decode(NULL, 6, Fea, NULL, thers, 4, rock)| +-------------------------------------------+ | thers| +-------------------------------------------+ -- elt SELECT elt(1, 'scala', 'java'); +-------------------+ |elt(1, scala, java)| +-------------------+ | scala| +-------------------+ SELECT elt(2, 'a', 1); +------------+ |elt(2, a, 1)| +------------+ | 1| +------------+ -- encode SELECT encode('abc', 'utf-8'); +------------------+ |encode(abc, utf-8)| +------------------+ | [61 62 63]| +------------------+ -- endswith SELECT endswith('Feathers', 'ers'); +------------------------+ |endswith(Feathers, ers)| +------------------------+ | true| +------------------------+ SELECT endswith('Feathers', 'SQL'); +--------------------------+ |endswith(Feathers, SQL)| +--------------------------+ | false| +--------------------------+ SELECT endswith('Feathers', null); +-------------------------+ |endswith(Feathers, NULL)| +-------------------------+ | NULL| +-------------------------+ SELECT endswith(x'537061726b2053514c', x'537061726b'); +----------------------------------------------+ |endswith(X'537061726B2053514C', X'537061726B')| +----------------------------------------------+ | false| +----------------------------------------------+ SELECT endswith(x'537061726b2053514c', x'53514c'); +------------------------------------------+ |endswith(X'537061726B2053514C', X'53514C')| +------------------------------------------+ | true| +------------------------------------------+ -- find_in_set SELECT find_in_set('ab','abc,b,ab,c,def'); +-------------------------------+ |find_in_set(ab, abc,b,ab,c,def)| +-------------------------------+ | 3| +-------------------------------+ -- format_number SELECT format_number(12332.123456, 4); +------------------------------+ |format_number(12332.123456, 4)| +------------------------------+ | 12,332.1235| +------------------------------+ SELECT format_number(12332.123456, '##################.###'); +---------------------------------------------------+ |format_number(12332.123456, ##################.###)| +---------------------------------------------------+ | 12332.123| +---------------------------------------------------+ -- format_string SELECT format_string("Hello World %d %s", 100, "days"); +-------------------------------------------+ |format_string(Hello World %d %s, 100, days)| +-------------------------------------------+ | Hello World 100 days| +-------------------------------------------+ -- initcap SELECT initcap('Feathers'); +------------------+ |initcap(Feathers)| +------------------+ | Feathers| +------------------+ -- instr SELECT instr('Feathers', 'ers'); +--------------------+ |instr(Feathers, ers)| +--------------------+ | 6| +--------------------+ -- lcase SELECT lcase('Feathers'); +---------------+ |lcase(Feathers)| +---------------+ | feathers| +---------------+ -- left SELECT left('Feathers', 3); +------------------+ |left(Feathers, 3)| +------------------+ | Fea| +------------------+ SELECT left(encode('Feathers', 'utf-8'), 3); +---------------------------------+ |left(encode(Feathers, utf-8), 3)| +---------------------------------+ | [RmVh]| +---------------------------------+ -- len SELECT len('Feathers '); +---------------+ |len(Feathers )| +---------------+ | 9| +---------------+ SELECT len(x'537061726b2053514c'); +--------------------------+ |len(X'537061726B2053514C')| +--------------------------+ | 9| +--------------------------+ SELECT CHAR_LENGTH('Feathers '); +-----------------------+ |char_length(Feathers )| +-----------------------+ | 9| +-----------------------+ SELECT CHARACTER_LENGTH('Feathers '); +----------------------------+ |character_length(Feathers )| +----------------------------+ | 9| +----------------------------+ -- length SELECT length('Feathers '); +------------------+ |length(Feathers )| +------------------+ | 9| +------------------+ SELECT length(x'537061726b2053514c'); +-----------------------------+ |length(X'537061726B2053514C')| +-----------------------------+ | 9| +-----------------------------+ SELECT CHAR_LENGTH('Feathers '); +-----------------------+ |char_length(Feathers )| +-----------------------+ | 9| +-----------------------+ SELECT CHARACTER_LENGTH('Feathers '); +----------------------------+ |character_length(Feathers )| +----------------------------+ | 9| +----------------------------+ -- levenshtein SELECT levenshtein('kitten', 'sitting'); +----------------------------+ |levenshtein(kitten, sitting)| +----------------------------+ | 3| +----------------------------+ SELECT levenshtein('kitten', 'sitting', 2); +-------------------------------+ |levenshtein(kitten, sitting, 2)| +-------------------------------+ | -1| +-------------------------------+ -- locate SELECT locate('bar', 'foobarbar'); +-------------------------+ |locate(bar, foobarbar, 1)| +-------------------------+ | 4| +-------------------------+ SELECT locate('bar', 'foobarbar', 5); +-------------------------+ |locate(bar, foobarbar, 5)| +-------------------------+ | 7| +-------------------------+ SELECT POSITION('bar' IN 'foobarbar'); +-------------------------+ |locate(bar, foobarbar, 1)| +-------------------------+ | 4| +-------------------------+ -- lower SELECT lower('Feathers'); +---------------+ |lower(Feathers)| +---------------+ | feathers| +---------------+ -- lpad SELECT lpad('hi', 5, '??'); +---------------+ |lpad(hi, 5, ??)| +---------------+ | ???hi| +---------------+ SELECT lpad('hi', 1, '??'); +---------------+ |lpad(hi, 1, ??)| +---------------+ | h| +---------------+ SELECT lpad('hi', 5); +--------------+ |lpad(hi, 5, )| +--------------+ | hi| +--------------+ SELECT hex(lpad(unhex('aabb'), 5)); +--------------------------------+ |hex(lpad(unhex(aabb), 5, X'00'))| +--------------------------------+ | 000000AABB| +--------------------------------+ SELECT hex(lpad(unhex('aabb'), 5, unhex('1122'))); +--------------------------------------+ |hex(lpad(unhex(aabb), 5, unhex(1122)))| +--------------------------------------+ | 112211AABB| +--------------------------------------+ -- ltrim SELECT ltrim(' Feathers '); +----------------------+ |ltrim( Feathers )| +----------------------+ | Feathers | +----------------------+ -- luhn_check SELECT luhn_check('8112189876'); +----------------------+ |luhn_check(8112189876)| +----------------------+ | true| +----------------------+ SELECT luhn_check('79927398713'); +-----------------------+ |luhn_check(79927398713)| +-----------------------+ | true| +-----------------------+ SELECT luhn_check('79927398714'); +-----------------------+ |luhn_check(79927398714)| +-----------------------+ | false| +-----------------------+ -- mask SELECT mask('abcd-EFGH-8765-4321'); +----------------------------------------+ |mask(abcd-EFGH-8765-4321, X, x, n, NULL)| +----------------------------------------+ | xxxx-XXXX-nnnn-nnnn| +----------------------------------------+ SELECT mask('abcd-EFGH-8765-4321', 'Q'); +----------------------------------------+ |mask(abcd-EFGH-8765-4321, Q, x, n, NULL)| +----------------------------------------+ | xxxx-QQQQ-nnnn-nnnn| +----------------------------------------+ SELECT mask('AbCD123-@$#', 'Q', 'q'); +--------------------------------+ |mask(AbCD123-@$#, Q, q, n, NULL)| +--------------------------------+ | QqQQnnn-@$#| +--------------------------------+ SELECT mask('AbCD123-@$#'); +--------------------------------+ |mask(AbCD123-@$#, X, x, n, NULL)| +--------------------------------+ | XxXXnnn-@$#| +--------------------------------+ SELECT mask('AbCD123-@$#', 'Q'); +--------------------------------+ |mask(AbCD123-@$#, Q, x, n, NULL)| +--------------------------------+ | QxQQnnn-@$#| +--------------------------------+ SELECT mask('AbCD123-@$#', 'Q', 'q'); +--------------------------------+ |mask(AbCD123-@$#, Q, q, n, NULL)| +--------------------------------+ | QqQQnnn-@$#| +--------------------------------+ SELECT mask('AbCD123-@$#', 'Q', 'q', 'd'); +--------------------------------+ |mask(AbCD123-@$#, Q, q, d, NULL)| +--------------------------------+ | QqQQddd-@$#| +--------------------------------+ SELECT mask('AbCD123-@$#', 'Q', 'q', 'd', 'o'); +-----------------------------+ |mask(AbCD123-@$#, Q, q, d, o)| +-----------------------------+ | QqQQdddoooo| +-----------------------------+ SELECT mask('AbCD123-@$#', NULL, 'q', 'd', 'o'); +--------------------------------+ |mask(AbCD123-@$#, NULL, q, d, o)| +--------------------------------+ | AqCDdddoooo| +--------------------------------+ SELECT mask('AbCD123-@$#', NULL, NULL, 'd', 'o'); +-----------------------------------+ |mask(AbCD123-@$#, NULL, NULL, d, o)| +-----------------------------------+ | AbCDdddoooo| +-----------------------------------+ SELECT mask('AbCD123-@$#', NULL, NULL, NULL, 'o'); +--------------------------------------+ |mask(AbCD123-@$#, NULL, NULL, NULL, o)| +--------------------------------------+ | AbCD123oooo| +--------------------------------------+ SELECT mask(NULL, NULL, NULL, NULL, 'o'); +-------------------------------+ |mask(NULL, NULL, NULL, NULL, o)| +-------------------------------+ | NULL| +-------------------------------+ SELECT mask(NULL); +-------------------------+ |mask(NULL, X, x, n, NULL)| +-------------------------+ | NULL| +-------------------------+ SELECT mask('AbCD123-@$#', NULL, NULL, NULL, NULL); +-----------------------------------------+ |mask(AbCD123-@$#, NULL, NULL, NULL, NULL)| +-----------------------------------------+ | AbCD123-@$#| +-----------------------------------------+ -- octet_length SELECT octet_length('Feathers'); +-----------------------+ |octet_length(Feathers)| +-----------------------+ | 8| +-----------------------+ SELECT octet_length(x'537061726b2053514c'); +-----------------------------------+ |octet_length(X'537061726B2053514C')| +-----------------------------------+ | 9| +-----------------------------------+ -- overlay SELECT overlay('Feathers' PLACING '_' FROM 6); +----------------------------+ |overlay(Feathers, _, 6, -1)| +----------------------------+ | Feathe_ers| +----------------------------+ SELECT overlay('Feathers' PLACING 'ures' FROM 5); +-------------------------------+ |overlay(Feathers, ures, 5, -1)| +-------------------------------+ | Features | +-------------------------------+ -- position SELECT position('bar', 'foobarbar'); +---------------------------+ |position(bar, foobarbar, 1)| +---------------------------+ | 4| +---------------------------+ SELECT position('bar', 'foobarbar', 5); +---------------------------+ |position(bar, foobarbar, 5)| +---------------------------+ | 7| +---------------------------+ SELECT POSITION('bar' IN 'foobarbar'); +-------------------------+ |locate(bar, foobarbar, 1)| +-------------------------+ | 4| +-------------------------+ -- printf SELECT printf("Hello World %d %s", 100, "days"); +------------------------------------+ |printf(Hello World %d %s, 100, days)| +------------------------------------+ | Hello World 100 days| +------------------------------------+ -- regexp_count SELECT regexp_count('Steven Jones and Stephen Smith are the best players', 'Ste(v|ph)en'); +------------------------------------------------------------------------------+ |regexp_count(Steven Jones and Stephen Smith are the best players, Ste(v|ph)en)| +------------------------------------------------------------------------------+ | 2| +------------------------------------------------------------------------------+ SELECT regexp_count('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}'); +--------------------------------------------------+ |regexp_count(abcdefghijklmnopqrstuvwxyz, [a-z]{3})| +--------------------------------------------------+ | 8| +--------------------------------------------------+ -- regexp_extract SELECT regexp_extract('100-200', '(\\d+)-(\\d+)', 1); +---------------------------------------+ |regexp_extract(100-200, (\d+)-(\d+), 1)| +---------------------------------------+ | 100| +---------------------------------------+ -- regexp_extract_all SELECT regexp_extract_all('100-200, 300-400', '(\\d+)-(\\d+)', 1); +----------------------------------------------------+ |regexp_extract_all(100-200, 300-400, (\d+)-(\d+), 1)| +----------------------------------------------------+ | [100, 300]| +----------------------------------------------------+ -- regexp_instr SELECT regexp_instr('user@opensearch.org', '@[^.]*'); +----------------------------------------------+ |regexp_instr(user@opensearch.org, @[^.]*, 0)| +----------------------------------------------+ | 5| +----------------------------------------------+ -- regexp_replace SELECT regexp_replace('100-200', '(\\d+)', 'num'); +--------------------------------------+ |regexp_replace(100-200, (\d+), num, 1)| +--------------------------------------+ | num-num| +--------------------------------------+ -- regexp_substr SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', 'Ste(v|ph)en'); +-------------------------------------------------------------------------------+ |regexp_substr(Steven Jones and Stephen Smith are the best players, Ste(v|ph)en)| +-------------------------------------------------------------------------------+ | Steven| +-------------------------------------------------------------------------------+ SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', 'Jeck'); +------------------------------------------------------------------------+ |regexp_substr(Steven Jones and Stephen Smith are the best players, Jeck)| +------------------------------------------------------------------------+ | NULL| +------------------------------------------------------------------------+ -- repeat SELECT repeat('123', 2); +--------------+ |repeat(123, 2)| +--------------+ | 123123| +--------------+ -- replace SELECT replace('ABCabc', 'abc', 'DEF'); +-------------------------+ |replace(ABCabc, abc, DEF)| +-------------------------+ | ABCDEF| +-------------------------+ -- right SELECT right('Feathers', 3); +-------------------+ |right(Feathers, 3)| +-------------------+ | ers| +-------------------+ -- rpad SELECT rpad('hi', 5, '??'); +---------------+ |rpad(hi, 5, ??)| +---------------+ | hi???| +---------------+ SELECT rpad('hi', 1, '??'); +---------------+ |rpad(hi, 1, ??)| +---------------+ | h| +---------------+ SELECT rpad('hi', 5); +--------------+ |rpad(hi, 5, )| +--------------+ | hi | +--------------+ SELECT hex(rpad(unhex('aabb'), 5)); +--------------------------------+ |hex(rpad(unhex(aabb), 5, X'00'))| +--------------------------------+ | AABB000000| +--------------------------------+ SELECT hex(rpad(unhex('aabb'), 5, unhex('1122'))); +--------------------------------------+ |hex(rpad(unhex(aabb), 5, unhex(1122)))| +--------------------------------------+ | AABB112211| +--------------------------------------+ -- rtrim SELECT rtrim(' Feathers '); +----------------------+ |rtrim( Feathers )| +----------------------+ | Feathers| +----------------------+ -- sentences SELECT sentences('Hi there! Good morning.'); +--------------------------------------+ |sentences(Hi there! Good morning., , )| +--------------------------------------+ | [[Hi, there], [Go...| +--------------------------------------+ -- soundex SELECT soundex('Miller'); +---------------+ |soundex(Miller)| +---------------+ | M460| +---------------+ -- space SELECT concat(space(2), '1'); +-------------------+ |concat(space(2), 1)| +-------------------+ | 1| +-------------------+ -- split SELECT split('oneAtwoBthreeC', '[ABC]'); +--------------------------------+ |split(oneAtwoBthreeC, [ABC], -1)| +--------------------------------+ | [one, two, three, ]| +--------------------------------+ SELECT split('oneAtwoBthreeC', '[ABC]', -1); +--------------------------------+ |split(oneAtwoBthreeC, [ABC], -1)| +--------------------------------+ | [one, two, three, ]| +--------------------------------+ SELECT split('oneAtwoBthreeC', '[ABC]', 2); +-------------------------------+ |split(oneAtwoBthreeC, [ABC], 2)| +-------------------------------+ | [one, twoBthreeC]| +-------------------------------+ -- split_part SELECT split_part('11.12.13', '.', 3); +--------------------------+ |split_part(11.12.13, ., 3)| +--------------------------+ | 13| +--------------------------+ -- startswith SELECT startswith('Feathers', 'Fea'); +----------------------------+ |startswith(Feathers, Fea)| +----------------------------+ | true| +----------------------------+ SELECT startswith('Feathers', 'SQL'); +--------------------------+ |startswith(Feathers, SQL)| +--------------------------+ | false| +--------------------------+ SELECT startswith('Feathers', null); +---------------------------+ |startswith(Feathers, NULL)| +---------------------------+ | NULL| +---------------------------+ SELECT startswith(x'537061726b2053514c', x'537061726b'); +------------------------------------------------+ |startswith(X'537061726B2053514C', X'537061726B')| +------------------------------------------------+ | true| +------------------------------------------------+ SELECT startswith(x'537061726b2053514c', x'53514c'); +--------------------------------------------+ |startswith(X'537061726B2053514C', X'53514C')| +--------------------------------------------+ | false| +--------------------------------------------+ -- substr SELECT substr('Feathers', 5); +--------------------------------+ |substr(Feathers, 5, 2147483647)| +--------------------------------+ | hers | +--------------------------------+ SELECT substr('Feathers', -3); +---------------------------------+ |substr(Feathers, -3, 2147483647)| +---------------------------------+ | ers| +---------------------------------+ SELECT substr('Feathers', 5, 1); +-----------------------+ |substr(Feathers, 5, 1)| +-----------------------+ | h| +-----------------------+ SELECT substr('Feathers' FROM 5); +-----------------------------------+ |substring(Feathers, 5, 2147483647)| +-----------------------------------+ | hers | +-----------------------------------+ SELECT substr('Feathers' FROM -3); +------------------------------------+ |substring(Feathers, -3, 2147483647)| +------------------------------------+ | ers| +------------------------------------+ SELECT substr('Feathers' FROM 5 FOR 1); +--------------------------+ |substring(Feathers, 5, 1)| +--------------------------+ | h| +--------------------------+ -- substring SELECT substring('Feathers', 5); +-----------------------------------+ |substring(Feathers, 5, 2147483647)| +-----------------------------------+ | hers | +-----------------------------------+ SELECT substring('Feathers', -3); +------------------------------------+ |substring(Feathers, -3, 2147483647)| +------------------------------------+ | ers| +------------------------------------+ SELECT substring('Feathers', 5, 1); +--------------------------+ |substring(Feathers, 5, 1)| +--------------------------+ | h| +--------------------------+ SELECT substring('Feathers' FROM 5); +-----------------------------------+ |substring(Feathers, 5, 2147483647)| +-----------------------------------+ | hers | +-----------------------------------+ SELECT substring('Feathers' FROM -3); +------------------------------------+ |substring(Feathers, -3, 2147483647)| +------------------------------------+ | ers| +------------------------------------+ SELECT substring('Feathers' FROM 5 FOR 1); +--------------------------+ |substring(Feathers, 5, 1)| +--------------------------+ | h| +--------------------------+ -- substring_index SELECT substring_index('www.apache.org', '.', 2); +-------------------------------------+ |substring_index(www.apache.org, ., 2)| +-------------------------------------+ | www.apache| +-------------------------------------+ -- to_binary SELECT to_binary('abc', 'utf-8'); +---------------------+ |to_binary(abc, utf-8)| +---------------------+ | [61 62 63]| +---------------------+ -- to_char SELECT to_char(454, '999'); +-----------------+ |to_char(454, 999)| +-----------------+ | 454| +-----------------+ SELECT to_char(454.00, '000D00'); +-----------------------+ |to_char(454.00, 000D00)| +-----------------------+ | 454.00| +-----------------------+ SELECT to_char(12454, '99G999'); +----------------------+ |to_char(12454, 99G999)| +----------------------+ | 12,454| +----------------------+ SELECT to_char(78.12, '$99.99'); +----------------------+ |to_char(78.12, $99.99)| +----------------------+ | $78.12| +----------------------+ SELECT to_char(-12454.8, '99G999D9S'); +----------------------------+ |to_char(-12454.8, 99G999D9S)| +----------------------------+ | 12,454.8-| +----------------------------+ -- to_number SELECT to_number('454', '999'); +-------------------+ |to_number(454, 999)| +-------------------+ | 454| +-------------------+ SELECT to_number('454.00', '000.00'); +-------------------------+ |to_number(454.00, 000.00)| +-------------------------+ | 454.00| +-------------------------+ SELECT to_number('12,454', '99,999'); +-------------------------+ |to_number(12,454, 99,999)| +-------------------------+ | 12454| +-------------------------+ SELECT to_number('$78.12', '$99.99'); +-------------------------+ |to_number($78.12, $99.99)| +-------------------------+ | 78.12| +-------------------------+ SELECT to_number('12,454.8-', '99,999.9S'); +-------------------------------+ |to_number(12,454.8-, 99,999.9S)| +-------------------------------+ | -12454.8| +-------------------------------+ -- to_varchar SELECT to_varchar(454, '999'); +-----------------+ |to_char(454, 999)| +-----------------+ | 454| +-----------------+ SELECT to_varchar(454.00, '000D00'); +-----------------------+ |to_char(454.00, 000D00)| +-----------------------+ | 454.00| +-----------------------+ SELECT to_varchar(12454, '99G999'); +----------------------+ |to_char(12454, 99G999)| +----------------------+ | 12,454| +----------------------+ SELECT to_varchar(78.12, '$99.99'); +----------------------+ |to_char(78.12, $99.99)| +----------------------+ | $78.12| +----------------------+ SELECT to_varchar(-12454.8, '99G999D9S'); +----------------------------+ |to_char(-12454.8, 99G999D9S)| +----------------------------+ | 12,454.8-| +----------------------------+ -- translate SELECT translate('AaBbCc', 'abc', '123'); +---------------------------+ |translate(AaBbCc, abc, 123)| +---------------------------+ | A1B2C3| +---------------------------+ -- try_to_binary SELECT try_to_binary('abc', 'utf-8'); +-------------------------+ |try_to_binary(abc, utf-8)| +-------------------------+ | [61 62 63]| +-------------------------+ select try_to_binary('a!', 'base64'); +-------------------------+ |try_to_binary(a!, base64)| +-------------------------+ | NULL| +-------------------------+ select try_to_binary('abc', 'invalidFormat'); +---------------------------------+ |try_to_binary(abc, invalidFormat)| +---------------------------------+ | NULL| +---------------------------------+ -- try_to_number SELECT try_to_number('454', '999'); +-----------------------+ |try_to_number(454, 999)| +-----------------------+ | 454| +-----------------------+ SELECT try_to_number('454.00', '000.00'); +-----------------------------+ |try_to_number(454.00, 000.00)| +-----------------------------+ | 454.00| +-----------------------------+ SELECT try_to_number('12,454', '99,999'); +-----------------------------+ |try_to_number(12,454, 99,999)| +-----------------------------+ | 12454| +-----------------------------+ SELECT try_to_number('$78.12', '$99.99'); +-----------------------------+ |try_to_number($78.12, $99.99)| +-----------------------------+ | 78.12| +-----------------------------+ SELECT try_to_number('12,454.8-', '99,999.9S'); +-----------------------------------+ |try_to_number(12,454.8-, 99,999.9S)| +-----------------------------------+ | -12454.8| +-----------------------------------+ -- ucase SELECT ucase('Feathers'); +---------------+ |ucase(Feathers)| +---------------+ | FEATHERS| +---------------+ -- unbase64 SELECT unbase64('U3BhcmsgU1FM'); +----------------------+ |unbase64(U3BhcmsgU1FM)| +----------------------+ | [53 70 61 72 6B 2...| +----------------------+ -- upper SELECT upper('Feathers'); +---------------+ |upper(Feathers)| +---------------+ | FEATHERS| +---------------+ ``` #### 날짜 및 시간 함수 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). **** | 함수 | 설명 | | --- | --- | | add\$1months(start\$1date, num\$1months) | start\$1date로부터 num\$1months 후 날짜를 반환합니다. | | convert\$1timezone([sourceTz, ]targetTz, sourceTs) | 시간대가 없는 타임스탬프 sourceTz를 시간대 sourceTs에서 targetTz로 변환합니다. | | curdate() | 쿼리 평가 시작 시 현재 날짜를 반환합니다. 동일한 쿼리 내의 모든 curdate 호출은 동일한 값을 반환합니다. | | current\$1date() | 쿼리 평가 시작 시 현재 날짜를 반환합니다. 동일한 쿼리 내의 모든 current\$1date 호출은 동일한 값을 반환합니다. | | current\$1date | 쿼리 평가 시작 시 현재 날짜를 반환합니다. | | current\$1timestamp() | 쿼리 평가 시작 시 현재 타임스탬프를 반환합니다. 동일한 쿼리 내의 모든 current\$1timestamp 호출은 동일한 값을 반환합니다. | | current\$1timestamp | 쿼리 평가 시작 시 현재 타임스탬프를 반환합니다. | | current\$1timezone() | 현재 세션의 현지 시간대를 반환합니다. | | date\$1add(start\$1date, num\$1days) | start\$1date로부터 num\$1days 후 날짜를 반환합니다. | | date\$1diff(endDate, startDate) | startDate에서 endDate까지의 일수를 반환합니다. | | date\$1format(timestamp, fmt) | 날짜 형식 fmt로 지정된 형식의 문자열 값으로 timestamp를 변환합니다. | | date\$1from\$1unix\$1date(days) | 1970-01-01 이후 일수에서 날짜를 생성합니다. | | date\$1part(field, source) | 날짜/타임스탬프 또는 간격 소스의 일부를 추출합니다. | | date\$1sub(start\$1date, num\$1days) | start\$1date로부터 num\$1days 전 날짜를 반환합니다. | | date\$1trunc(fmt, ts) | 형식 모델 fmt에서 지정한 단위로 잘린 타임스탬프 ts를 반환합니다. | | dateadd(start\$1date, num\$1days) | start\$1date로부터 num\$1days 후 날짜를 반환합니다. | | datediff(endDate, startDate) | startDate에서 endDate까지의 일수를 반환합니다. | | datepart(field, source) | 날짜/타임스탬프 또는 간격 소스의 일부를 추출합니다. | | day(date) | 날짜/타임스탬프의 요일을 반환합니다. | | dayofmonth(date) | 날짜/타임스탬프의 요일을 반환합니다. | | dayofweek(date) | 날짜/타임스탬프의 요일을 반환합니다(1 = 일요일, 2 = 월요일, ..., 7 = 토요일). | | dayofyear(date) | 날짜/타임스탬프의 날짜를 반환합니다. | | extract(field FROM source) | 날짜/타임스탬프 또는 간격 소스의 일부를 추출합니다. | | from\$1unixtime(unix\$1time[, fmt]) | 지정된 fmt에서 unix\$1time을 반환합니다. | | from\$1utc\$1timestamp(timestamp, timezone) | '2017-07-14 02:40:00.0'과 같은 타임스탬프가 주어지면, 이를 UTC의 시간으로 해석하고 해당 시간을 지정된 시간대의 타임스탬프로 렌더링합니다. 예를 들어 'GMT\$11'은 '2017-07-14 03:40:00.0'을 생성합니다. | | hour(timestamp) | 문자열/타임스탬프의 시간 구성 요소를 반환합니다. | | last\$1day(date) | 날짜가 속한 달의 마지막 날을 반환합니다. | | localtimestamp() | 쿼리 평가 시작 시 시간대가 없는 현재 타임스탬프를 반환합니다. 동일한 쿼리 내의 모든 localtimestamp 호출은 동일한 값을 반환합니다. | | localtimestamp | 쿼리 평가 시작 시 세션 시간대의 현재 로컬 날짜-시간을 반환합니다. | | make\$1date(year, month, day) | 연도, 월 및 일 필드에서 날짜를 생성합니다. | | make\$1dt\$1interval([days[, hours[, mins[, secs]]]]) | 일, 시간, 분 및 초에서 DayTimeIntervalType 기간을 만듭니다. | | make\$1interval([years[, months[, weeks[, days[, hours[, mins[, secs]]]]]]]) | 년, 월, 주, 일, 시간, 분 및 초에서 간격을 만듭니다. | | make\$1timestamp(year, month, day, hour, min, sec[, timezone]) | 연도, 월, 일, 시간, 분, 초 및 시간대 필드에서 타임스탬프를 생성합니다. | | make\$1timestamp\$1ltz(year, month, day, hour, min, sec[, timezone]) | 연도, 월, 일, 시간, 분, 초 및 시간대 필드의 현지 시간대로 현재 타임스탬프를 생성합니다. | | make\$1timestamp\$1ntz(year, month, day, hour, min, sec) | 년, 월, 일, 시간, 분, 초 필드에서 로컬 날짜-시간을 생성합니다. | | make\$1ym\$1interval([years[, months]]) | 년, 월에서 년-월 간격을 만듭니다. | | minute(timestamp) | 문자열/타임스탬프의 분 구성 요소를 반환합니다. | | month(date) | 날짜/타임스탬프의 월 구성 요소를 반환합니다. | | months\$1between(timestamp1, timestamp2[, roundOff]) | timestamp1이 timestamp2보다 이후인 경우 결과는 양수입니다. timestamp1 및 timestamp2가 같은 요일이거나 둘 다 마지막 요일인 경우 시간대는 무시됩니다. 그렇지 않으면 차이는 매월 31일을 기준으로 계산되며 roundOff=false가 아니면 8자리로 반올림됩니다. | | next\$1day(start\$1date, day\$1of\$1week) | 표시된 대로 start\$1date 이후이고 이름이 지정된 첫 번째 날짜를 반환합니다. 입력 파라미터 중 하나 이상이 NULL인 경우 함수는 NULL을 반환합니다. | | now() | 쿼리 평가 시작 시 현재 타임스탬프를 반환합니다. | | quarter(date) | 날짜의 분기를 1\$14 범위로 반환합니다. | | second(timestamp) | 문자열/타임스탬프의 초 구성 요소를 반환합니다. | | session\$1window(time\$1column, gap\$1duration) | 열 및 간격 기간을 지정하는 타임스탬프가 지정된 세션 윈도우를 생성합니다. 자세한 설명과 예는 구조화 스트리밍 가이드 문서의 '시간 범위 유형'을 참조하세요. | | timestamp\$1micros(microseconds) | UTC 에포크 이후 마이크로초 수에서 타임스탬프를 생성합니다. | | timestamp\$1millis(milliseconds) | UTC 에포크 이후 밀리초 수에서 타임스탬프를 생성합니다. | | timestamp\$1seconds(seconds) | UTC 에포크 이후 초(분수일 수 있음)에서 타임스탬프를 생성합니다. | | to\$1date(date\$1str[, fmt]) | date\$1str 표현식이 포함된 fmt 표현식을 날짜로 구문 분석합니다. 잘못된 입력 시 null을 반환합니다. 기본적으로 fmt가 생략된 경우 캐스팅 규칙을 따라 날짜를 지정합니다. | | to\$1timestamp(timestamp\$1str[, fmt]) | timestamp\$1str 표현식이 포함된 fmt 표현식을 타임스탬프로 구문 분석합니다. 잘못된 입력 시 null을 반환합니다. 기본적으로 fmt가 생략된 경우 캐스팅 규칙을 따라 타임스탬프를 지정합니다. | | to\$1timestamp\$1ltz(timestamp\$1str[, fmt]) | timestamp\$1str 표현식이 있는 fmt 표현식을 현지 시간대가 있는 타임스탬프로 구문 분석합니다. 잘못된 입력 시 null을 반환합니다. 기본적으로 fmt가 생략된 경우 캐스팅 규칙을 따라 타임스탬프를 지정합니다. | | to\$1timestamp\$1ntz(timestamp\$1str[, fmt]) | timestamp\$1str 표현식이 있는 fmt 표현식을 시간대가 없는 타임스탬프로 구문 분석합니다. 잘못된 입력 시 null을 반환합니다. 기본적으로 fmt가 생략된 경우 캐스팅 규칙을 따라 타임스탬프를 지정합니다. | | to\$1unix\$1timestamp(timeExp[, fmt]) | 지정된 시간의 UNIX 타임스탬프를 반환합니다. | | to\$1utc\$1timestamp(timestamp, timezone) | '2017-07-14 02:40:00.0'과 같은 타임스탬프가 주어지면, 이를 지정된 시간대의 시간으로 해석하고 해당 시간을 UTC의 타임스탬프로 렌더링합니다. 예를 들어 'GMT\$11'은 '2017-07-14 01:40:00.0'을 생성합니다. | | trunc(date, fmt) | 형식 모델 fmt에서 지정한 단위로 잘린 날짜의 시간 부분이 있는 date를 반환합니다. | | try\$1to\$1timestamp(timestamp\$1str[, fmt]) | timestamp\$1str 표현식이 포함된 fmt 표현식을 타임스탬프로 구문 분석합니다. | | unix\$1date(date) | 1970-01-01 이후 일수를 반환합니다. | | unix\$1micros(timestamp) | 1970-01-01 00:00:00 UTC 이후 마이크로초 수를 반환합니다. | | unix\$1millis(timestamp) | 1970-01-01 00:00:00 UTC 이후 밀리초 수를 반환합니다. 더 높은 수준의 정밀도를 자릅니다. | | unix\$1seconds(timestamp) | 1970-01-01 00:00:00 UTC 이후의 초 수를 반환합니다. 더 높은 수준의 정밀도를 자릅니다. | | unix\$1timestamp([timeExp[, fmt]]) | 현재 또는 지정된 시간의 UNIX 타임스탬프를 반환합니다. | | weekday(date) | 날짜/타임스탬프의 요일을 반환합니다(0 = 월요일, 1 = 화요일, ..., 6 = 일요일). | | weekofyear(date) | 지정된 날짜가 그 해 몇 주차인지 반환합니다. 한 주는 월요일에 시작하며, 1주는 3일을 초과하는 날이 포함된 첫 번째 주로 간주됩니다. | | window(time\$1column, window\$1duration[, slide\$1duration[, start\$1time]]) | 열을 지정하는 타임스탬프가 주어지면 행을 하나 이상의 윈도우로 버킷화합니다. 윈도우의 시작은 포함되지만 윈도우의 끝은 제외됩니다. 예를 들어 12:05는 [12:05,12:10) 기간에는 있지만 [12:00,12:05)에는 없습니다. 윈도우는 마이크로초 정밀도를 지원할 수 있습니다. 월 단위의 윈도우는 지원되지 않습니다. 자세한 설명과 예는 구조화 스트리밍 가이드 문서의 '이벤트 시간에 대한 윈도우 작업'을 참조하세요. | | window\$1time(window\$1column) | 윈도우의 이벤트 시간 값에 사용할 수 있는 시간/세션 기간 열에서 윈도우 값을 추출합니다. 추출된 시간은 (window.end - 1)이며, 이는 집계 윈도우에 배타적인 구간, 즉 [start, end)가 있다는 사실을 반영합니다. 자세한 설명과 예는 구조화 스트리밍 가이드 문서의 '이벤트 시간에 대한 윈도우 작업'을 참조하세요. | | year(date) | 날짜/타임스탬프의 연도 구성 요소를 반환합니다. | **예시** ``` -- add_months SELECT add_months('2016-08-31', 1); +-------------------------+ |add_months(2016-08-31, 1)| +-------------------------+ | 2016-09-30| +-------------------------+ -- convert_timezone SELECT convert_timezone('Europe/Brussels', 'America/Los_Angeles', timestamp_ntz'2021-12-06 00:00:00'); +-------------------------------------------------------------------------------------------+ |convert_timezone(Europe/Brussels, America/Los_Angeles, TIMESTAMP_NTZ '2021-12-06 00:00:00')| +-------------------------------------------------------------------------------------------+ | 2021-12-05 15:00:00| +-------------------------------------------------------------------------------------------+ SELECT convert_timezone('Europe/Brussels', timestamp_ntz'2021-12-05 15:00:00'); +------------------------------------------------------------------------------------------+ |convert_timezone(current_timezone(), Europe/Brussels, TIMESTAMP_NTZ '2021-12-05 15:00:00')| +------------------------------------------------------------------------------------------+ | 2021-12-05 07:00:00| +------------------------------------------------------------------------------------------+ -- curdate SELECT curdate(); +--------------+ |current_date()| +--------------+ | 2024-02-24| +--------------+ -- current_date SELECT current_date(); +--------------+ |current_date()| +--------------+ | 2024-02-24| +--------------+ SELECT current_date; +--------------+ |current_date()| +--------------+ | 2024-02-24| +--------------+ -- current_timestamp SELECT current_timestamp(); +--------------------+ | current_timestamp()| +--------------------+ |2024-02-24 16:36:...| +--------------------+ SELECT current_timestamp; +--------------------+ | current_timestamp()| +--------------------+ |2024-02-24 16:36:...| +--------------------+ -- current_timezone SELECT current_timezone(); +------------------+ |current_timezone()| +------------------+ | Asia/Seoul| +------------------+ -- date_add SELECT date_add('2016-07-30', 1); +-----------------------+ |date_add(2016-07-30, 1)| +-----------------------+ | 2016-07-31| +-----------------------+ -- date_diff SELECT date_diff('2009-07-31', '2009-07-30'); +---------------------------------+ |date_diff(2009-07-31, 2009-07-30)| +---------------------------------+ | 1| +---------------------------------+ SELECT date_diff('2009-07-30', '2009-07-31'); +---------------------------------+ |date_diff(2009-07-30, 2009-07-31)| +---------------------------------+ | -1| +---------------------------------+ -- date_format SELECT date_format('2016-04-08', 'y'); +--------------------------+ |date_format(2016-04-08, y)| +--------------------------+ | 2016| +--------------------------+ -- date_from_unix_date SELECT date_from_unix_date(1); +----------------------+ |date_from_unix_date(1)| +----------------------+ | 1970-01-02| +----------------------+ -- date_part SELECT date_part('YEAR', TIMESTAMP '2019-08-12 01:00:00.123456'); +-------------------------------------------------------+ |date_part(YEAR, TIMESTAMP '2019-08-12 01:00:00.123456')| +-------------------------------------------------------+ | 2019| +-------------------------------------------------------+ SELECT date_part('week', timestamp'2019-08-12 01:00:00.123456'); +-------------------------------------------------------+ |date_part(week, TIMESTAMP '2019-08-12 01:00:00.123456')| +-------------------------------------------------------+ | 33| +-------------------------------------------------------+ SELECT date_part('doy', DATE'2019-08-12'); +---------------------------------+ |date_part(doy, DATE '2019-08-12')| +---------------------------------+ | 224| +---------------------------------+ SELECT date_part('SECONDS', timestamp'2019-10-01 00:00:01.000001'); +----------------------------------------------------------+ |date_part(SECONDS, TIMESTAMP '2019-10-01 00:00:01.000001')| +----------------------------------------------------------+ | 1.000001| +----------------------------------------------------------+ SELECT date_part('days', interval 5 days 3 hours 7 minutes); +-------------------------------------------------+ |date_part(days, INTERVAL '5 03:07' DAY TO MINUTE)| +-------------------------------------------------+ | 5| +-------------------------------------------------+ SELECT date_part('seconds', interval 5 hours 30 seconds 1 milliseconds 1 microseconds); +-------------------------------------------------------------+ |date_part(seconds, INTERVAL '05:00:30.001001' HOUR TO SECOND)| +-------------------------------------------------------------+ | 30.001001| +-------------------------------------------------------------+ SELECT date_part('MONTH', INTERVAL '2021-11' YEAR TO MONTH); +--------------------------------------------------+ |date_part(MONTH, INTERVAL '2021-11' YEAR TO MONTH)| +--------------------------------------------------+ | 11| +--------------------------------------------------+ SELECT date_part('MINUTE', INTERVAL '123 23:55:59.002001' DAY TO SECOND); +---------------------------------------------------------------+ |date_part(MINUTE, INTERVAL '123 23:55:59.002001' DAY TO SECOND)| +---------------------------------------------------------------+ | 55| +---------------------------------------------------------------+ -- date_sub SELECT date_sub('2016-07-30', 1); +-----------------------+ |date_sub(2016-07-30, 1)| +-----------------------+ | 2016-07-29| +-----------------------+ -- date_trunc SELECT date_trunc('YEAR', '2015-03-05T09:32:05.359'); +-----------------------------------------+ |date_trunc(YEAR, 2015-03-05T09:32:05.359)| +-----------------------------------------+ | 2015-01-01 00:00:00| +-----------------------------------------+ SELECT date_trunc('MM', '2015-03-05T09:32:05.359'); +---------------------------------------+ |date_trunc(MM, 2015-03-05T09:32:05.359)| +---------------------------------------+ | 2015-03-01 00:00:00| +---------------------------------------+ SELECT date_trunc('DD', '2015-03-05T09:32:05.359'); +---------------------------------------+ |date_trunc(DD, 2015-03-05T09:32:05.359)| +---------------------------------------+ | 2015-03-05 00:00:00| +---------------------------------------+ SELECT date_trunc('HOUR', '2015-03-05T09:32:05.359'); +-----------------------------------------+ |date_trunc(HOUR, 2015-03-05T09:32:05.359)| +-----------------------------------------+ | 2015-03-05 09:00:00| +-----------------------------------------+ SELECT date_trunc('MILLISECOND', '2015-03-05T09:32:05.123456'); +---------------------------------------------------+ |date_trunc(MILLISECOND, 2015-03-05T09:32:05.123456)| +---------------------------------------------------+ | 2015-03-05 09:32:...| +---------------------------------------------------+ -- dateadd SELECT dateadd('2016-07-30', 1); +-----------------------+ |date_add(2016-07-30, 1)| +-----------------------+ | 2016-07-31| +-----------------------+ -- datediff SELECT datediff('2009-07-31', '2009-07-30'); +--------------------------------+ |datediff(2009-07-31, 2009-07-30)| +--------------------------------+ | 1| +--------------------------------+ SELECT datediff('2009-07-30', '2009-07-31'); +--------------------------------+ |datediff(2009-07-30, 2009-07-31)| +--------------------------------+ | -1| +--------------------------------+ -- datepart SELECT datepart('YEAR', TIMESTAMP '2019-08-12 01:00:00.123456'); +----------------------------------------------------------+ |datepart(YEAR FROM TIMESTAMP '2019-08-12 01:00:00.123456')| +----------------------------------------------------------+ | 2019| +----------------------------------------------------------+ SELECT datepart('week', timestamp'2019-08-12 01:00:00.123456'); +----------------------------------------------------------+ |datepart(week FROM TIMESTAMP '2019-08-12 01:00:00.123456')| +----------------------------------------------------------+ | 33| +----------------------------------------------------------+ SELECT datepart('doy', DATE'2019-08-12'); +------------------------------------+ |datepart(doy FROM DATE '2019-08-12')| +------------------------------------+ | 224| +------------------------------------+ SELECT datepart('SECONDS', timestamp'2019-10-01 00:00:01.000001'); +-------------------------------------------------------------+ |datepart(SECONDS FROM TIMESTAMP '2019-10-01 00:00:01.000001')| +-------------------------------------------------------------+ | 1.000001| +-------------------------------------------------------------+ SELECT datepart('days', interval 5 days 3 hours 7 minutes); +----------------------------------------------------+ |datepart(days FROM INTERVAL '5 03:07' DAY TO MINUTE)| +----------------------------------------------------+ | 5| +----------------------------------------------------+ SELECT datepart('seconds', interval 5 hours 30 seconds 1 milliseconds 1 microseconds); +----------------------------------------------------------------+ |datepart(seconds FROM INTERVAL '05:00:30.001001' HOUR TO SECOND)| +----------------------------------------------------------------+ | 30.001001| +----------------------------------------------------------------+ SELECT datepart('MONTH', INTERVAL '2021-11' YEAR TO MONTH); +-----------------------------------------------------+ |datepart(MONTH FROM INTERVAL '2021-11' YEAR TO MONTH)| +-----------------------------------------------------+ | 11| +-----------------------------------------------------+ SELECT datepart('MINUTE', INTERVAL '123 23:55:59.002001' DAY TO SECOND); +------------------------------------------------------------------+ |datepart(MINUTE FROM INTERVAL '123 23:55:59.002001' DAY TO SECOND)| +------------------------------------------------------------------+ | 55| +------------------------------------------------------------------+ -- day SELECT day('2009-07-30'); +---------------+ |day(2009-07-30)| +---------------+ | 30| +---------------+ -- dayofmonth SELECT dayofmonth('2009-07-30'); +----------------------+ |dayofmonth(2009-07-30)| +----------------------+ | 30| +----------------------+ -- dayofweek SELECT dayofweek('2009-07-30'); +---------------------+ |dayofweek(2009-07-30)| +---------------------+ | 5| +---------------------+ -- dayofyear SELECT dayofyear('2016-04-09'); +---------------------+ |dayofyear(2016-04-09)| +---------------------+ | 100| +---------------------+ -- extract SELECT extract(YEAR FROM TIMESTAMP '2019-08-12 01:00:00.123456'); +---------------------------------------------------------+ |extract(YEAR FROM TIMESTAMP '2019-08-12 01:00:00.123456')| +---------------------------------------------------------+ | 2019| +---------------------------------------------------------+ SELECT extract(week FROM timestamp'2019-08-12 01:00:00.123456'); +---------------------------------------------------------+ |extract(week FROM TIMESTAMP '2019-08-12 01:00:00.123456')| +---------------------------------------------------------+ | 33| +---------------------------------------------------------+ SELECT extract(doy FROM DATE'2019-08-12'); +-----------------------------------+ |extract(doy FROM DATE '2019-08-12')| +-----------------------------------+ | 224| +-----------------------------------+ SELECT extract(SECONDS FROM timestamp'2019-10-01 00:00:01.000001'); +------------------------------------------------------------+ |extract(SECONDS FROM TIMESTAMP '2019-10-01 00:00:01.000001')| +------------------------------------------------------------+ | 1.000001| +------------------------------------------------------------+ SELECT extract(days FROM interval 5 days 3 hours 7 minutes); +---------------------------------------------------+ |extract(days FROM INTERVAL '5 03:07' DAY TO MINUTE)| +---------------------------------------------------+ | 5| +---------------------------------------------------+ SELECT extract(seconds FROM interval 5 hours 30 seconds 1 milliseconds 1 microseconds); +---------------------------------------------------------------+ |extract(seconds FROM INTERVAL '05:00:30.001001' HOUR TO SECOND)| +---------------------------------------------------------------+ | 30.001001| +---------------------------------------------------------------+ SELECT extract(MONTH FROM INTERVAL '2021-11' YEAR TO MONTH); +----------------------------------------------------+ |extract(MONTH FROM INTERVAL '2021-11' YEAR TO MONTH)| +----------------------------------------------------+ | 11| +----------------------------------------------------+ SELECT extract(MINUTE FROM INTERVAL '123 23:55:59.002001' DAY TO SECOND); +-----------------------------------------------------------------+ |extract(MINUTE FROM INTERVAL '123 23:55:59.002001' DAY TO SECOND)| +-----------------------------------------------------------------+ | 55| +-----------------------------------------------------------------+ -- from_unixtime SELECT from_unixtime(0, 'yyyy-MM-dd HH:mm:ss'); +-------------------------------------+ |from_unixtime(0, yyyy-MM-dd HH:mm:ss)| +-------------------------------------+ | 1970-01-01 09:00:00| +-------------------------------------+ SELECT from_unixtime(0); +-------------------------------------+ |from_unixtime(0, yyyy-MM-dd HH:mm:ss)| +-------------------------------------+ | 1970-01-01 09:00:00| +-------------------------------------+ -- from_utc_timestamp SELECT from_utc_timestamp('2016-08-31', 'Asia/Seoul'); +------------------------------------------+ |from_utc_timestamp(2016-08-31, Asia/Seoul)| +------------------------------------------+ | 2016-08-31 09:00:00| +------------------------------------------+ -- hour SELECT hour('2009-07-30 12:58:59'); +-------------------------+ |hour(2009-07-30 12:58:59)| +-------------------------+ | 12| +-------------------------+ -- last_day SELECT last_day('2009-01-12'); +--------------------+ |last_day(2009-01-12)| +--------------------+ | 2009-01-31| +--------------------+ -- localtimestamp SELECT localtimestamp(); +--------------------+ | localtimestamp()| +--------------------+ |2024-02-24 16:36:...| +--------------------+ -- make_date SELECT make_date(2013, 7, 15); +----------------------+ |make_date(2013, 7, 15)| +----------------------+ | 2013-07-15| +----------------------+ SELECT make_date(2019, 7, NULL); +------------------------+ |make_date(2019, 7, NULL)| +------------------------+ | NULL| +------------------------+ -- make_dt_interval SELECT make_dt_interval(1, 12, 30, 01.001001); +-------------------------------------+ |make_dt_interval(1, 12, 30, 1.001001)| +-------------------------------------+ | INTERVAL '1 12:30...| +-------------------------------------+ SELECT make_dt_interval(2); +-----------------------------------+ |make_dt_interval(2, 0, 0, 0.000000)| +-----------------------------------+ | INTERVAL '2 00:00...| +-----------------------------------+ SELECT make_dt_interval(100, null, 3); +----------------------------------------+ |make_dt_interval(100, NULL, 3, 0.000000)| +----------------------------------------+ | NULL| +----------------------------------------+ -- make_interval SELECT make_interval(100, 11, 1, 1, 12, 30, 01.001001); +----------------------------------------------+ |make_interval(100, 11, 1, 1, 12, 30, 1.001001)| +----------------------------------------------+ | 100 years 11 mont...| +----------------------------------------------+ SELECT make_interval(100, null, 3); +----------------------------------------------+ |make_interval(100, NULL, 3, 0, 0, 0, 0.000000)| +----------------------------------------------+ | NULL| +----------------------------------------------+ SELECT make_interval(0, 1, 0, 1, 0, 0, 100.000001); +-------------------------------------------+ |make_interval(0, 1, 0, 1, 0, 0, 100.000001)| +-------------------------------------------+ | 1 months 1 days 1...| +-------------------------------------------+ -- make_timestamp SELECT make_timestamp(2014, 12, 28, 6, 30, 45.887); +-------------------------------------------+ |make_timestamp(2014, 12, 28, 6, 30, 45.887)| +-------------------------------------------+ | 2014-12-28 06:30:...| +-------------------------------------------+ SELECT make_timestamp(2014, 12, 28, 6, 30, 45.887, 'CET'); +------------------------------------------------+ |make_timestamp(2014, 12, 28, 6, 30, 45.887, CET)| +------------------------------------------------+ | 2014-12-28 14:30:...| +------------------------------------------------+ SELECT make_timestamp(2019, 6, 30, 23, 59, 60); +---------------------------------------+ |make_timestamp(2019, 6, 30, 23, 59, 60)| +---------------------------------------+ | 2019-07-01 00:00:00| +---------------------------------------+ SELECT make_timestamp(2019, 6, 30, 23, 59, 1); +--------------------------------------+ |make_timestamp(2019, 6, 30, 23, 59, 1)| +--------------------------------------+ | 2019-06-30 23:59:01| +--------------------------------------+ SELECT make_timestamp(null, 7, 22, 15, 30, 0); +--------------------------------------+ |make_timestamp(NULL, 7, 22, 15, 30, 0)| +--------------------------------------+ | NULL| +--------------------------------------+ -- make_timestamp_ltz SELECT make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887); +-----------------------------------------------+ |make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887)| +-----------------------------------------------+ | 2014-12-28 06:30:...| +-----------------------------------------------+ SELECT make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887, 'CET'); +----------------------------------------------------+ |make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887, CET)| +----------------------------------------------------+ | 2014-12-28 14:30:...| +----------------------------------------------------+ SELECT make_timestamp_ltz(2019, 6, 30, 23, 59, 60); +-------------------------------------------+ |make_timestamp_ltz(2019, 6, 30, 23, 59, 60)| +-------------------------------------------+ | 2019-07-01 00:00:00| +-------------------------------------------+ SELECT make_timestamp_ltz(null, 7, 22, 15, 30, 0); +------------------------------------------+ |make_timestamp_ltz(NULL, 7, 22, 15, 30, 0)| +------------------------------------------+ | NULL| +------------------------------------------+ -- make_timestamp_ntz SELECT make_timestamp_ntz(2014, 12, 28, 6, 30, 45.887); +-----------------------------------------------+ |make_timestamp_ntz(2014, 12, 28, 6, 30, 45.887)| +-----------------------------------------------+ | 2014-12-28 06:30:...| +-----------------------------------------------+ SELECT make_timestamp_ntz(2019, 6, 30, 23, 59, 60); +-------------------------------------------+ |make_timestamp_ntz(2019, 6, 30, 23, 59, 60)| +-------------------------------------------+ | 2019-07-01 00:00:00| +-------------------------------------------+ SELECT make_timestamp_ntz(null, 7, 22, 15, 30, 0); +------------------------------------------+ |make_timestamp_ntz(NULL, 7, 22, 15, 30, 0)| +------------------------------------------+ | NULL| +------------------------------------------+ -- make_ym_interval SELECT make_ym_interval(1, 2); +----------------------+ |make_ym_interval(1, 2)| +----------------------+ | INTERVAL '1-2' YE...| +----------------------+ SELECT make_ym_interval(1, 0); +----------------------+ |make_ym_interval(1, 0)| +----------------------+ | INTERVAL '1-0' YE...| +----------------------+ SELECT make_ym_interval(-1, 1); +-----------------------+ |make_ym_interval(-1, 1)| +-----------------------+ | INTERVAL '-0-11' ...| +-----------------------+ SELECT make_ym_interval(2); +----------------------+ |make_ym_interval(2, 0)| +----------------------+ | INTERVAL '2-0' YE...| +----------------------+ -- minute SELECT minute('2009-07-30 12:58:59'); +---------------------------+ |minute(2009-07-30 12:58:59)| +---------------------------+ | 58| +---------------------------+ -- month SELECT month('2016-07-30'); +-----------------+ |month(2016-07-30)| +-----------------+ | 7| +-----------------+ -- months_between SELECT months_between('1997-02-28 10:30:00', '1996-10-30'); +-----------------------------------------------------+ |months_between(1997-02-28 10:30:00, 1996-10-30, true)| +-----------------------------------------------------+ | 3.94959677| +-----------------------------------------------------+ SELECT months_between('1997-02-28 10:30:00', '1996-10-30', false); +------------------------------------------------------+ |months_between(1997-02-28 10:30:00, 1996-10-30, false)| +------------------------------------------------------+ | 3.9495967741935485| +------------------------------------------------------+ -- next_day SELECT next_day('2015-01-14', 'TU'); +------------------------+ |next_day(2015-01-14, TU)| +------------------------+ | 2015-01-20| +------------------------+ -- now SELECT now(); +--------------------+ | now()| +--------------------+ |2024-02-24 16:36:...| +--------------------+ -- quarter SELECT quarter('2016-08-31'); +-------------------+ |quarter(2016-08-31)| +-------------------+ | 3| +-------------------+ -- second SELECT second('2009-07-30 12:58:59'); +---------------------------+ |second(2009-07-30 12:58:59)| +---------------------------+ | 59| +---------------------------+ -- session_window SELECT a, session_window.start, session_window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:10:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, session_window(b, '5 minutes') ORDER BY a, start; +---+-------------------+-------------------+---+ | a| start| end|cnt| +---+-------------------+-------------------+---+ | A1|2021-01-01 00:00:00|2021-01-01 00:09:30| 2| | A1|2021-01-01 00:10:00|2021-01-01 00:15:00| 1| | A2|2021-01-01 00:01:00|2021-01-01 00:06:00| 1| +---+-------------------+-------------------+---+ SELECT a, session_window.start, session_window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:10:00'), ('A2', '2021-01-01 00:01:00'), ('A2', '2021-01-01 00:04:30') AS tab(a, b) GROUP by a, session_window(b, CASE WHEN a = 'A1' THEN '5 minutes' WHEN a = 'A2' THEN '1 minute' ELSE '10 minutes' END) ORDER BY a, start; +---+-------------------+-------------------+---+ | a| start| end|cnt| +---+-------------------+-------------------+---+ | A1|2021-01-01 00:00:00|2021-01-01 00:09:30| 2| | A1|2021-01-01 00:10:00|2021-01-01 00:15:00| 1| | A2|2021-01-01 00:01:00|2021-01-01 00:02:00| 1| | A2|2021-01-01 00:04:30|2021-01-01 00:05:30| 1| +---+-------------------+-------------------+---+ -- timestamp_micros SELECT timestamp_micros(1230219000123123); +----------------------------------+ |timestamp_micros(1230219000123123)| +----------------------------------+ | 2008-12-26 00:30:...| +----------------------------------+ -- timestamp_millis SELECT timestamp_millis(1230219000123); +-------------------------------+ |timestamp_millis(1230219000123)| +-------------------------------+ | 2008-12-26 00:30:...| +-------------------------------+ -- timestamp_seconds SELECT timestamp_seconds(1230219000); +-----------------------------+ |timestamp_seconds(1230219000)| +-----------------------------+ | 2008-12-26 00:30:00| +-----------------------------+ SELECT timestamp_seconds(1230219000.123); +---------------------------------+ |timestamp_seconds(1230219000.123)| +---------------------------------+ | 2008-12-26 00:30:...| +---------------------------------+ -- to_date SELECT to_date('2009-07-30 04:17:52'); +----------------------------+ |to_date(2009-07-30 04:17:52)| +----------------------------+ | 2009-07-30| +----------------------------+ SELECT to_date('2016-12-31', 'yyyy-MM-dd'); +-------------------------------+ |to_date(2016-12-31, yyyy-MM-dd)| +-------------------------------+ | 2016-12-31| +-------------------------------+ -- to_timestamp SELECT to_timestamp('2016-12-31 00:12:00'); +---------------------------------+ |to_timestamp(2016-12-31 00:12:00)| +---------------------------------+ | 2016-12-31 00:12:00| +---------------------------------+ SELECT to_timestamp('2016-12-31', 'yyyy-MM-dd'); +------------------------------------+ |to_timestamp(2016-12-31, yyyy-MM-dd)| +------------------------------------+ | 2016-12-31 00:00:00| +------------------------------------+ -- to_timestamp_ltz SELECT to_timestamp_ltz('2016-12-31 00:12:00'); +-------------------------------------+ |to_timestamp_ltz(2016-12-31 00:12:00)| +-------------------------------------+ | 2016-12-31 00:12:00| +-------------------------------------+ SELECT to_timestamp_ltz('2016-12-31', 'yyyy-MM-dd'); +----------------------------------------+ |to_timestamp_ltz(2016-12-31, yyyy-MM-dd)| +----------------------------------------+ | 2016-12-31 00:00:00| +----------------------------------------+ -- to_timestamp_ntz SELECT to_timestamp_ntz('2016-12-31 00:12:00'); +-------------------------------------+ |to_timestamp_ntz(2016-12-31 00:12:00)| +-------------------------------------+ | 2016-12-31 00:12:00| +-------------------------------------+ SELECT to_timestamp_ntz('2016-12-31', 'yyyy-MM-dd'); +----------------------------------------+ |to_timestamp_ntz(2016-12-31, yyyy-MM-dd)| +----------------------------------------+ | 2016-12-31 00:00:00| +----------------------------------------+ -- to_unix_timestamp SELECT to_unix_timestamp('2016-04-08', 'yyyy-MM-dd'); +-----------------------------------------+ |to_unix_timestamp(2016-04-08, yyyy-MM-dd)| +-----------------------------------------+ | 1460041200| +-----------------------------------------+ -- to_utc_timestamp SELECT to_utc_timestamp('2016-08-31', 'Asia/Seoul'); +----------------------------------------+ |to_utc_timestamp(2016-08-31, Asia/Seoul)| +----------------------------------------+ | 2016-08-30 15:00:00| +----------------------------------------+ -- trunc SELECT trunc('2019-08-04', 'week'); +-----------------------+ |trunc(2019-08-04, week)| +-----------------------+ | 2019-07-29| +-----------------------+ SELECT trunc('2019-08-04', 'quarter'); +--------------------------+ |trunc(2019-08-04, quarter)| +--------------------------+ | 2019-07-01| +--------------------------+ SELECT trunc('2009-02-12', 'MM'); +---------------------+ |trunc(2009-02-12, MM)| +---------------------+ | 2009-02-01| +---------------------+ SELECT trunc('2015-10-27', 'YEAR'); +-----------------------+ |trunc(2015-10-27, YEAR)| +-----------------------+ | 2015-01-01| +-----------------------+ -- try_to_timestamp SELECT try_to_timestamp('2016-12-31 00:12:00'); +-------------------------------------+ |try_to_timestamp(2016-12-31 00:12:00)| +-------------------------------------+ | 2016-12-31 00:12:00| +-------------------------------------+ SELECT try_to_timestamp('2016-12-31', 'yyyy-MM-dd'); +----------------------------------------+ |try_to_timestamp(2016-12-31, yyyy-MM-dd)| +----------------------------------------+ | 2016-12-31 00:00:00| +----------------------------------------+ SELECT try_to_timestamp('foo', 'yyyy-MM-dd'); +---------------------------------+ |try_to_timestamp(foo, yyyy-MM-dd)| +---------------------------------+ | NULL| +---------------------------------+ -- unix_date SELECT unix_date(DATE("1970-01-02")); +---------------------+ |unix_date(1970-01-02)| +---------------------+ | 1| +---------------------+ -- unix_micros SELECT unix_micros(TIMESTAMP('1970-01-01 00:00:01Z')); +---------------------------------+ |unix_micros(1970-01-01 00:00:01Z)| +---------------------------------+ | 1000000| +---------------------------------+ -- unix_millis SELECT unix_millis(TIMESTAMP('1970-01-01 00:00:01Z')); +---------------------------------+ |unix_millis(1970-01-01 00:00:01Z)| +---------------------------------+ | 1000| +---------------------------------+ -- unix_seconds SELECT unix_seconds(TIMESTAMP('1970-01-01 00:00:01Z')); +----------------------------------+ |unix_seconds(1970-01-01 00:00:01Z)| +----------------------------------+ | 1| +----------------------------------+ -- unix_timestamp SELECT unix_timestamp(); +--------------------------------------------------------+ |unix_timestamp(current_timestamp(), yyyy-MM-dd HH:mm:ss)| +--------------------------------------------------------+ | 1708760216| +--------------------------------------------------------+ SELECT unix_timestamp('2016-04-08', 'yyyy-MM-dd'); +--------------------------------------+ |unix_timestamp(2016-04-08, yyyy-MM-dd)| +--------------------------------------+ | 1460041200| +--------------------------------------+ -- weekday SELECT weekday('2009-07-30'); +-------------------+ |weekday(2009-07-30)| +-------------------+ | 3| +-------------------+ -- weekofyear SELECT weekofyear('2008-02-20'); +----------------------+ |weekofyear(2008-02-20)| +----------------------+ | 8| +----------------------+ -- window SELECT a, window.start, window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '5 minutes') ORDER BY a, start; +---+-------------------+-------------------+---+ | a| start| end|cnt| +---+-------------------+-------------------+---+ | A1|2021-01-01 00:00:00|2021-01-01 00:05:00| 2| | A1|2021-01-01 00:05:00|2021-01-01 00:10:00| 1| | A2|2021-01-01 00:00:00|2021-01-01 00:05:00| 1| +---+-------------------+-------------------+---+ SELECT a, window.start, window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '10 minutes', '5 minutes') ORDER BY a, start; +---+-------------------+-------------------+---+ | a| start| end|cnt| +---+-------------------+-------------------+---+ | A1|2020-12-31 23:55:00|2021-01-01 00:05:00| 2| | A1|2021-01-01 00:00:00|2021-01-01 00:10:00| 3| | A1|2021-01-01 00:05:00|2021-01-01 00:15:00| 1| | A2|2020-12-31 23:55:00|2021-01-01 00:05:00| 1| | A2|2021-01-01 00:00:00|2021-01-01 00:10:00| 1| +---+-------------------+-------------------+---+ -- window_time SELECT a, window.start as start, window.end as end, window_time(window), cnt FROM (SELECT a, window, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '5 minutes') ORDER BY a, window.start); +---+-------------------+-------------------+--------------------+---+ | a| start| end| window_time(window)|cnt| +---+-------------------+-------------------+--------------------+---+ | A1|2021-01-01 00:00:00|2021-01-01 00:05:00|2021-01-01 00:04:...| 2| | A1|2021-01-01 00:05:00|2021-01-01 00:10:00|2021-01-01 00:09:...| 1| | A2|2021-01-01 00:00:00|2021-01-01 00:05:00|2021-01-01 00:04:...| 1| +---+-------------------+-------------------+--------------------+---+ -- year SELECT year('2016-07-30'); +----------------+ |year(2016-07-30)| +----------------+ | 2016| +----------------+ ``` #### 집계 함수 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). 집계 함수는 행의 값에 대해 작동하여 합계, 평균, 계산, 최소값/최대값, 표준 편차, 추정과 같은 수학 계산과 일부 비수학 연산을 수행합니다. **구문 ** ``` aggregate_function(input1 [, input2, ...]) FILTER (WHERE boolean_expression) ``` **파라미터** + `boolean_expression` - 결과 유형 부울로 평가되는 표현식을 지정합니다. 논리 연산자(AND, OR)를 사용하여 둘 이상의 표현식을 결합할 수 있습니다. **순서 지정 집계 함수 ** 이 집계 함수는 다른 집계 함수와 다른 구문을 사용하여 값을 정렬할 표현식(일반적으로 열 이름)을 지정합니다. **구문 ** ``` { PERCENTILE_CONT | PERCENTILE_DISC }(percentile) WITHIN GROUP (ORDER BY { order_by_expression [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [ , ... ] }) FILTER (WHERE boolean_expression) ``` **파라미터** + `percentile` - 찾으려는 값의 백분위수입니다. 백분위수는 0.0에서 1.0 사이의 상수여야 합니다. + `order_by_expression` - 값을 집계하기 전에 정렬할 표현식(일반적으로 열 이름)입니다. + `boolean_expression` - 결과 유형 부울로 평가되는 표현식을 지정합니다. 논리 연산자(AND, OR)를 사용하여 둘 이상의 표현식을 결합할 수 있습니다. **예시** ``` CREATE OR REPLACE TEMPORARY VIEW basic_pays AS SELECT * FROM VALUES ('Jane Doe','Accounting',8435), ('Akua Mansa','Accounting',9998), ('John Doe','Accounting',8992), ('Juan Li','Accounting',8870), ('Carlos Salazar','Accounting',11472), ('Arnav Desai','Accounting',6627), ('Saanvi Sarkar','IT',8113), ('Shirley Rodriguez','IT',5186), ('Nikki Wolf','Sales',9181), ('Alejandro Rosalez','Sales',9441), ('Nikhil Jayashankar','Sales',6660), ('Richard Roe','Sales',10563), ('Pat Candella','SCM',10449), ('Gerard Hernandez','SCM',6949), ('Pamela Castillo','SCM',11303), ('Paulo Santos','SCM',11798), ('Jorge Souza','SCM',10586) AS basic_pays(employee_name, department, salary); SELECT * FROM basic_pays; +-------------------+----------+------+ | employee_name |department|salary| +-------------------+----------+------+ | Arnav Desai |Accounting| 6627| | Jorge Souza | SCM| 10586| | Jane Doe |Accounting| 8435| | Nikhil Jayashankar| Sales| 6660| | Diego Vanauf | Sales| 10563| | Carlos Salazar |Accounting| 11472| | Gerard Hernandez | SCM| 6949| | John Doe |Accounting| 8992| | Nikki Wolf | Sales| 9181| | Paulo Santos | SCM| 11798| | Saanvi Sarkar | IT| 8113| | Shirley Rodriguez | IT| 5186| | Pat Candella | SCM| 10449| | Akua Mansa |Accounting| 9998| | Pamela Castillo | SCM| 11303| | Alejandro Rosalez | Sales| 9441| | Juan Li |Accounting| 8870| +-------------------+----------+------+ SELECT department, percentile_cont(0.25) WITHIN GROUP (ORDER BY salary) AS pc1, percentile_cont(0.25) WITHIN GROUP (ORDER BY salary) FILTER (WHERE employee_name LIKE '%Bo%') AS pc2, percentile_cont(0.25) WITHIN GROUP (ORDER BY salary DESC) AS pc3, percentile_cont(0.25) WITHIN GROUP (ORDER BY salary DESC) FILTER (WHERE employee_name LIKE '%Bo%') AS pc4, percentile_disc(0.25) WITHIN GROUP (ORDER BY salary) AS pd1, percentile_disc(0.25) WITHIN GROUP (ORDER BY salary) FILTER (WHERE employee_name LIKE '%Bo%') AS pd2, percentile_disc(0.25) WITHIN GROUP (ORDER BY salary DESC) AS pd3, percentile_disc(0.25) WITHIN GROUP (ORDER BY salary DESC) FILTER (WHERE employee_name LIKE '%Bo%') AS pd4 FROM basic_pays GROUP BY department ORDER BY department; +----------+-------+--------+-------+--------+-----+-----+-----+-----+ |department| pc1| pc2| pc3| pc4| pd1| pd2| pd3| pd4| +----------+-------+--------+-------+--------+-----+-----+-----+-----+ |Accounting|8543.75| 7838.25| 9746.5|10260.75| 8435| 6627| 9998|11472| | IT|5917.75| NULL|7381.25| NULL| 5186| NULL| 8113| NULL| | Sales|8550.75| NULL| 9721.5| NULL| 6660| NULL|10563| NULL| | SCM|10449.0|10786.25|11303.0|11460.75|10449|10449|11303|11798| +----------+-------+--------+-------+--------+-----+-----+-----+-----+ ``` #### 조건 함수 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). **** | 함수 | 설명 | | --- | --- | | coalesce(expr1, expr2, ...) | 존재하는 경우, 첫 번째 null이 아닌 인수를 반환합니다. 그렇지 않은 경우 null입니다. | | if(expr1, expr2, expr3) | expr1이 true로 평가되면 expr2를 반환하고, 그렇지 않으면 expr3을 반환합니다. | | ifnull(expr1, expr2) | expr1이 null이면 expr1을 반환하고, 그렇지 않으면 expr2를 반환합니다. | | nanvl(expr1, expr2) | NaN이 아니면 expr1을 반환하고, 그렇지 않으면 expr2를 반환합니다. | | nullif(expr1, expr2) | expr1가 expr2와 같으면 null을 반환하고, 그렇지 않으면 expr1을 반환합니다. | | nvl(expr1, expr2) | expr1이 null이면 expr1을 반환하고, 그렇지 않으면 expr2를 반환합니다. | | nvl2(expr1, expr2, expr3) | expr1이 null이 아니면 expr3을 반환하고, 그렇지 않으면 expr2를 반환합니다. | | CASE WHEN expr1 THEN expr2 [WHEN expr3 THEN expr4]\$1 [ELSE expr5] END | expr1 = true이면 expr2를 반환하고, expr3 = true이면 expr4를 반환하고, 그렇지 않으면 expr5를 반환합니다. | **예시** ``` -- coalesce SELECT coalesce(NULL, 1, NULL); +-----------------------+ |coalesce(NULL, 1, NULL)| +-----------------------+ | 1| +-----------------------+ -- if SELECT if(1 < 2, 'a', 'b'); +-------------------+ |(IF((1 < 2), a, b))| +-------------------+ | a| +-------------------+ -- ifnull SELECT ifnull(NULL, array('2')); +----------------------+ |ifnull(NULL, array(2))| +----------------------+ | [2]| +----------------------+ -- nanvl SELECT nanvl(cast('NaN' as double), 123); +-------------------------------+ |nanvl(CAST(NaN AS DOUBLE), 123)| +-------------------------------+ | 123.0| +-------------------------------+ -- nullif SELECT nullif(2, 2); +------------+ |nullif(2, 2)| +------------+ | NULL| +------------+ -- nvl SELECT nvl(NULL, array('2')); +-------------------+ |nvl(NULL, array(2))| +-------------------+ | [2]| +-------------------+ -- nvl2 SELECT nvl2(NULL, 2, 1); +----------------+ |nvl2(NULL, 2, 1)| +----------------+ | 1| +----------------+ -- when SELECT CASE WHEN 1 > 0 THEN 1 WHEN 2 > 0 THEN 2.0 ELSE 1.2 END; +-----------------------------------------------------------+ |CASE WHEN (1 > 0) THEN 1 WHEN (2 > 0) THEN 2.0 ELSE 1.2 END| +-----------------------------------------------------------+ | 1.0| +-----------------------------------------------------------+ SELECT CASE WHEN 1 < 0 THEN 1 WHEN 2 > 0 THEN 2.0 ELSE 1.2 END; +-----------------------------------------------------------+ |CASE WHEN (1 < 0) THEN 1 WHEN (2 > 0) THEN 2.0 ELSE 1.2 END| +-----------------------------------------------------------+ | 2.0| +-----------------------------------------------------------+ SELECT CASE WHEN 1 < 0 THEN 1 WHEN 2 < 0 THEN 2.0 END; +--------------------------------------------------+ |CASE WHEN (1 < 0) THEN 1 WHEN (2 < 0) THEN 2.0 END| +--------------------------------------------------+ | NULL| +--------------------------------------------------+ ``` #### JSON 함수 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). **** | 함수 | 설명 | | --- | --- | | from\$1json(jsonStr, schema[, options]) | 지정된 `jsonStr` 및 `schema`의 구문 값을 반환합니다. | | get\$1json\$1object(json\$1txt, path) | `path`에서 json 객체를 추출합니다. | | json\$1array\$1length(jsonArray) | JSON 문자열의 바깥쪽 배열에 속한 요소 수를 반환합니다. | | json\$1object\$1keys(json\$1object) | 가장 바깥쪽 JSON 객체의 모든 키를 배열로 반환합니다. | | json\$1tuple(jsonStr, p1, p2, ..., pn) | 함수 get\$1json\$1object와 같은 튜플을 반환하지만 여러 이름을 사용합니다. 모든 입력 파라미터와 출력 열 유형은 문자열입니다. | | schema\$1of\$1json(json[, options]) | JSON 문자열의 DDL 형식으로 스키마를 반환합니다. | | to\$1json(expr[, options]) | 지정된 구문 값을 가진 JSON 문자열을 반환합니다. | **예시** ``` -- from_json SELECT from_json('{"a":1, "b":0.8}', 'a INT, b DOUBLE'); +---------------------------+ | from_json({"a":1, "b":0.8}) | +---------------------------+ | {1, 0.8} | +---------------------------+ SELECT from_json('{"time":"26/08/2015"}', 'time Timestamp', map('timestampFormat', 'dd/MM/yyyy')); +--------------------------------+ | from_json({"time":"26/08/2015"}) | +--------------------------------+ | {2015-08-26 00:00... | +--------------------------------+ SELECT from_json('{"teacher": "Alice", "student": [{"name": "Bob", "rank": 1}, {"name": "Charlie", "rank": 2}]}', 'STRUCT>>'); +--------------------------------------------------------------------------------------------------------+ | from_json({"teacher": "Alice", "student": [{"name": "Bob", "rank": 1}, {"name": "Charlie", "rank": 2}]}) | +--------------------------------------------------------------------------------------------------------+ | {Alice, [{Bob, 1}... | +--------------------------------------------------------------------------------------------------------+ -- get_json_object SELECT get_json_object('{"a":"b"}', '$.a'); +-------------------------------+ | get_json_object({"a":"b"}, $.a) | +-------------------------------+ | b | +-------------------------------+ -- json_array_length SELECT json_array_length('[1,2,3,4]'); +----------------------------+ | json_array_length([1,2,3,4]) | +----------------------------+ | 4 | +----------------------------+ SELECT json_array_length('[1,2,3,{"f1":1,"f2":[5,6]},4]'); +------------------------------------------------+ | json_array_length([1,2,3,{"f1":1,"f2":[5,6]},4]) | +------------------------------------------------+ | 5 | +------------------------------------------------+ SELECT json_array_length('[1,2'); +-----------------------+ | json_array_length([1,2) | +-----------------------+ | NULL | +-----------------------+ -- json_object_keys SELECT json_object_keys('{}'); +--------------------+ | json_object_keys({}) | +--------------------+ | [] | +--------------------+ SELECT json_object_keys('{"key": "value"}'); +----------------------------------+ | json_object_keys({"key": "value"}) | +----------------------------------+ | [key] | +----------------------------------+ SELECT json_object_keys('{"f1":"abc","f2":{"f3":"a", "f4":"b"}}'); +--------------------------------------------------------+ | json_object_keys({"f1":"abc","f2":{"f3":"a", "f4":"b"}}) | +--------------------------------------------------------+ | [f1, f2] | +--------------------------------------------------------+ -- json_tuple SELECT json_tuple('{"a":1, "b":2}', 'a', 'b'); +---+---+ | c0| c1| +---+---+ | 1| 2| +---+---+ -- schema_of_json SELECT schema_of_json('[{"col":0}]'); +---------------------------+ | schema_of_json([{"col":0}]) | +---------------------------+ | ARRAY **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). **** | 함수 | 설명 | | --- | --- | | array(expr, ...) | 지정된 요소가 있는 배열을 반환합니다. | | array\$1append(array, element) | 첫 번째 인수로 전달된 배열 끝에 요소를 추가합니다. 요소 유형은 배열의 요소 유형과 유사해야 합니다. Null 요소도 배열에 추가됩니다. 단, 배열이 전달되면 NULL 출력은 NULL입니다. | | array\$1compact(array) | 배열에서 null 값을 제거합니다. | | array\$1contains(array, value) | 배열에 값이 포함된 경우 true를 반환합니다. | | array\$1distinct(array) | 배열에서 중복 값을 제거합니다. | | array\$1except(array1, array2) | 중복 없이 array2에 없는 array1의 요소 배열을 반환합니다. | | array\$1insert(x, pos, val) | 배열 x의 인덱스 위치에 val을 배치합니다. 배열 인덱스는 1에서 시작합니다. 함수가 현재 마지막 요소 뒤에 새 요소를 삽입하는 최대 음수 인덱스는 -1입니다. 배열 크기를 초과하는 인덱스가 주어지면 인덱스가 양수일 경우 배열의 뒤에, 음수일 경우 배열의 앞에 null 요소를 채워 넣어 확장합니다. | | array\$1intersect(array1, array2) | 중복 없이 array1과 array2의 교차점에 있는 요소의 배열을 반환합니다. | | array\$1join(array, delimiter[, nullReplacement]) | null을 대체하기 위해 구분 기호와 선택적 문자열을 사용하여 지정된 배열의 요소를 연결합니다. nullReplacement에 값을 설정하지 않으면 null 값이 필터링됩니다. | | array\$1max(array) | 배열의 최대값을 반환합니다. NaN은 이중/부동 소수점 유형에 대한 비NaN 요소보다 큽니다. NULL 요소는 건너뜁니다. | | array\$1min(array) | 배열의 최소값을 반환합니다. NaN은 이중/부동 소수점 유형에 대한 비NaN 요소보다 큽니다. NULL 요소는 건너뜁니다. | | array\$1position(array, element) | 배열에서 처음으로 일치하는 요소의 (1 기반) 인덱스를 long 형식으로 반환하며, 일치하는 요소가 없으면 0을 반환합니다. | | array\$1prepend(array, element) | 첫 번째 인수로 전달된 배열의 시작 부분에 요소를 추가합니다. 요소 유형은 배열의 요소 유형과 동일해야 합니다. Null 요소도 배열 앞에 추가됩니다. 단, 배열이 전달되면 NULL 출력은 NULL입니다. | | array\$1remove(array, element) | 배열에서 요소와 동일한 요소를 모두 제거합니다. | | array\$1repeat(element, count) | 요소를 count 횟수만큼 포함하는 배열을 반환합니다. | | array\$1union(array1, array2) | 중복 없이 array1과 array2의 합집합에 있는 요소의 배열을 반환합니다. | | arrays\$1overlap(a1, a2) | a1에 null이 아닌 요소가 하나 이상 포함되어 있고 a2에도 있는 경우 true를 반환합니다. 배열에 공통 요소가 없고 둘 다 비어 있지 않으며 둘 중 하나에 null 요소가 포함된 경우 null이, 그렇지 않은 경우 false가 반환됩니다. | | arrays\$1zip(a1, a2, ...) | N번째 구문에 입력 배열의 모든 N번째 값이 포함된 병합된 구조체 배열을 반환합니다. | | flatten(arrayOfArrays) | 배열의 배열을 단일 배열로 변환합니다. | | get(array, index) | 지정된 (0 기반) 인덱스에서 배열의 요소를 반환합니다. 인덱스가 배열 경계 외부를 가리키는 경우 이 함수는 NULL을 반환합니다. | | sequence(start, stop, step) | start부터 stop(끝 값 포함)까지 step만큼 증가하는 요소 배열을 생성합니다. 반환되는 요소의 유형은 인수 표현식의 유형과 동일합니다. 지원되는 유형은 byte, short, integer, long, date, timestamp입니다. start 및 stop 표현식은 동일한 유형으로 확인되어야 합니다. start 및 stop 표현식이 'date' 또는 'timestamp' 유형으로 확인되면 step 표현식은 'interval', 'year-month interval' 또는 'day-time interval' 유형으로 확인되어야 하며, 그렇지 않으면 start 및 stop 표현식과 동일한 유형으로 확인되어야 합니다. | | shuffle(array) | 지정된 배열의 임의 순열을 반환합니다. | | slice(x, start, length) | 지정된 길이의 인덱스 시작(배열 인덱스는 1에서 시작하거나 시작이 음수인 경우 끝에서 시작)부터 시작하는 배열 x의 부분 배열을 추출합니다. | | sort\$1array(array[, ascendingOrder]) | 배열 요소의 자연 순서에 따라 입력 배열을 오름차순 또는 내림차순으로 정렬합니다. NaN은 이중/부동 소수점 유형에 대한 비NaN 요소보다 큽니다. Null 요소는 반환된 배열의 시작 부분에 오름차순으로 또는 반환된 배열의 끝에 내림차순으로 배치됩니다. | **예시** ``` -- array SELECT array(1, 2, 3); +--------------+ |array(1, 2, 3)| +--------------+ | [1, 2, 3]| +--------------+ -- array_append SELECT array_append(array('b', 'd', 'c', 'a'), 'd'); +----------------------------------+ |array_append(array(b, d, c, a), d)| +----------------------------------+ | [b, d, c, a, d]| +----------------------------------+ SELECT array_append(array(1, 2, 3, null), null); +----------------------------------------+ |array_append(array(1, 2, 3, NULL), NULL)| +----------------------------------------+ | [1, 2, 3, NULL, N...| +----------------------------------------+ SELECT array_append(CAST(null as Array), 2); +---------------------+ |array_append(NULL, 2)| +---------------------+ | NULL| +---------------------+ -- array_compact SELECT array_compact(array(1, 2, 3, null)); +-----------------------------------+ |array_compact(array(1, 2, 3, NULL))| +-----------------------------------+ | [1, 2, 3]| +-----------------------------------+ SELECT array_compact(array("a", "b", "c")); +-----------------------------+ |array_compact(array(a, b, c))| +-----------------------------+ | [a, b, c]| +-----------------------------+ -- array_contains SELECT array_contains(array(1, 2, 3), 2); +---------------------------------+ |array_contains(array(1, 2, 3), 2)| +---------------------------------+ | true| +---------------------------------+ -- array_distinct SELECT array_distinct(array(1, 2, 3, null, 3)); +---------------------------------------+ |array_distinct(array(1, 2, 3, NULL, 3))| +---------------------------------------+ | [1, 2, 3, NULL]| +---------------------------------------+ -- array_except SELECT array_except(array(1, 2, 3), array(1, 3, 5)); +--------------------------------------------+ |array_except(array(1, 2, 3), array(1, 3, 5))| +--------------------------------------------+ | [2]| +--------------------------------------------+ -- array_insert SELECT array_insert(array(1, 2, 3, 4), 5, 5); +-------------------------------------+ |array_insert(array(1, 2, 3, 4), 5, 5)| +-------------------------------------+ | [1, 2, 3, 4, 5]| +-------------------------------------+ SELECT array_insert(array(5, 4, 3, 2), -1, 1); +--------------------------------------+ |array_insert(array(5, 4, 3, 2), -1, 1)| +--------------------------------------+ | [5, 4, 3, 2, 1]| +--------------------------------------+ SELECT array_insert(array(5, 3, 2, 1), -4, 4); +--------------------------------------+ |array_insert(array(5, 3, 2, 1), -4, 4)| +--------------------------------------+ | [5, 4, 3, 2, 1]| +--------------------------------------+ -- array_intersect SELECT array_intersect(array(1, 2, 3), array(1, 3, 5)); +-----------------------------------------------+ |array_intersect(array(1, 2, 3), array(1, 3, 5))| +-----------------------------------------------+ | [1, 3]| +-----------------------------------------------+ -- array_join SELECT array_join(array('hello', 'world'), ' '); +----------------------------------+ |array_join(array(hello, world), )| +----------------------------------+ | hello world| +----------------------------------+ SELECT array_join(array('hello', null ,'world'), ' '); +----------------------------------------+ |array_join(array(hello, NULL, world), )| +----------------------------------------+ | hello world| +----------------------------------------+ SELECT array_join(array('hello', null ,'world'), ' ', ','); +-------------------------------------------+ |array_join(array(hello, NULL, world), , ,)| +-------------------------------------------+ | hello , world| +-------------------------------------------+ -- array_max SELECT array_max(array(1, 20, null, 3)); +--------------------------------+ |array_max(array(1, 20, NULL, 3))| +--------------------------------+ | 20| +--------------------------------+ -- array_min SELECT array_min(array(1, 20, null, 3)); +--------------------------------+ |array_min(array(1, 20, NULL, 3))| +--------------------------------+ | 1| +--------------------------------+ -- array_position SELECT array_position(array(312, 773, 708, 708), 708); +----------------------------------------------+ |array_position(array(312, 773, 708, 708), 708)| +----------------------------------------------+ | 3| +----------------------------------------------+ SELECT array_position(array(312, 773, 708, 708), 414); +----------------------------------------------+ |array_position(array(312, 773, 708, 708), 414)| +----------------------------------------------+ | 0| +----------------------------------------------+ -- array_prepend SELECT array_prepend(array('b', 'd', 'c', 'a'), 'd'); +-----------------------------------+ |array_prepend(array(b, d, c, a), d)| +-----------------------------------+ | [d, b, d, c, a]| +-----------------------------------+ SELECT array_prepend(array(1, 2, 3, null), null); +-----------------------------------------+ |array_prepend(array(1, 2, 3, NULL), NULL)| +-----------------------------------------+ | [NULL, 1, 2, 3, N...| +-----------------------------------------+ SELECT array_prepend(CAST(null as Array), 2); +----------------------+ |array_prepend(NULL, 2)| +----------------------+ | NULL| +----------------------+ -- array_remove SELECT array_remove(array(1, 2, 3, null, 3), 3); +----------------------------------------+ |array_remove(array(1, 2, 3, NULL, 3), 3)| +----------------------------------------+ | [1, 2, NULL]| +----------------------------------------+ -- array_repeat SELECT array_repeat('123', 2); +--------------------+ |array_repeat(123, 2)| +--------------------+ | [123, 123]| +--------------------+ -- array_union SELECT array_union(array(1, 2, 3), array(1, 3, 5)); +-------------------------------------------+ |array_union(array(1, 2, 3), array(1, 3, 5))| +-------------------------------------------+ | [1, 2, 3, 5]| +-------------------------------------------+ -- arrays_overlap SELECT arrays_overlap(array(1, 2, 3), array(3, 4, 5)); +----------------------------------------------+ |arrays_overlap(array(1, 2, 3), array(3, 4, 5))| +----------------------------------------------+ | true| +----------------------------------------------+ -- arrays_zip SELECT arrays_zip(array(1, 2, 3), array(2, 3, 4)); +------------------------------------------+ |arrays_zip(array(1, 2, 3), array(2, 3, 4))| +------------------------------------------+ | [{1, 2}, {2, 3}, ...| +------------------------------------------+ SELECT arrays_zip(array(1, 2), array(2, 3), array(3, 4)); +-------------------------------------------------+ |arrays_zip(array(1, 2), array(2, 3), array(3, 4))| +-------------------------------------------------+ | [{1, 2, 3}, {2, 3...| +-------------------------------------------------+ -- flatten SELECT flatten(array(array(1, 2), array(3, 4))); +----------------------------------------+ |flatten(array(array(1, 2), array(3, 4)))| +----------------------------------------+ | [1, 2, 3, 4]| +----------------------------------------+ -- get SELECT get(array(1, 2, 3), 0); +----------------------+ |get(array(1, 2, 3), 0)| +----------------------+ | 1| +----------------------+ SELECT get(array(1, 2, 3), 3); +----------------------+ |get(array(1, 2, 3), 3)| +----------------------+ | NULL| +----------------------+ SELECT get(array(1, 2, 3), -1); +-----------------------+ |get(array(1, 2, 3), -1)| +-----------------------+ | NULL| +-----------------------+ -- sequence SELECT sequence(1, 5); +---------------+ | sequence(1, 5)| +---------------+ |[1, 2, 3, 4, 5]| +---------------+ SELECT sequence(5, 1); +---------------+ | sequence(5, 1)| +---------------+ |[5, 4, 3, 2, 1]| +---------------+ SELECT sequence(to_date('2018-01-01'), to_date('2018-03-01'), interval 1 month); +----------------------------------------------------------------------+ |sequence(to_date(2018-01-01), to_date(2018-03-01), INTERVAL '1' MONTH)| +----------------------------------------------------------------------+ | [2018-01-01, 2018...| +----------------------------------------------------------------------+ SELECT sequence(to_date('2018-01-01'), to_date('2018-03-01'), interval '0-1' year to month); +--------------------------------------------------------------------------------+ |sequence(to_date(2018-01-01), to_date(2018-03-01), INTERVAL '0-1' YEAR TO MONTH)| +--------------------------------------------------------------------------------+ | [2018-01-01, 2018...| +--------------------------------------------------------------------------------+ -- shuffle SELECT shuffle(array(1, 20, 3, 5)); +---------------------------+ |shuffle(array(1, 20, 3, 5))| +---------------------------+ | [5, 1, 20, 3]| +---------------------------+ SELECT shuffle(array(1, 20, null, 3)); +------------------------------+ |shuffle(array(1, 20, NULL, 3))| +------------------------------+ | [1, NULL, 20, 3]| +------------------------------+ -- slice SELECT slice(array(1, 2, 3, 4), 2, 2); +------------------------------+ |slice(array(1, 2, 3, 4), 2, 2)| +------------------------------+ | [2, 3]| +------------------------------+ SELECT slice(array(1, 2, 3, 4), -2, 2); +-------------------------------+ |slice(array(1, 2, 3, 4), -2, 2)| +-------------------------------+ | [3, 4]| +-------------------------------+ -- sort_array SELECT sort_array(array('b', 'd', null, 'c', 'a'), true); +-----------------------------------------+ |sort_array(array(b, d, NULL, c, a), true)| +-----------------------------------------+ | [NULL, a, b, c, d]| +-----------------------------------------+ ``` #### 윈도우 함수 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). window 함수는 윈도우라고 하는 행 그룹에서 작동하며 행 그룹을 기반으로 각 행의 반환 값을 계산합니다. window 함수는 이동 평균 계산, 누적 통계 계산 또는 현재 행의 상대 위치가 지정된 행 값에 액세스와 같은 작업을 처리하는 데 유용합니다. **구문** ``` window_function [ nulls_option ] OVER ( [ { PARTITION | DISTRIBUTE } BY partition_col_name = partition_col_val ( [ , ... ] ) ] { ORDER | SORT } BY expression [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [ , ... ] [ window_frame ] ) ``` **파라미터** + window\$1function 순위 함수 구문: `RANK | DENSE_RANK | PERCENT_RANK | NTILE | ROW_NUMBER ` 분석 함수 구문: `CUME_DIST | LAG | LEAD | NTH_VALUE | FIRST_VALUE | LAST_VALUE ` 집계 함수 구문: `MAX | MIN | COUNT | SUM | AVG | ... ` + `nulls_option` - window 함수를 평가할 때 null 값을 건너뛸지 여부를 지정합니다. RESPECT NULLS는 null 값을 건너뛰지 않음을, IGNORE NULLS는 건너뜀을 의미합니다. 지정하지 않으면 기본값은 RESPECT NULLS입니다. 구문: `{ IGNORE | RESPECT } NULLS ` 참고: `Only LAG` \$1 `LEAD` \$1 `NTH_VALUE` \$1 `FIRST_VALUE` \$1 `LAST_VALUE`는 `IGNORE NULLS`와 함께 사용할 수 있습니다. + `window_frame` - 윈도우를 시작할 행과 윈도우를 종료할 위치를 지정합니다. 구문: `{ RANGE | ROWS } { frame_start | BETWEEN frame_start AND frame_end }` frame\$1start 및 frame\$1end의 구문은 다음과 같습니다. 구문: `UNBOUNDED PRECEDING | offset PRECEDING | CURRENT ROW | offset FOLLOWING | UNBOUNDED FOLLOWING ` offset: 현재 행의 위치에서 오프셋을 지정합니다. **참고** frame\$1end를 생략하면 기본적으로 CURRENT ROW로 설정됩니다. **예시** ``` CREATE TABLE employees (name STRING, dept STRING, salary INT, age INT); INSERT INTO employees VALUES ("Lisa", "Sales", 10000, 35); INSERT INTO employees VALUES ("Evan", "Sales", 32000, 38); INSERT INTO employees VALUES ("Fred", "Engineering", 21000, 28); INSERT INTO employees VALUES ("Alex", "Sales", 30000, 33); INSERT INTO employees VALUES ("Tom", "Engineering", 23000, 33); INSERT INTO employees VALUES ("Jane", "Marketing", 29000, 28); INSERT INTO employees VALUES ("Jeff", "Marketing", 35000, 38); INSERT INTO employees VALUES ("Paul", "Engineering", 29000, 23); INSERT INTO employees VALUES ("Chloe", "Engineering", 23000, 25); SELECT * FROM employees; +-----+-----------+------+-----+ | name| dept|salary| age| +-----+-----------+------+-----+ |Chloe|Engineering| 23000| 25| | Fred|Engineering| 21000| 28| | Paul|Engineering| 29000| 23| |Helen| Marketing| 29000| 40| | Tom|Engineering| 23000| 33| | Jane| Marketing| 29000| 28| | Jeff| Marketing| 35000| 38| | Evan| Sales| 32000| 38| | Lisa| Sales| 10000| 35| | Alex| Sales| 30000| 33| +-----+-----------+------+-----+ SELECT name, dept, salary, RANK() OVER (PARTITION BY dept ORDER BY salary) AS rank FROM employees; +-----+-----------+------+----+ | name| dept|salary|rank| +-----+-----------+------+----+ | Lisa| Sales| 10000| 1| | Alex| Sales| 30000| 2| | Evan| Sales| 32000| 3| | Fred|Engineering| 21000| 1| | Tom|Engineering| 23000| 2| |Chloe|Engineering| 23000| 2| | Paul|Engineering| 29000| 4| |Helen| Marketing| 29000| 1| | Jane| Marketing| 29000| 1| | Jeff| Marketing| 35000| 3| +-----+-----------+------+----+ SELECT name, dept, salary, DENSE_RANK() OVER (PARTITION BY dept ORDER BY salary ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS dense_rank FROM employees; +-----+-----------+------+----------+ | name| dept|salary|dense_rank| +-----+-----------+------+----------+ | Lisa| Sales| 10000| 1| | Alex| Sales| 30000| 2| | Evan| Sales| 32000| 3| | Fred|Engineering| 21000| 1| | Tom|Engineering| 23000| 2| |Chloe|Engineering| 23000| 2| | Paul|Engineering| 29000| 3| |Helen| Marketing| 29000| 1| | Jane| Marketing| 29000| 1| | Jeff| Marketing| 35000| 2| +-----+-----------+------+----------+ SELECT name, dept, age, CUME_DIST() OVER (PARTITION BY dept ORDER BY age RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS cume_dist FROM employees; +-----+-----------+------+------------------+ | name| dept|age | cume_dist| +-----+-----------+------+------------------+ | Alex| Sales| 33|0.3333333333333333| | Lisa| Sales| 35|0.6666666666666666| | Evan| Sales| 38| 1.0| | Paul|Engineering| 23| 0.25| |Chloe|Engineering| 25| 0.75| | Fred|Engineering| 28| 0.25| | Tom|Engineering| 33| 1.0| | Jane| Marketing| 28|0.3333333333333333| | Jeff| Marketing| 38|0.6666666666666666| |Helen| Marketing| 40| 1.0| +-----+-----------+------+------------------+ SELECT name, dept, salary, MIN(salary) OVER (PARTITION BY dept ORDER BY salary) AS min FROM employees; +-----+-----------+------+-----+ | name| dept|salary| min| +-----+-----------+------+-----+ | Lisa| Sales| 10000|10000| | Alex| Sales| 30000|10000| | Evan| Sales| 32000|10000| |Helen| Marketing| 29000|29000| | Jane| Marketing| 29000|29000| | Jeff| Marketing| 35000|29000| | Fred|Engineering| 21000|21000| | Tom|Engineering| 23000|21000| |Chloe|Engineering| 23000|21000| | Paul|Engineering| 29000|21000| +-----+-----------+------+-----+ SELECT name, salary, LAG(salary) OVER (PARTITION BY dept ORDER BY salary) AS lag, LEAD(salary, 1, 0) OVER (PARTITION BY dept ORDER BY salary) AS lead FROM employees; +-----+-----------+------+-----+-----+ | name| dept|salary| lag| lead| +-----+-----------+------+-----+-----+ | Lisa| Sales| 10000|NULL |30000| | Alex| Sales| 30000|10000|32000| | Evan| Sales| 32000|30000| 0| | Fred|Engineering| 21000| NULL|23000| |Chloe|Engineering| 23000|21000|23000| | Tom|Engineering| 23000|23000|29000| | Paul|Engineering| 29000|23000| 0| |Helen| Marketing| 29000| NULL|29000| | Jane| Marketing| 29000|29000|35000| | Jeff| Marketing| 35000|29000| 0| +-----+-----------+------+-----+-----+ SELECT id, v, LEAD(v, 0) IGNORE NULLS OVER w lead, LAG(v, 0) IGNORE NULLS OVER w lag, NTH_VALUE(v, 2) IGNORE NULLS OVER w nth_value, FIRST_VALUE(v) IGNORE NULLS OVER w first_value, LAST_VALUE(v) IGNORE NULLS OVER w last_value FROM test_ignore_null WINDOW w AS (ORDER BY id) ORDER BY id; +--+----+----+----+---------+-----------+----------+ |id| v|lead| lag|nth_value|first_value|last_value| +--+----+----+----+---------+-----------+----------+ | 0|NULL|NULL|NULL| NULL| NULL| NULL| | 1| x| x| x| NULL| x| x| | 2|NULL|NULL|NULL| NULL| x| x| | 3|NULL|NULL|NULL| NULL| x| x| | 4| y| y| y| y| x| y| | 5|NULL|NULL|NULL| y| x| y| | 6| z| z| z| y| x| z| | 7| v| v| v| y| x| v| | 8|NULL|NULL|NULL| y| x| v| +--+----+----+----+---------+-----------+----------+ ``` #### 변환 함수 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). **** | 함수 | 설명 | | --- | --- | | bigint(expr) | `expr` 값을 대상 데이터 유형 `bigint`로 캐스팅합니다. | | binary(expr) | `expr` 값을 대상 데이터 유형 `binary`로 캐스팅합니다. | | boolean(expr) | `expr` 값을 대상 데이터 유형 `boolean`으로 캐스팅합니다. | | cast(expr AS type) | `expr` 값을 대상 데이터 유형 `type`으로 캐스팅합니다. | | date(expr) | `expr` 값을 대상 데이터 유형 `date`로 캐스팅합니다. | | decimal(expr) | `expr` 값을 대상 데이터 유형 `decimal`로 캐스팅합니다. | | double(expr) | `expr` 값을 대상 데이터 유형 `double`로 캐스팅합니다. | | float(expr) | `expr` 값을 대상 데이터 유형 `float`으로 캐스팅합니다. | | int(expr) | `expr` 값을 대상 데이터 유형 `int`로 캐스팅합니다. | | smallint(expr) | `expr` 값을 대상 데이터 유형 `smallint`로 캐스팅합니다. | | string(expr) | `expr` 값을 대상 데이터 유형 `string`으로 캐스팅합니다. | | timestamp(expr) | `expr` 값을 대상 데이터 유형 `timestamp`로 캐스팅합니다. | | tinyint(expr) | `expr` 값을 대상 데이터 유형 `tinyint`로 캐스팅합니다. | **예시** ``` -- cast SELECT cast(field as int); +---------------+ |CAST(field AS INT)| +---------------+ | 10| +---------------+ ``` #### 조건자 함수 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). **** | 함수 | 설명 | | --- | --- | | \$1 expr | 논리 not. | | expr1 < expr2 | `expr1`이 `expr2`보다 작으면 true를 반환합니다. | | expr1 <= expr2 | `expr1`이 `expr2`보다 작거나 같으면 true를 반환합니다. | | expr1 <=> expr2 | null이 아닌 피연산자에 대해 EQUAL(=) 연산자와 동일한 결과를 반환하지만 둘 다 null이면 true, 둘 중 하나가 null이면 false를 반환합니다. | | expr1 = expr2 | `expr1`이 `expr2`와 같으면 true를 반환하고 그렇지 않으면 false를 반환합니다. | | expr1 == expr2 | `expr1`이 `expr2`와 같으면 true를 반환하고 그렇지 않으면 false를 반환합니다. | | expr1 > expr2 | `expr1`이 `expr2`보다 큰 경우 true를 반환합니다. | | expr1 >= expr2 | `expr1`이 `expr2`보다 크거나 같으면 true를 반환합니다. | | expr1 and expr2 | 논리적 AND | | str ilike pattern[ ESCAPE escape] | str이 대소문자를 구분하지 않고 `escape`를 포함한 `pattern`과 일치하면 true를 반환하고, 인수가 null이면 null을 반환하고, 그렇지 않으면 false를 반환합니다. | | expr1 in(expr2, expr3, ...) | `expr`가 임의의 valN과 같으면 true를 반환합니다. | | isnan(expr) | `expr`가 NaN이면 true를 반환하고 그렇지 않으면 false를 반환합니다. | | isnotnull(expr) | `expr`가 null이 아니면 true를 반환하고 그렇지 않으면 false를 반환합니다. | | isnull(expr) | `expr`가 null이면 true를 반환하고 그렇지 않으면 false를 반환합니다. | | str like pattern[ ESCAPE escape] | str이 `pattern`과 `escape`가 일치하면 true를 반환하고, 인수가 null이면 null을 반환하고, 그렇지 않으면 false를 반환합니다. | | not expr | 논리 not. | | expr1 or expr2 | 논리적 OR | | regexp(str, regexp) | `str`이 `regexp`와 일치하면 true를 반환하고, 그렇지 않으면 false를 반환합니다. | | regexp\$1like(str, regexp) | `str`이 `regexp`와 일치하면 true를 반환하고, 그렇지 않으면 false를 반환합니다. | | rlike(str, regexp) | `str`이 `regexp`와 일치하면 true를 반환하고, 그렇지 않으면 false를 반환합니다. | **예시** ``` -- ! SELECT ! true; +----------+ |(NOT true)| +----------+ | false| +----------+ SELECT ! false; +-----------+ |(NOT false)| +-----------+ | true| +-----------+ SELECT ! NULL; +----------+ |(NOT NULL)| +----------+ | NULL| +----------+ -- < SELECT to_date('2009-07-30 04:17:52') < to_date('2009-07-30 04:17:52'); +-------------------------------------------------------------+ |(to_date(2009-07-30 04:17:52) < to_date(2009-07-30 04:17:52))| +-------------------------------------------------------------+ | false| +-------------------------------------------------------------+ SELECT to_date('2009-07-30 04:17:52') < to_date('2009-08-01 04:17:52'); +-------------------------------------------------------------+ |(to_date(2009-07-30 04:17:52) < to_date(2009-08-01 04:17:52))| +-------------------------------------------------------------+ | true| +-------------------------------------------------------------+ SELECT 1 < NULL; +----------+ |(1 < NULL)| +----------+ | NULL| +----------+ -- <= SELECT 2 <= 2; +--------+ |(2 <= 2)| +--------+ | true| +--------+ SELECT 1.0 <= '1'; +----------+ |(1.0 <= 1)| +----------+ | true| +----------+ SELECT to_date('2009-07-30 04:17:52') <= to_date('2009-07-30 04:17:52'); +--------------------------------------------------------------+ |(to_date(2009-07-30 04:17:52) <= to_date(2009-07-30 04:17:52))| +--------------------------------------------------------------+ | true| +--------------------------------------------------------------+ SELECT to_date('2009-07-30 04:17:52') <= to_date('2009-08-01 04:17:52'); +--------------------------------------------------------------+ |(to_date(2009-07-30 04:17:52) <= to_date(2009-08-01 04:17:52))| +--------------------------------------------------------------+ | true| +--------------------------------------------------------------+ SELECT 1 <= NULL; +-----------+ |(1 <= NULL)| +-----------+ | NULL| +-----------+ -- <=> SELECT 2 <=> 2; +---------+ |(2 <=> 2)| +---------+ | true| +---------+ SELECT 1 <=> '1'; +---------+ |(1 <=> 1)| +---------+ | true| +---------+ SELECT true <=> NULL; +---------------+ |(true <=> NULL)| +---------------+ | false| +---------------+ SELECT NULL <=> NULL; +---------------+ |(NULL <=> NULL)| +---------------+ | true| +---------------+ -- = SELECT 2 = 2; +-------+ |(2 = 2)| +-------+ | true| +-------+ SELECT 1 = '1'; +-------+ |(1 = 1)| +-------+ | true| +-------+ SELECT true = NULL; +-------------+ |(true = NULL)| +-------------+ | NULL| +-------------+ SELECT NULL = NULL; +-------------+ |(NULL = NULL)| +-------------+ | NULL| +-------------+ -- == SELECT 2 == 2; +-------+ |(2 = 2)| +-------+ | true| +-------+ SELECT 1 == '1'; +-------+ |(1 = 1)| +-------+ | true| +-------+ SELECT true == NULL; +-------------+ |(true = NULL)| +-------------+ | NULL| +-------------+ SELECT NULL == NULL; +-------------+ |(NULL = NULL)| +-------------+ | NULL| +-------------+ -- > SELECT 2 > 1; +-------+ |(2 > 1)| +-------+ | true| +-------+ SELECT 2 > 1.1; +-------+ |(2 > 1)| +-------+ | true| +-------+ SELECT to_date('2009-07-30 04:17:52') > to_date('2009-07-30 04:17:52'); +-------------------------------------------------------------+ |(to_date(2009-07-30 04:17:52) > to_date(2009-07-30 04:17:52))| +-------------------------------------------------------------+ | false| +-------------------------------------------------------------+ SELECT to_date('2009-07-30 04:17:52') > to_date('2009-08-01 04:17:52'); +-------------------------------------------------------------+ |(to_date(2009-07-30 04:17:52) > to_date(2009-08-01 04:17:52))| +-------------------------------------------------------------+ | false| +-------------------------------------------------------------+ SELECT 1 > NULL; +----------+ |(1 > NULL)| +----------+ | NULL| +----------+ -- >= SELECT 2 >= 1; +--------+ |(2 >= 1)| +--------+ | true| +--------+ SELECT 2.0 >= '2.1'; +------------+ |(2.0 >= 2.1)| +------------+ | false| +------------+ SELECT to_date('2009-07-30 04:17:52') >= to_date('2009-07-30 04:17:52'); +--------------------------------------------------------------+ |(to_date(2009-07-30 04:17:52) >= to_date(2009-07-30 04:17:52))| +--------------------------------------------------------------+ | true| +--------------------------------------------------------------+ SELECT to_date('2009-07-30 04:17:52') >= to_date('2009-08-01 04:17:52'); +--------------------------------------------------------------+ |(to_date(2009-07-30 04:17:52) >= to_date(2009-08-01 04:17:52))| +--------------------------------------------------------------+ | false| +--------------------------------------------------------------+ SELECT 1 >= NULL; +-----------+ |(1 >= NULL)| +-----------+ | NULL| +-----------+ -- and SELECT true and true; +---------------+ |(true AND true)| +---------------+ | true| +---------------+ SELECT true and false; +----------------+ |(true AND false)| +----------------+ | false| +----------------+ SELECT true and NULL; +---------------+ |(true AND NULL)| +---------------+ | NULL| +---------------+ SELECT false and NULL; +----------------+ |(false AND NULL)| +----------------+ | false| +----------------+ -- ilike SELECT ilike('Wagon', '_Agon'); +-------------------+ |ilike(Wagon, _Agon)| +-------------------+ | true| +-------------------+ SELECT '%SystemDrive%\Users\John' ilike '\%SystemDrive\%\\users%'; +--------------------------------------------------------+ |ilike(%SystemDrive%\Users\John, \%SystemDrive\%\\users%)| +--------------------------------------------------------+ | true| +--------------------------------------------------------+ SELECT '%SystemDrive%\\USERS\\John' ilike '\%SystemDrive\%\\\\Users%'; +--------------------------------------------------------+ |ilike(%SystemDrive%\USERS\John, \%SystemDrive\%\\Users%)| +--------------------------------------------------------+ | true| +--------------------------------------------------------+ SELECT '%SystemDrive%/Users/John' ilike '/%SYSTEMDrive/%//Users%' ESCAPE '/'; +--------------------------------------------------------+ |ilike(%SystemDrive%/Users/John, /%SYSTEMDrive/%//Users%)| +--------------------------------------------------------+ | true| +--------------------------------------------------------+ -- in SELECT 1 in(1, 2, 3); +----------------+ |(1 IN (1, 2, 3))| +----------------+ | true| +----------------+ SELECT 1 in(2, 3, 4); +----------------+ |(1 IN (2, 3, 4))| +----------------+ | false| +----------------+ SELECT named_struct('a', 1, 'b', 2) in(named_struct('a', 1, 'b', 1), named_struct('a', 1, 'b', 3)); +----------------------------------------------------------------------------------+ |(named_struct(a, 1, b, 2) IN (named_struct(a, 1, b, 1), named_struct(a, 1, b, 3)))| +----------------------------------------------------------------------------------+ | false| +----------------------------------------------------------------------------------+ SELECT named_struct('a', 1, 'b', 2) in(named_struct('a', 1, 'b', 2), named_struct('a', 1, 'b', 3)); +----------------------------------------------------------------------------------+ |(named_struct(a, 1, b, 2) IN (named_struct(a, 1, b, 2), named_struct(a, 1, b, 3)))| +----------------------------------------------------------------------------------+ | true| +----------------------------------------------------------------------------------+ -- isnan SELECT isnan(cast('NaN' as double)); +--------------------------+ |isnan(CAST(NaN AS DOUBLE))| +--------------------------+ | true| +--------------------------+ -- isnotnull SELECT isnotnull(1); +---------------+ |(1 IS NOT NULL)| +---------------+ | true| +---------------+ -- isnull SELECT isnull(1); +-----------+ |(1 IS NULL)| +-----------+ | false| +-----------+ -- like SELECT like('Wagon', '_Agon'); +----------------+ |Wagon LIKE _Agon| +----------------+ | true| +----------------+ -- not SELECT not true; +----------+ |(NOT true)| +----------+ | false| +----------+ SELECT not false; +-----------+ |(NOT false)| +-----------+ | true| +-----------+ SELECT not NULL; +----------+ |(NOT NULL)| +----------+ | NULL| +----------+ -- or SELECT true or false; +---------------+ |(true OR false)| +---------------+ | true| +---------------+ SELECT false or false; +----------------+ |(false OR false)| +----------------+ | false| +----------------+ SELECT true or NULL; +--------------+ |(true OR NULL)| +--------------+ | true| +--------------+ SELECT false or NULL; +---------------+ |(false OR NULL)| +---------------+ | NULL| +---------------+ ``` #### 맵 함수 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). **** | 함수 | 설명 | | --- | --- | | element\$1at(array, index) | 지정된 (1 기반) 인덱스에서 배열의 요소를 반환합니다. | | element\$1at(map, key) | 지정된 키의 값을 반환합니다. 키가 맵에 포함되지 않은 경우 이 함수는 NULL을 반환합니다. | | map(key0, value0, key1, value1, ...) | 지정된 키/값 페어로 맵을 생성합니다. | | map\$1concat(map, ...) | 지정된 모든 맵의 합집합을 반환합니다. | | map\$1contains\$1key(map, key) | 맵에 키가 포함되어 있는 경우 true를 반환합니다. | | map\$1entries(map) | 지정된 맵에 있는 모든 항목의 정렬되지 않은 배열을 반환합니다. | | map\$1from\$1arrays(keys, values) | 지정된 키/값 배열 페어로 맵을 생성합니다. 키의 모든 요소는 null이 아니어야 합니다. | | map\$1from\$1entries(arrayOfEntries) | 지정된 항목 배열에서 생성된 맵을 반환합니다. | | map\$1keys(map) | 맵의 키가 포함된 정렬되지 않은 배열을 반환합니다. | | map\$1values(map) | 맵의 값이 포함된 정렬되지 않은 배열을 반환합니다. | | str\$1to\$1map(text[, pairDelim[, keyValueDelim]]) | 구분 기호를 사용하여 텍스트를 키/값 페어로 분할한 후 맵을 생성합니다. 기본 구분 기호는 `pairDelim`의 경우 ',', `keyValueDelim`의 경우 ':'입니다. `pairDelim`과 `keyValueDelim`은 모두 정규식으로 처리됩니다. | | try\$1element\$1at(array, index) | 지정된 (1 기반) 인덱스에서 배열의 요소를 반환합니다. 인덱스가 0이면 시스템에서 오류가 발생합니다. 인덱스가 0보다 작으면 마지막에서 첫 번째로 요소에 액세스합니다. 인덱스가 배열 길이를 초과하면 함수는 항상 NULL을 반환합니다. | | try\$1element\$1at(map, key) | 지정된 키의 값을 반환합니다. 키가 맵에 포함되지 않은 경우 이 함수는 항상 NULL을 반환합니다. | **예시** ``` -- element_at SELECT element_at(array(1, 2, 3), 2); +-----------------------------+ |element_at(array(1, 2, 3), 2)| +-----------------------------+ | 2| +-----------------------------+ SELECT element_at(map(1, 'a', 2, 'b'), 2); +------------------------------+ |element_at(map(1, a, 2, b), 2)| +------------------------------+ | b| +------------------------------+ -- map SELECT map(1.0, '2', 3.0, '4'); +--------------------+ | map(1.0, 2, 3.0, 4)| +--------------------+ |{1.0 -> 2, 3.0 -> 4}| +--------------------+ -- map_concat SELECT map_concat(map(1, 'a', 2, 'b'), map(3, 'c')); +--------------------------------------+ |map_concat(map(1, a, 2, b), map(3, c))| +--------------------------------------+ | {1 -> a, 2 -> b, ...| +--------------------------------------+ -- map_contains_key SELECT map_contains_key(map(1, 'a', 2, 'b'), 1); +------------------------------------+ |map_contains_key(map(1, a, 2, b), 1)| +------------------------------------+ | true| +------------------------------------+ SELECT map_contains_key(map(1, 'a', 2, 'b'), 3); +------------------------------------+ |map_contains_key(map(1, a, 2, b), 3)| +------------------------------------+ | false| +------------------------------------+ -- map_entries SELECT map_entries(map(1, 'a', 2, 'b')); +----------------------------+ |map_entries(map(1, a, 2, b))| +----------------------------+ | [{1, a}, {2, b}]| +----------------------------+ -- map_from_arrays SELECT map_from_arrays(array(1.0, 3.0), array('2', '4')); +---------------------------------------------+ |map_from_arrays(array(1.0, 3.0), array(2, 4))| +---------------------------------------------+ | {1.0 -> 2, 3.0 -> 4}| +---------------------------------------------+ -- map_from_entries SELECT map_from_entries(array(struct(1, 'a'), struct(2, 'b'))); +---------------------------------------------------+ |map_from_entries(array(struct(1, a), struct(2, b)))| +---------------------------------------------------+ | {1 -> a, 2 -> b}| +---------------------------------------------------+ -- map_keys SELECT map_keys(map(1, 'a', 2, 'b')); +-------------------------+ |map_keys(map(1, a, 2, b))| +-------------------------+ | [1, 2]| +-------------------------+ -- map_values SELECT map_values(map(1, 'a', 2, 'b')); +---------------------------+ |map_values(map(1, a, 2, b))| +---------------------------+ | [a, b]| +---------------------------+ -- str_to_map SELECT str_to_map('a:1,b:2,c:3', ',', ':'); +-----------------------------+ |str_to_map(a:1,b:2,c:3, ,, :)| +-----------------------------+ | {a -> 1, b -> 2, ...| +-----------------------------+ SELECT str_to_map('a'); +-------------------+ |str_to_map(a, ,, :)| +-------------------+ | {a -> NULL}| +-------------------+ -- try_element_at SELECT try_element_at(array(1, 2, 3), 2); +---------------------------------+ |try_element_at(array(1, 2, 3), 2)| +---------------------------------+ | 2| +---------------------------------+ SELECT try_element_at(map(1, 'a', 2, 'b'), 2); +----------------------------------+ |try_element_at(map(1, a, 2, b), 2)| +----------------------------------+ | b| +----------------------------------+ ``` #### 수학 함수 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). **** | 함수 | 설명 | | --- | --- | | expr1 % expr2 | `expr1`/`expr2` 뒤의 나머지 부분을 반환합니다. | | expr1 \$1 expr2 | `expr1`\$1`expr2`를 반환합니다. | | expr1 \$1 expr2 | `expr1`\$1`expr2`를 반환합니다. | | expr1 - expr2 | `expr1`-`expr2`를 반환합니다. | | expr1 / expr2 | `expr1`/`expr2`를 반환합니다. 항상 부동 소수점 분할을 수행합니다. | | abs(expr) | 값의 절대값을 반환합니다. | | acos(expr) | `java.lang.Math.acos`로 계산된 것처럼, `expr`의 역코사인(아크 코사인)을 반환합니다. | | acosh(expr) | `expr`의 역 하이퍼볼릭 코사인을 반환합니다. | | asin(expr) | `java.lang.Math.asin`으로 계산되는 것처럼 `expr`의 역사인(아크 사인)을 반환합니다. | | asinh(expr) | `expr`의 역 하이퍼볼릭 사인을 반환합니다. | | atan(expr) | `java.lang.Math.atan`으로 계산된 것처럼 `expr`의 역탄젠트(아크 탄젠트)를 반환합니다. | | atan2(exprY, exprX) | `java.lang.Math.atan2`로 계산된 것처럼 평면의 양수 x축과 좌표로 지정된 점(`exprX`, `exprY`) 사이의 각도를 라디안 단위로 반환합니다. | | atanh(expr) | `expr`의 역 하이퍼볼릭 탄젠트를 반환합니다. | | bin(expr) | 바이너리로 표시되는 long 값 `expr`의 문자열 표현을 반환합니다. | | bround(expr, d) | HALF\$1EVEN 반올림 모드를 사용하여 `d` 소수 자릿수로 반올림된 `expr`를 반환합니다. | | cbrt(expr) | `expr`의 세제곱근을 반환합니다. | | ceil(expr[, scale]) | 반올림 후 `expr`보다 작지 않은 가장 작은 숫자를 반환합니다. 반올림 동작을 제어하기 위해 선택적 `scale` 파라미터를 지정할 수 있습니다. | | ceiling(expr[, scale]) | 반올림 후 `expr`보다 작지 않은 가장 작은 숫자를 반환합니다. 반올림 동작을 제어하기 위해 선택적 `scale` 파라미터를 지정할 수 있습니다. | | conv(num, from\$1base, to\$1base) | `num`을 `from\$1base`에서 `to\$1base`로 변환합니다. | | cos(expr) | `java.lang.Math.cos`로 계산된 것처럼 `expr`의 코사인을 반환합니다. | | cosh(expr) | `java.lang.Math.cosh`로 계산된 것처럼 `expr`의 하이퍼볼릭 코사인을 반환합니다. | | cot(expr) | `1/java.lang.Math.tan`으로 계산된 것처럼 `expr`의 코탄젠트를 반환합니다. | | csc(expr) | `1/java.lang.Math.sin`으로 계산되는 것처럼 `expr`의 코시컨트를 반환합니다. | | degrees(expr) | 라디안을 도로 변환합니다. | | expr1 div expr2 | `expr1`을 `expr2`로 나눕니다. 피연산자가 NULL이거나 `expr2`가 0인 경우 NULL을 반환합니다. 결과는 long으로 캐스팅됩니다. | | e() | Euler의 번호 e를 반환합니다. | | exp(expr) | e를 `expr`의 출력으로 반환합니다. | | expm1(expr) - exp(`expr`)를 반환합니다. | 1 | | factorial(expr) | `expr`의 인수를 반환합니다. `expr`는 [0..20]입니다. 그렇지 않은 경우 null입니다. | | floor(expr[, scale]) | 반올림 후 `expr`보다 크지 않은 가장 큰 숫자를 반환합니다. 반올림 동작을 제어하기 위해 선택적 `scale` 파라미터를 지정할 수 있습니다. | | greatest(expr, ...) | null 값을 건너뛰면서 모든 파라미터의 가장 큰 값을 반환합니다. | | hex(expr) | `expr`를 16진수로 변환합니다. | | hypot(expr1, expr2) | sqrt(`expr1`\$1\$12 \$1 `expr2`\$1\$12)를 반환합니다. | | least(expr, ...) | null 값을 건너뛰면서 모든 파라미터의 가장 작은 값을 반환합니다. | | ln(expr) | `expr`의 자연 로그(밑 e)를 반환합니다. | | log(base, expr) | `base`와 함께 `expr`의 로그를 반환합니다. | | log10(expr) | base 10과 함께 `expr`의 로그를 반환합니다. | | log1p(expr) | log(1 \$1 `expr`)를 반환합니다. | | log2(expr) | base 2와 함께 `expr`의 로그를 반환합니다. | | expr1 mod expr2 | `expr1`/`expr2` 뒤의 나머지 부분을 반환합니다. | | negative(expr) | `expr`의 부호를 반전한 값을 반환합니다. | | pi() | pi를 반환합니다. | | pmod(expr1, expr2) | `expr1` mod `expr2`의 양수 값을 반환합니다. | | positive(expr) | `expr`의 값을 반환합니다. | | pow(expr1, expr2) | `expr1`을 `expr2`의 출력으로 제곱합니다. | | power(expr1, expr2) | `expr1`을 `expr2`의 출력으로 제곱합니다. | | radians(expr) | 각도를 라디안으로 변환합니다. | | rand([seed]) | [0, 1) 구간에 균일하게 값이 분포하는 독립적이고 동일하게 분포(i.i.d.)하는 임의의 값을 반환합니다. | | randn([seed]) | 표준 정규 분포에서 가져온 독립적이고 동일하게 분포(i.i.d.)하는 값이 있는 임의 값을 반환합니다. | | random([seed]) | [0, 1) 구간에 균일하게 값이 분포하는 독립적이고 동일하게 분포(i.i.d.)하는 임의의 값을 반환합니다. | | rint(expr) | 인수에 대한 값에서 가장 가깝고 수학 정수와 동일한 이중 값을 반환합니다. | | round(expr, d) | HALF\$1UP 반올림 모드를 사용하여 `d` 소수 자릿수로 반올림된 `expr`를 반환합니다. | | sec(expr) | `1/java.lang.Math.cos`로 계산된 것처럼 `expr`의 시컨트를 반환합니다. | | shiftleft(base, expr) | 비트 단위로 왼쪽 이동합니다. | | sign(expr) | `expr`이 음수, 0 또는 양수이므로 -1.0, 0.0 또는 1.0을 반환합니다. | | signum(expr) | `expr`이 음수, 0 또는 양수이므로 -1.0, 0.0 또는 1.0을 반환합니다. | | sin(expr) | `java.lang.Math.sin`으로 계산된 것처럼 `expr`의 사인을 반환합니다. | | sinh(expr) | `java.lang.Math.sinh`로 계산된 것처럼 `expr`의 하이퍼볼릭 사인을 반환합니다. | | sqrt(expr) | `expr`의 제곱근을 반환합니다. | | tan(expr) | `java.lang.Math.tan`으로 계산된 것처럼 `expr`의 탄젠트를 반환합니다. | | tanh(expr) | `java.lang.Math.tanh`로 계산된 것처럼 `expr`의 하이퍼볼릭 탄젠트를 반환합니다. | | try\$1add(expr1, expr2) | `expr1`과 `expr2`의 합계를 반환하며 오버플로 시 결과는 null입니다. 허용되는 입력 유형은 `\$1` 연산자와 동일합니다. | | try\$1divide(dividend, divisor) | `dividend`/`divisor`를 반환합니다. 항상 부동 소수점 분할을 수행합니다. `expr2`가 0인 경우 결과는 항상 null입니다. `dividend`는 숫자 또는 간격이어야 합니다. `divisor`는 숫자여야 합니다. | | try\$1multiply(expr1, expr2) | `expr1`\$1`expr2`를 반환하며 오버플로 시 결과는 null입니다. 허용되는 입력 유형은 `\$1` 연산자와 동일합니다. | | try\$1subtract(expr1, expr2) | `expr1`-`expr2`를 반환하며 오버플로 시 결과는 null입니다. 허용되는 입력 유형은 `-` 연산자와 동일합니다. | | unhex(expr) | 16진수 `expr`를 이진수로 변환합니다. | | width\$1bucket(value, min\$1value, max\$1value, num\$1bucket) | `min\$1value`\$1`max\$1value` 범위의 `num\$1bucket` 버킷이 있는 등가 히스토그램에서 `value`가 할당될 버킷 번호를 반환합니다. | **예시** ``` -- % SELECT 2 % 1.8; +---------+ |(2 % 1.8)| +---------+ | 0.2| +---------+ SELECT MOD(2, 1.8); +-----------+ |mod(2, 1.8)| +-----------+ | 0.2| +-----------+ -- * SELECT 2 * 3; +-------+ |(2 * 3)| +-------+ | 6| +-------+ -- + SELECT 1 + 2; +-------+ |(1 + 2)| +-------+ | 3| +-------+ -- - SELECT 2 - 1; +-------+ |(2 - 1)| +-------+ | 1| +-------+ -- / SELECT 3 / 2; +-------+ |(3 / 2)| +-------+ | 1.5| +-------+ SELECT 2L / 2L; +-------+ |(2 / 2)| +-------+ | 1.0| +-------+ -- abs SELECT abs(-1); +-------+ |abs(-1)| +-------+ | 1| +-------+ SELECT abs(INTERVAL -'1-1' YEAR TO MONTH); +----------------------------------+ |abs(INTERVAL '-1-1' YEAR TO MONTH)| +----------------------------------+ | INTERVAL '1-1' YE...| +----------------------------------+ -- acos SELECT acos(1); +-------+ |ACOS(1)| +-------+ | 0.0| +-------+ SELECT acos(2); +-------+ |ACOS(2)| +-------+ | NaN| +-------+ -- acosh SELECT acosh(1); +--------+ |ACOSH(1)| +--------+ | 0.0| +--------+ SELECT acosh(0); +--------+ |ACOSH(0)| +--------+ | NaN| +--------+ -- asin SELECT asin(0); +-------+ |ASIN(0)| +-------+ | 0.0| +-------+ SELECT asin(2); +-------+ |ASIN(2)| +-------+ | NaN| +-------+ -- asinh SELECT asinh(0); +--------+ |ASINH(0)| +--------+ | 0.0| +--------+ -- atan SELECT atan(0); +-------+ |ATAN(0)| +-------+ | 0.0| +-------+ -- atan2 SELECT atan2(0, 0); +-----------+ |ATAN2(0, 0)| +-----------+ | 0.0| +-----------+ -- atanh SELECT atanh(0); +--------+ |ATANH(0)| +--------+ | 0.0| +--------+ SELECT atanh(2); +--------+ |ATANH(2)| +--------+ | NaN| +--------+ -- bin SELECT bin(13); +-------+ |bin(13)| +-------+ | 1101| +-------+ SELECT bin(-13); +--------------------+ | bin(-13)| +--------------------+ |11111111111111111...| +--------------------+ SELECT bin(13.3); +---------+ |bin(13.3)| +---------+ | 1101| +---------+ -- bround SELECT bround(2.5, 0); +--------------+ |bround(2.5, 0)| +--------------+ | 2| +--------------+ SELECT bround(25, -1); +--------------+ |bround(25, -1)| +--------------+ | 20| +--------------+ -- cbrt SELECT cbrt(27.0); +----------+ |CBRT(27.0)| +----------+ | 3.0| +----------+ -- ceil SELECT ceil(-0.1); +----------+ |CEIL(-0.1)| +----------+ | 0| +----------+ SELECT ceil(5); +-------+ |CEIL(5)| +-------+ | 5| +-------+ SELECT ceil(3.1411, 3); +---------------+ |ceil(3.1411, 3)| +---------------+ | 3.142| +---------------+ SELECT ceil(3.1411, -3); +----------------+ |ceil(3.1411, -3)| +----------------+ | 1000| +----------------+ -- ceiling SELECT ceiling(-0.1); +-------------+ |ceiling(-0.1)| +-------------+ | 0| +-------------+ SELECT ceiling(5); +----------+ |ceiling(5)| +----------+ | 5| +----------+ SELECT ceiling(3.1411, 3); +------------------+ |ceiling(3.1411, 3)| +------------------+ | 3.142| +------------------+ SELECT ceiling(3.1411, -3); +-------------------+ |ceiling(3.1411, -3)| +-------------------+ | 1000| +-------------------+ -- conv SELECT conv('100', 2, 10); +----------------+ |conv(100, 2, 10)| +----------------+ | 4| +----------------+ SELECT conv(-10, 16, -10); +------------------+ |conv(-10, 16, -10)| +------------------+ | -16| +------------------+ -- cos SELECT cos(0); +------+ |COS(0)| +------+ | 1.0| +------+ -- cosh SELECT cosh(0); +-------+ |COSH(0)| +-------+ | 1.0| +-------+ -- cot SELECT cot(1); +------------------+ | COT(1)| +------------------+ |0.6420926159343306| +------------------+ -- csc SELECT csc(1); +------------------+ | CSC(1)| +------------------+ |1.1883951057781212| +------------------+ -- degrees SELECT degrees(3.141592653589793); +--------------------------+ |DEGREES(3.141592653589793)| +--------------------------+ | 180.0| +--------------------------+ -- div SELECT 3 div 2; +---------+ |(3 div 2)| +---------+ | 1| +---------+ SELECT INTERVAL '1-1' YEAR TO MONTH div INTERVAL '-1' MONTH; +------------------------------------------------------+ |(INTERVAL '1-1' YEAR TO MONTH div INTERVAL '-1' MONTH)| +------------------------------------------------------+ | -13| +------------------------------------------------------+ -- e SELECT e(); +-----------------+ | E()| +-----------------+ |2.718281828459045| +-----------------+ -- exp SELECT exp(0); +------+ |EXP(0)| +------+ | 1.0| +------+ -- expm1 SELECT expm1(0); +--------+ |EXPM1(0)| +--------+ | 0.0| +--------+ -- factorial SELECT factorial(5); +------------+ |factorial(5)| +------------+ | 120| +------------+ -- floor SELECT floor(-0.1); +-----------+ |FLOOR(-0.1)| +-----------+ | -1| +-----------+ SELECT floor(5); +--------+ |FLOOR(5)| +--------+ | 5| +--------+ SELECT floor(3.1411, 3); +----------------+ |floor(3.1411, 3)| +----------------+ | 3.141| +----------------+ SELECT floor(3.1411, -3); +-----------------+ |floor(3.1411, -3)| +-----------------+ | 0| +-----------------+ -- greatest SELECT greatest(10, 9, 2, 4, 3); +------------------------+ |greatest(10, 9, 2, 4, 3)| +------------------------+ | 10| +------------------------+ -- hex SELECT hex(17); +-------+ |hex(17)| +-------+ | 11| +-------+ SELECT hex('SQL'); +------------------+ | hex(SQL)| +------------------+ |53514C| +------------------+ -- hypot SELECT hypot(3, 4); +-----------+ |HYPOT(3, 4)| +-----------+ | 5.0| +-----------+ -- least SELECT least(10, 9, 2, 4, 3); +---------------------+ |least(10, 9, 2, 4, 3)| +---------------------+ | 2| +---------------------+ -- ln SELECT ln(1); +-----+ |ln(1)| +-----+ | 0.0| +-----+ -- log SELECT log(10, 100); +------------+ |LOG(10, 100)| +------------+ | 2.0| +------------+ -- log10 SELECT log10(10); +---------+ |LOG10(10)| +---------+ | 1.0| +---------+ -- log1p SELECT log1p(0); +--------+ |LOG1P(0)| +--------+ | 0.0| +--------+ -- log2 SELECT log2(2); +-------+ |LOG2(2)| +-------+ | 1.0| +-------+ -- mod SELECT 2 % 1.8; +---------+ |(2 % 1.8)| +---------+ | 0.2| +---------+ SELECT MOD(2, 1.8); +-----------+ |mod(2, 1.8)| +-----------+ | 0.2| +-----------+ -- negative SELECT negative(1); +-----------+ |negative(1)| +-----------+ | -1| +-----------+ -- pi SELECT pi(); +-----------------+ | PI()| +-----------------+ |3.141592653589793| +-----------------+ -- pmod SELECT pmod(10, 3); +-----------+ |pmod(10, 3)| +-----------+ | 1| +-----------+ SELECT pmod(-10, 3); +------------+ |pmod(-10, 3)| +------------+ | 2| +------------+ -- positive SELECT positive(1); +-----+ |(+ 1)| +-----+ | 1| +-----+ -- pow SELECT pow(2, 3); +---------+ |pow(2, 3)| +---------+ | 8.0| +---------+ -- power SELECT power(2, 3); +-----------+ |POWER(2, 3)| +-----------+ | 8.0| +-----------+ -- radians SELECT radians(180); +-----------------+ | RADIANS(180)| +-----------------+ |3.141592653589793| +-----------------+ -- rand SELECT rand(); +------------------+ | rand()| +------------------+ |0.7211420708112387| +------------------+ SELECT rand(0); +------------------+ | rand(0)| +------------------+ |0.7604953758285915| +------------------+ SELECT rand(null); +------------------+ | rand(NULL)| +------------------+ |0.7604953758285915| +------------------+ -- randn SELECT randn(); +-------------------+ | randn()| +-------------------+ |-0.8175603217732732| +-------------------+ SELECT randn(0); +------------------+ | randn(0)| +------------------+ |1.6034991609278433| +------------------+ SELECT randn(null); +------------------+ | randn(NULL)| +------------------+ |1.6034991609278433| +------------------+ -- random SELECT random(); +-----------------+ | rand()| +-----------------+ |0.394205008255365| +-----------------+ SELECT random(0); +------------------+ | rand(0)| +------------------+ |0.7604953758285915| +------------------+ SELECT random(null); +------------------+ | rand(NULL)| +------------------+ |0.7604953758285915| +------------------+ -- rint SELECT rint(12.3456); +-------------+ |rint(12.3456)| +-------------+ | 12.0| +-------------+ -- round SELECT round(2.5, 0); +-------------+ |round(2.5, 0)| +-------------+ | 3| +-------------+ -- sec SELECT sec(0); +------+ |SEC(0)| +------+ | 1.0| +------+ -- shiftleft SELECT shiftleft(2, 1); +---------------+ |shiftleft(2, 1)| +---------------+ | 4| +---------------+ -- sign SELECT sign(40); +--------+ |sign(40)| +--------+ | 1.0| +--------+ SELECT sign(INTERVAL -'100' YEAR); +--------------------------+ |sign(INTERVAL '-100' YEAR)| +--------------------------+ | -1.0| +--------------------------+ -- signum SELECT signum(40); +----------+ |SIGNUM(40)| +----------+ | 1.0| +----------+ SELECT signum(INTERVAL -'100' YEAR); +----------------------------+ |SIGNUM(INTERVAL '-100' YEAR)| +----------------------------+ | -1.0| +----------------------------+ -- sin SELECT sin(0); +------+ |SIN(0)| +------+ | 0.0| +------+ -- sinh SELECT sinh(0); +-------+ |SINH(0)| +-------+ | 0.0| +-------+ -- sqrt SELECT sqrt(4); +-------+ |SQRT(4)| +-------+ | 2.0| +-------+ -- tan SELECT tan(0); +------+ |TAN(0)| +------+ | 0.0| +------+ -- tanh SELECT tanh(0); +-------+ |TANH(0)| +-------+ | 0.0| +-------+ -- try_add SELECT try_add(1, 2); +-------------+ |try_add(1, 2)| +-------------+ | 3| +-------------+ SELECT try_add(2147483647, 1); +----------------------+ |try_add(2147483647, 1)| +----------------------+ | NULL| +----------------------+ SELECT try_add(date'2021-01-01', 1); +-----------------------------+ |try_add(DATE '2021-01-01', 1)| +-----------------------------+ | 2021-01-02| +-----------------------------+ SELECT try_add(date'2021-01-01', interval 1 year); +---------------------------------------------+ |try_add(DATE '2021-01-01', INTERVAL '1' YEAR)| +---------------------------------------------+ | 2022-01-01| +---------------------------------------------+ SELECT try_add(timestamp'2021-01-01 00:00:00', interval 1 day); +----------------------------------------------------------+ |try_add(TIMESTAMP '2021-01-01 00:00:00', INTERVAL '1' DAY)| +----------------------------------------------------------+ | 2021-01-02 00:00:00| +----------------------------------------------------------+ SELECT try_add(interval 1 year, interval 2 year); +---------------------------------------------+ |try_add(INTERVAL '1' YEAR, INTERVAL '2' YEAR)| +---------------------------------------------+ | INTERVAL '3' YEAR| +---------------------------------------------+ -- try_divide SELECT try_divide(3, 2); +----------------+ |try_divide(3, 2)| +----------------+ | 1.5| +----------------+ SELECT try_divide(2L, 2L); +----------------+ |try_divide(2, 2)| +----------------+ | 1.0| +----------------+ SELECT try_divide(1, 0); +----------------+ |try_divide(1, 0)| +----------------+ | NULL| +----------------+ SELECT try_divide(interval 2 month, 2); +---------------------------------+ |try_divide(INTERVAL '2' MONTH, 2)| +---------------------------------+ | INTERVAL '0-1' YE...| +---------------------------------+ SELECT try_divide(interval 2 month, 0); +---------------------------------+ |try_divide(INTERVAL '2' MONTH, 0)| +---------------------------------+ | NULL| +---------------------------------+ -- try_multiply SELECT try_multiply(2, 3); +------------------+ |try_multiply(2, 3)| +------------------+ | 6| +------------------+ SELECT try_multiply(-2147483648, 10); +-----------------------------+ |try_multiply(-2147483648, 10)| +-----------------------------+ | NULL| +-----------------------------+ SELECT try_multiply(interval 2 year, 3); +----------------------------------+ |try_multiply(INTERVAL '2' YEAR, 3)| +----------------------------------+ | INTERVAL '6-0' YE...| +----------------------------------+ -- try_subtract SELECT try_subtract(2, 1); +------------------+ |try_subtract(2, 1)| +------------------+ | 1| +------------------+ SELECT try_subtract(-2147483648, 1); +----------------------------+ |try_subtract(-2147483648, 1)| +----------------------------+ | NULL| +----------------------------+ SELECT try_subtract(date'2021-01-02', 1); +----------------------------------+ |try_subtract(DATE '2021-01-02', 1)| +----------------------------------+ | 2021-01-01| +----------------------------------+ SELECT try_subtract(date'2021-01-01', interval 1 year); +--------------------------------------------------+ |try_subtract(DATE '2021-01-01', INTERVAL '1' YEAR)| +--------------------------------------------------+ | 2020-01-01| +--------------------------------------------------+ SELECT try_subtract(timestamp'2021-01-02 00:00:00', interval 1 day); +---------------------------------------------------------------+ |try_subtract(TIMESTAMP '2021-01-02 00:00:00', INTERVAL '1' DAY)| +---------------------------------------------------------------+ | 2021-01-01 00:00:00| +---------------------------------------------------------------+ SELECT try_subtract(interval 2 year, interval 1 year); +--------------------------------------------------+ |try_subtract(INTERVAL '2' YEAR, INTERVAL '1' YEAR)| +--------------------------------------------------+ | INTERVAL '1' YEAR| +--------------------------------------------------+ -- unhex SELECT decode(unhex('53514C'), 'UTF-8'); +----------------------------------------+ |decode(unhex(53514C), UTF-8)| +----------------------------------------+ | SQL| +----------------------------------------+ -- width_bucket SELECT width_bucket(5.3, 0.2, 10.6, 5); +-------------------------------+ |width_bucket(5.3, 0.2, 10.6, 5)| +-------------------------------+ | 3| +-------------------------------+ SELECT width_bucket(-2.1, 1.3, 3.4, 3); +-------------------------------+ |width_bucket(-2.1, 1.3, 3.4, 3)| +-------------------------------+ | 0| +-------------------------------+ SELECT width_bucket(8.1, 0.0, 5.7, 4); +------------------------------+ |width_bucket(8.1, 0.0, 5.7, 4)| +------------------------------+ | 5| +------------------------------+ SELECT width_bucket(-0.9, 5.2, 0.5, 2); +-------------------------------+ |width_bucket(-0.9, 5.2, 0.5, 2)| +-------------------------------+ | 3| +-------------------------------+ SELECT width_bucket(INTERVAL '0' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10); +--------------------------------------------------------------------------+ |width_bucket(INTERVAL '0' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10)| +--------------------------------------------------------------------------+ | 1| +--------------------------------------------------------------------------+ SELECT width_bucket(INTERVAL '1' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10); +--------------------------------------------------------------------------+ |width_bucket(INTERVAL '1' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10)| +--------------------------------------------------------------------------+ | 2| +--------------------------------------------------------------------------+ SELECT width_bucket(INTERVAL '0' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10); +-----------------------------------------------------------------------+ |width_bucket(INTERVAL '0' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10)| +-----------------------------------------------------------------------+ | 1| +-----------------------------------------------------------------------+ SELECT width_bucket(INTERVAL '1' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10); +-----------------------------------------------------------------------+ |width_bucket(INTERVAL '1' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10)| +-----------------------------------------------------------------------+ | 2| +-----------------------------------------------------------------------+ ``` #### 생성 함수 **참고** 이러한 SQL 함수를 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). **** | 함수 | 설명 | | --- | --- | | explode(expr) | 배열 `expr`의 요소를 여러 행으로 구분하거나 `expr`의 요소를 여러 행과 열로 매핑합니다. 달리 지정하지 않는 한, 배열 요소에 기본 열 이름 `col`을 사용하거나 맵 요소에 `key` 및 `value`를 사용합니다. | | explode\$1outer(expr) | 배열 `expr`의 요소를 여러 행으로 구분하거나 `expr`의 요소를 여러 행과 열로 매핑합니다. 달리 지정하지 않는 한, 배열 요소에 기본 열 이름 `col`을 사용하거나 맵 요소에 `key` 및 `value`를 사용합니다. | | inline(expr) | 구문의 배열을 테이블로 탐색합니다. 달리 지정하지 않는 한, 기본적으로 열 이름 col1, col2 등을 사용합니다. | | inline\$1outer(expr) | 구문의 배열을 테이블로 탐색합니다. 달리 지정하지 않는 한, 기본적으로 열 이름 col1, col2 등을 사용합니다. | | posexplode(expr) | 배열 `expr`의 요소를 위치가 있는 여러 행으로 구분하거나 맵 `expr`의 요소를 위치가 있는 여러 행과 열로 구분합니다. 달리 지정하지 않는 한, 위치에 열 이름 `pos`, 배열의 요소에 `col` 또는 맵의 요소에 `key` 및 `value`를 사용합니다. | | posexplode\$1outer(expr) | 배열 `expr`의 요소를 위치가 있는 여러 행으로 구분하거나 맵 `expr`의 요소를 위치가 있는 여러 행과 열로 구분합니다. 달리 지정하지 않는 한, 위치에 열 이름 `pos`, 배열의 요소에 `col` 또는 맵의 요소에 `key` 및 `value`를 사용합니다. | | stack(n, expr1, ..., exprk) | `expr1`, ..., `exprk`를 `n` 행으로 구분합니다. 달리 지정하지 않는 한, 기본적으로 열 이름 col0, col1 등을 사용합니다. | **예시** ``` -- explode SELECT explode(array(10, 20)); +---+ |col| +---+ | 10| | 20| +---+ SELECT explode(collection => array(10, 20)); +---+ |col| +---+ | 10| | 20| +---+ SELECT * FROM explode(collection => array(10, 20)); +---+ |col| +---+ | 10| | 20| +---+ -- explode_outer SELECT explode_outer(array(10, 20)); +---+ |col| +---+ | 10| | 20| +---+ SELECT explode_outer(collection => array(10, 20)); +---+ |col| +---+ | 10| | 20| +---+ SELECT * FROM explode_outer(collection => array(10, 20)); +---+ |col| +---+ | 10| | 20| +---+ -- inline SELECT inline(array(struct(1, 'a'), struct(2, 'b'))); +----+----+ |col1|col2| +----+----+ | 1| a| | 2| b| +----+----+ -- inline_outer SELECT inline_outer(array(struct(1, 'a'), struct(2, 'b'))); +----+----+ |col1|col2| +----+----+ | 1| a| | 2| b| +----+----+ -- posexplode SELECT posexplode(array(10,20)); +---+---+ |pos|col| +---+---+ | 0| 10| | 1| 20| +---+---+ SELECT * FROM posexplode(array(10,20)); +---+---+ |pos|col| +---+---+ | 0| 10| | 1| 20| +---+---+ -- posexplode_outer SELECT posexplode_outer(array(10,20)); +---+---+ |pos|col| +---+---+ | 0| 10| | 1| 20| +---+---+ SELECT * FROM posexplode_outer(array(10,20)); +---+---+ |pos|col| +---+---+ | 0| 10| | 1| 20| +---+---+ -- stack SELECT stack(2, 1, 2, 3); +----+----+ |col0|col1| +----+----+ | 1| 2| | 3|NULL| +----+----+ ``` #### SELECT 절 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). OpenSearch SQL은 하나 이상의 테이블에서 결과 세트를 검색하는 데 사용되는 `SELECT` 문을 지원합니다. 다음 섹션에서는 전체 쿼리 구문과 쿼리의 다양한 구문에 대해 설명합니다. **구문** ``` select_statement [ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select_statement, ... ] [ ORDER BY { expression [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [ , ... ] } ] [ SORT BY { expression [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [ , ... ] } ] [ WINDOW { named_window [ , WINDOW named_window, ... ] } ] [ LIMIT { ALL | expression } ] ``` `select_statement`는 다음과 같이 정의됩니다. ``` SELECT [ ALL | DISTINCT ] { [ [ named_expression ] [ , ... ] ] } FROM { from_item [ , ... ] } [ PIVOT clause ] [ UNPIVOT clause ] [ LATERAL VIEW clause ] [ ... ] [ WHERE boolean_expression ] [ GROUP BY expression [ , ... ] ] [ HAVING boolean_expression ] ``` **파라미터** + **모두** 관계에서 일치하는 모든 행을 선택하며 기본적으로 활성화됩니다. + **DISTINCT** 결과에서 중복 항목을 제거한 후 관계에서 일치하는 모든 행을 선택합니다. + **named\$1expression ** 이름이 할당된 표현식입니다. 일반적으로 열 표현식을 나타냅니다. 구문: `expression [[AS] alias]` + **from\$1item ** 테이블 관계 조인 관계 피벗 관계 언피벗 관계 테이블 값 함수 인라인 테이블 `[ LATERAL ] ( Subquery )` + **PIVOT** `PIVOT` 절은 데이터와 관련하여 사용됩니다. 특정 열 값을 기반으로 집계된 값을 가져올 수 있습니다. + **UNPIVOT** `UNPIVOT` 절은 열을 행으로 변환합니다. 값 집계를 제외하고 `PIVOT`의 반대입니다. + **LATERAL VIEW ** `LATERAL VIEW` 절은 하나 이상의 행이 포함된 가상 테이블을 생성하는 `EXPLODE`와 같은 생성 함수와 함께 사용됩니다. `LATERAL VIEW`는 각 원래 출력 행에 행을 적용합니다. + **WHERE** 제공된 조건자를 기준으로 `FROM` 절의 결과를 필터링합니다. + **그룹화 기준 ** 행을 그룹화하는 데 사용되는 표현식을 지정합니다. 이는 집계 함수(`MIN`, `MAX`, `COUNT`, `SUM`, `AVG` 등)와 함께 각 그룹의 그룹화 표현식 및 집계 값을 기반으로 행을 그룹화하는 데 사용됩니다. `FILTER` 절이 집계 함수에 연결되면 일치하는 행만 해당 함수에 전달됩니다. + **보유** `GROUP BY`에 의해 생성된 행이 필터링되는 조건자를 지정합니다. `HAVING` 절은 그룹화가 수행된 후 행을 필터링하는 데 사용됩니다. `GROUP BY` 없이 `HAVING`를 지정하면 그룹화 표현식(글로벌 집계)이 없는 `GROUP BY`를 나타냅니다. + **ORDER BY ** 쿼리의 전체 결과 집합 행 순서를 지정합니다. 출력 행은 여러 파티션에 걸쳐 정렬됩니다. 이 파라미터는 `SORT BY` 및 `DISTRIBUTE BY`와 상호 배타적이며 함께 지정할 수 없습니다. + **SORT BY ** 각 파티션 내에서 행이 정렬되는 순서를 지정합니다. 이 파라미터는 `ORDER BY`와 상호 배타적이며 함께 지정할 수 없습니다. + **LIMIT** 문 또는 하위 쿼리에서 반환할 수 있는 최대 행 수를 지정합니다. 이 절은 주로 `ORDER BY`와 함께 결정적 결과를 생성하는 데 사용됩니다. + **boolean\$1expression ** 결과 유형 부울로 평가되는 표현식을 지정합니다. 논리 연산자(`AND`, `OR`)를 사용하여 둘 이상의 표현식을 결합할 수 있습니다. + **expression** 하나 이상의 값, 연산자 및 값으로 평가되는 SQL 함수의 조합을 지정합니다. + **named\$1window ** 하나 이상의 소스 윈도우 사양에 대한 별칭을 지정합니다. 소스 윈도우 사양은 쿼리의 윈도우 정의에서 참조할 수 있습니다. #### WHERE 절 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). `WHERE` 절은 지정된 조건에 따라 쿼리 또는 하위 쿼리의 `FROM` 절 결과를 제한하는 데 사용됩니다. **구문** ``` WHERE boolean_expression ``` **파라미터** + **boolean\$1expression** 결과 유형 부울로 평가되는 표현식을 지정합니다. 논리 연산자(`AND`, `OR`)를 사용하여 둘 이상의 표현식을 결합할 수 있습니다. **예시** ``` CREATE TABLE person (id INT, name STRING, age INT); INSERT INTO person VALUES (100, 'John', 30), (200, 'Mary', NULL), (300, 'Mike', 80), (400, 'Dan', 50); -- Comparison operator in `WHERE` clause. SELECT * FROM person WHERE id > 200 ORDER BY id; +---+----+---+ | id|name|age| +---+----+---+ |300|Mike| 80| |400| Dan| 50| +---+----+---+ -- Comparison and logical operators in `WHERE` clause. SELECT * FROM person WHERE id = 200 OR id = 300 ORDER BY id; +---+----+----+ | id|name| age| +---+----+----+ |200|Mary|null| |300|Mike| 80| +---+----+----+ -- IS NULL expression in `WHERE` clause. SELECT * FROM person WHERE id > 300 OR age IS NULL ORDER BY id; +---+----+----+ | id|name| age| +---+----+----+ |200|Mary|null| |400| Dan| 50| +---+----+----+ -- Function expression in `WHERE` clause. SELECT * FROM person WHERE length(name) > 3 ORDER BY id; +---+----+----+ | id|name| age| +---+----+----+ |100|John| 30| |200|Mary|null| |300|Mike| 80| +---+----+----+ -- `BETWEEN` expression in `WHERE` clause. SELECT * FROM person WHERE id BETWEEN 200 AND 300 ORDER BY id; +---+----+----+ | id|name| age| +---+----+----+ |200|Mary|null| |300|Mike| 80| +---+----+----+ -- Scalar Subquery in `WHERE` clause. SELECT * FROM person WHERE age > (SELECT avg(age) FROM person); +---+----+---+ | id|name|age| +---+----+---+ |300|Mike| 80| +---+----+---+ -- Correlated Subquery in `WHERE` clause. SELECT id FROM person WHERE exists (SELECT id FROM person where id = 200); +---+----+----+ |id |name|age | +---+----+----+ |200|Mary|null| +---+----+----+ ``` #### GROUP BY 절 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). `GROUP BY` 절은 지정된 그룹화 표현식 세트를 기반으로 행을 그룹화하고, 하나 이상의 지정된 집계 함수를 기반으로 행 그룹에 대한 집계를 계산하는 데 사용됩니다. 또한 시스템은 `GROUPING SETS`, `CUBE`, `ROLLUP` 절을 통해 동일한 입력 레코드 세트에 대해 여러 집계를 수행합니다. 그룹화 표현식과 고급 집계는 `GROUP BY` 절에서 혼합하고 `GROUPING SETS ` 절에서 중첩할 수 있습니다. 자세한 내용은 `Mixed/Nested Grouping Analytics ` 섹션을 참조하세요. `FILTER` 절이 집계 함수에 연결되면 일치하는 행만 해당 함수에 전달됩니다. **구문** ``` GROUP BY group_expression [ , group_expression [ , ... ] ] [ WITH { ROLLUP | CUBE } ] GROUP BY { group_expression | { ROLLUP | CUBE | GROUPING SETS } (grouping_set [ , ...]) } [ , ... ] ``` 집계 함수는 다음과 같이 정의됩니다. ``` aggregate_name ( [ DISTINCT ] expression [ , ... ] ) [ FILTER ( WHERE boolean_expression ) ] ``` **파라미터** + **group\$1expression ** 행을 그룹화할 기준을 지정합니다. 행 그룹화는 그룹화 표현식의 결과 값에 따라 수행됩니다. 그룹화 표현식은 `GROUP BY a`와 같은 열 이름, `GROUP BY 0`과 같은 열 위치 또는 `GROUP BY a + b`와 같은 표현식일 수 있습니다. + **grouping\$1set ** 그룹화 세트는 괄호 안에 0개 이상의 쉼표로 구분된 표현식으로 지정됩니다. 그룹화 세트에 요소가 하나만 있는 경우 괄호를 생략할 수 있습니다. 예를 들어 `GROUPING SETS ((a), (b))`는 `GROUPING SETS (a, b)`와 동일합니다. 구문: `{ ( [ expression [ , ... ] ] ) | expression }` + **GROUPING SETS ** `GROUPING SETS` 뒤에 지정된 각 그룹화 세트의 행을 그룹화합니다. 예를 들어 `GROUP BY GROUPING SETS ((warehouse), (product))`는 의미상 `GROUP BY warehouse` 및 `GROUP BY product`의 결과 조합과 동일합니다. 이 절은 UNION ALL의 축약형으로, `UNION ALL` 연산자의 각 분기가 `GROUPING SETS` 절에 지정된 각 그룹화 세트에 대한 집계를 수행합니다. 마찬가지로 `GROUP BY GROUPING SETS ((warehouse, product), (product), ())`는 의미상 `GROUP BY warehouse, product, GROUP BY product` 및 전역 집계의 결과 조합과 동일합니다. + **ROLLUP** 단일 문에서 여러 수준의 집계를 지정합니다. 이 절은 여러 그룹화 세트를 기반으로 집계를 계산하는 데 사용됩니다. `ROLLUP`는 `GROUPING SETS`의 축약형입니다. 예를 들어, `GROUP BY warehouse, product WITH ROLLUP or GROUP BY ROLLUP(warehouse, product)`은 `GROUP BY GROUPING SETS((warehouse, product), (warehouse), ())`과 같습니다. `GROUP BY ROLLUP(warehouse, product, (warehouse, location))`은 `GROUP BY GROUPING SETS((warehouse, product, location), (warehouse, product), (warehouse), ())`와 동일합니다. ROLLUP 사양의 N 요소는 N\$11 GROUPING SETS가 됩니다. + **CUBE** CUBE 절은 GROUP BY 절에 지정된 그룹화 열의 조합을 기반으로 집계를 수행하는 데 사용됩니다. CUBE는 GROUPING SETS의 축약형입니다. 예를 들어, `GROUP BY warehouse, product WITH CUBE or GROUP BY CUBE(warehouse, product)`은 `GROUP BY GROUPING SETS((warehouse, product), (warehouse), (product), ())`과 같습니다. `GROUP BY CUBE(warehouse, product, (warehouse, location))`은 `GROUP BY GROUPING SETS((warehouse, product, location), (warehouse, product), (warehouse, location), (product, warehouse, location), (warehouse), (product), (warehouse, product), ())`와 동일합니다. `CUBE` 사양의 N 요소는 2^N `GROUPING SETS`가 됩니다. + **혼합/중첩 그룹화 분석 ** `GROUP BY` 절에는 여러 group\$1expressions 및 여러 `CUBE|ROLLUP|GROUPING SETS`가 포함될 수 있습니다. `GROUPING SETS`에는 `GROUPING SETS(ROLLUP(warehouse, location)`, `CUBE(warehouse, location))`, `GROUPING SETS(warehouse, GROUPING SETS(location, GROUPING SETS(ROLLUP(warehouse, location),` `CUBE(warehouse, location))))`와 같은 중첩된 `CUBE|ROLLUP|GROUPING SETS` 절도 있을 수 있습니다. `CUBE|ROLLUP`는 `GROUPING SETS`의 간결한 구문일 뿐입니다. `CUBE|ROLLUP`을 `GROUPING SETS`로 변환하는 방법은 위의 섹션을 참조하세요. `group_expression`은 이 컨텍스트에서 단일 그룹 `GROUPING SETS`로 취급될 수 있습니다. `GROUP BY` 절의 여러 `GROUPING SETS`에 대해 원래 `GROUPING SETS`의 교차 곱을 수행하여 단일 `GROUPING SETS`을 생성합니다. `GROUPING SETS` 절에서 중첩된 `GROUPING SETS`의 경우 그룹화 세트를 가져와 제거합니다. 예를 들어, `GROUP BY warehouse, GROUPING SETS((product), ()), GROUPING SETS((location, size), (location), (size), ()) and GROUP BY warehouse, ROLLUP(product), CUBE(location, size)`은 `GROUP BY GROUPING SETS( (warehouse, product, location, size), (warehouse, product, location), (warehouse, product, size), (warehouse, product), (warehouse, location, size), (warehouse, location), (warehouse, size), (warehouse))`과 같습니다. `GROUP BY GROUPING SETS(GROUPING SETS(warehouse), GROUPING SETS((warehouse, product)))`은 `GROUP BY GROUPING SETS((warehouse), (warehouse, product))`와 동일합니다. + **aggregate\$1name ** 집계 함수 이름(`MIN`, `MAX`, `COUNT`, `SUM`, `AVG` 등)을 지정합니다. + **DISTINCT** 집계 함수로 전달되기 전에 입력 행의 중복을 제거합니다. + **필터** `WHERE` 절의 `boolean_expression`이 true로 평가되는 입력 행을 필터링하여 집계 함수로 전달하고 다른 행은 삭제됩니다. **예시** ``` CREATE TABLE dealer (id INT, city STRING, car_model STRING, quantity INT); INSERT INTO dealer VALUES (100, 'Fremont', 'Honda Civic', 10), (100, 'Fremont', 'Honda Accord', 15), (100, 'Fremont', 'Honda CRV', 7), (200, 'Dublin', 'Honda Civic', 20), (200, 'Dublin', 'Honda Accord', 10), (200, 'Dublin', 'Honda CRV', 3), (300, 'San Jose', 'Honda Civic', 5), (300, 'San Jose', 'Honda Accord', 8); -- Sum of quantity per dealership. Group by `id`. SELECT id, sum(quantity) FROM dealer GROUP BY id ORDER BY id; +---+-------------+ | id|sum(quantity)| +---+-------------+ |100| 32| |200| 33| |300| 13| +---+-------------+ -- Use column position in GROUP by clause. SELECT id, sum(quantity) FROM dealer GROUP BY 1 ORDER BY 1; +---+-------------+ | id|sum(quantity)| +---+-------------+ |100| 32| |200| 33| |300| 13| +---+-------------+ -- Multiple aggregations. -- 1. Sum of quantity per dealership. -- 2. Max quantity per dealership. SELECT id, sum(quantity) AS sum, max(quantity) AS max FROM dealer GROUP BY id ORDER BY id; +---+---+---+ | id|sum|max| +---+---+---+ |100| 32| 15| |200| 33| 20| |300| 13| 8| +---+---+---+ -- Count the number of distinct dealer cities per car_model. SELECT car_model, count(DISTINCT city) AS count FROM dealer GROUP BY car_model; +------------+-----+ | car_model|count| +------------+-----+ | Honda Civic| 3| | Honda CRV| 2| |Honda Accord| 3| +------------+-----+ -- Sum of only 'Honda Civic' and 'Honda CRV' quantities per dealership. SELECT id, sum(quantity) FILTER ( WHERE car_model IN ('Honda Civic', 'Honda CRV') ) AS `sum(quantity)` FROM dealer GROUP BY id ORDER BY id; +---+-------------+ | id|sum(quantity)| +---+-------------+ |100| 17| |200| 23| |300| 5| +---+-------------+ -- Aggregations using multiple sets of grouping columns in a single statement. -- Following performs aggregations based on four sets of grouping columns. -- 1. city, car_model -- 2. city -- 3. car_model -- 4. Empty grouping set. Returns quantities for all city and car models. SELECT city, car_model, sum(quantity) AS sum FROM dealer GROUP BY GROUPING SETS ((city, car_model), (city), (car_model), ()) ORDER BY city; +---------+------------+---+ | city| car_model|sum| +---------+------------+---+ | null| null| 78| | null| HondaAccord| 33| | null| HondaCRV| 10| | null| HondaCivic| 35| | Dublin| null| 33| | Dublin| HondaAccord| 10| | Dublin| HondaCRV| 3| | Dublin| HondaCivic| 20| | Fremont| null| 32| | Fremont| HondaAccord| 15| | Fremont| HondaCRV| 7| | Fremont| HondaCivic| 10| | San Jose| null| 13| | San Jose| HondaAccord| 8| | San Jose| HondaCivic| 5| +---------+------------+---+ -- Group by processing with `ROLLUP` clause. -- Equivalent GROUP BY GROUPING SETS ((city, car_model), (city), ()) SELECT city, car_model, sum(quantity) AS sum FROM dealer GROUP BY city, car_model WITH ROLLUP ORDER BY city, car_model; +---------+------------+---+ | city| car_model|sum| +---------+------------+---+ | null| null| 78| | Dublin| null| 33| | Dublin| HondaAccord| 10| | Dublin| HondaCRV| 3| | Dublin| HondaCivic| 20| | Fremont| null| 32| | Fremont| HondaAccord| 15| | Fremont| HondaCRV| 7| | Fremont| HondaCivic| 10| | San Jose| null| 13| | San Jose| HondaAccord| 8| | San Jose| HondaCivic| 5| +---------+------------+---+ -- Group by processing with `CUBE` clause. -- Equivalent GROUP BY GROUPING SETS ((city, car_model), (city), (car_model), ()) SELECT city, car_model, sum(quantity) AS sum FROM dealer GROUP BY city, car_model WITH CUBE ORDER BY city, car_model; +---------+------------+---+ | city| car_model|sum| +---------+------------+---+ | null| null| 78| | null| HondaAccord| 33| | null| HondaCRV| 10| | null| HondaCivic| 35| | Dublin| null| 33| | Dublin| HondaAccord| 10| | Dublin| HondaCRV| 3| | Dublin| HondaCivic| 20| | Fremont| null| 32| | Fremont| HondaAccord| 15| | Fremont| HondaCRV| 7| | Fremont| HondaCivic| 10| | San Jose| null| 13| | San Jose| HondaAccord| 8| | San Jose| HondaCivic| 5| +---------+------------+---+ --Prepare data for ignore nulls example CREATE TABLE person (id INT, name STRING, age INT); INSERT INTO person VALUES (100, 'Mary', NULL), (200, 'John', 30), (300, 'Mike', 80), (400, 'Dan', 50); --Select the first row in column age SELECT FIRST(age) FROM person; +--------------------+ | first(age, false) | +--------------------+ | NULL | +--------------------+ --Get the first row in column `age` ignore nulls,last row in column `id` and sum of column `id`. SELECT FIRST(age IGNORE NULLS), LAST(id), SUM(id) FROM person; +-------------------+------------------+----------+ | first(age, true) | last(id, false) | sum(id) | +-------------------+------------------+----------+ | 30 | 400 | 1000 | +-------------------+------------------+----------+ ``` #### HAVING 절 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). `HAVING` 절은 지정된 조건을 기반으로 `GROUP BY`에 의해 생성된 결과를 필터링하는 데 사용됩니다. `GROUP BY` 절과 함께 사용되는 경우가 많습니다. **구문** ``` HAVING boolean_expression ``` **파라미터** + **boolean\$1expression ** 결과 유형 부울로 평가되는 표현식을 지정합니다. 논리 연산자(`AND`, `OR`)를 사용하여 둘 이상의 표현식을 결합할 수 있습니다. **참고** `HAVING` 절에서 지정된 표현식은 다음 항목만 참조할 수 있습니다. 1. 상수 1. `GROUP BY`에 표시되는 표현식 1. 집계 함수 **예시** ``` CREATE TABLE dealer (id INT, city STRING, car_model STRING, quantity INT); INSERT INTO dealer VALUES (100, 'Fremont', 'Honda Civic', 10), (100, 'Fremont', 'Honda Accord', 15), (100, 'Fremont', 'Honda CRV', 7), (200, 'Dublin', 'Honda Civic', 20), (200, 'Dublin', 'Honda Accord', 10), (200, 'Dublin', 'Honda CRV', 3), (300, 'San Jose', 'Honda Civic', 5), (300, 'San Jose', 'Honda Accord', 8); -- `HAVING` clause referring to column in `GROUP BY`. SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING city = 'Fremont'; +-------+---+ | city|sum| +-------+---+ |Fremont| 32| +-------+---+ -- `HAVING` clause referring to aggregate function. SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING sum(quantity) > 15; +-------+---+ | city|sum| +-------+---+ | Dublin| 33| |Fremont| 32| +-------+---+ -- `HAVING` clause referring to aggregate function by its alias. SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING sum > 15; +-------+---+ | city|sum| +-------+---+ | Dublin| 33| |Fremont| 32| +-------+---+ -- `HAVING` clause referring to a different aggregate function than what is present in -- `SELECT` list. SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING max(quantity) > 15; +------+---+ | city|sum| +------+---+ |Dublin| 33| +------+---+ -- `HAVING` clause referring to constant expression. SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING 1 > 0 ORDER BY city; +--------+---+ | city|sum| +--------+---+ | Dublin| 33| | Fremont| 32| |San Jose| 13| +--------+---+ -- `HAVING` clause without a `GROUP BY` clause. SELECT sum(quantity) AS sum FROM dealer HAVING sum(quantity) > 10; +---+ |sum| +---+ | 78| +---+ ``` #### ORDER BY 절 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). `ORDER BY` 절은 사용자 지정 순서로 정렬된 결과 행을 반환하는 데 사용됩니다. SORT BY 절과 달리 이 절은 출력의 전체 순서를 보장합니다. **구문** ``` ORDER BY { expression [ sort_direction | nulls_sort_order ] [ , ... ] } ``` **파라미터** + **ORDER BY ** 행을 정렬하는 데 사용되는 선택적 파라미터 `sort_direction` 및 `nulls_sort_order`와 함께 쉼표로 구분된 표현식 목록을 지정합니다. + **sort\$1direction ** 선택적으로, 행을 오름차순 또는 내림차순으로 정렬할지 여부를 지정합니다. 정렬 방향의 유효한 값은 오름차순을 의미하는 `ASC`와 내림차순을 의미하는 `DESC`입니다. 정렬 방향이 명시적으로 지정되지 않으면 기본적으로 행이 오름차순으로 정렬됩니다. 구문: `[ ASC | DESC ] ` + **nulls\$1sort\$1order ** 선택적으로 NULL이 아닌 값 이전/이후에 `NULL` 값을 반환할지 여부를 지정합니다. null\$1sort\$1order를 지정하지 않으면 정렬 순서가 `ASC`인 경우 `NULLs`를 먼저 정렬하고 정렬 순서가 `DESC`인 경우 NULLS를 마지막으로 정렬합니다. 1. `NULLS FIRST`를 지정하면 정렬 순서에 관계없이 NULL 값이 먼저 반환됩니다. 2. `NULLS LAST`를 지정하면 정렬 순서에 관계없이 NULL 값이 마지막으로 반환됩니다. 구문: `[ NULLS { FIRST | LAST } ]` **예시** ``` CREATE TABLE person (id INT, name STRING, age INT); INSERT INTO person VALUES (100, 'John', 30), (200, 'Mary', NULL), (300, 'Mike', 80), (400, 'Jerry', NULL), (500, 'Dan', 50); -- Sort rows by age. By default rows are sorted in ascending manner with NULL FIRST. SELECT name, age FROM person ORDER BY age; +-----+----+ | name| age| +-----+----+ |Jerry|null| | Mary|null| | John| 30| | Dan| 50| | Mike| 80| +-----+----+ -- Sort rows in ascending manner keeping null values to be last. SELECT name, age FROM person ORDER BY age NULLS LAST; +-----+----+ | name| age| +-----+----+ | John| 30| | Dan| 50| | Mike| 80| | Mary|null| |Jerry|null| +-----+----+ -- Sort rows by age in descending manner, which defaults to NULL LAST. SELECT name, age FROM person ORDER BY age DESC; +-----+----+ | name| age| +-----+----+ | Mike| 80| | Dan| 50| | John| 30| |Jerry|null| | Mary|null| +-----+----+ -- Sort rows in ascending manner keeping null values to be first. SELECT name, age FROM person ORDER BY age DESC NULLS FIRST; +-----+----+ | name| age| +-----+----+ |Jerry|null| | Mary|null| | Mike| 80| | Dan| 50| | John| 30| +-----+----+ -- Sort rows based on more than one column with each column having different -- sort direction. SELECT * FROM person ORDER BY name ASC, age DESC; +---+-----+----+ | id| name| age| +---+-----+----+ |500| Dan| 50| |400|Jerry|null| |100| John| 30| |200| Mary|null| |300| Mike| 80| +---+-----+----+ ``` #### JOIN 절 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). SQL 조인은 조인 기준에 따라 두 관계의 행을 결합하는 데 사용됩니다. 다음 섹션에서는 예와 함께 전체 조인 구문과 다양한 유형의 조인에 대해 설명합니다. **구문** ``` relation INNER JOIN relation [ join_criteria ] ``` **파라미터** + **relation ** 조인할 관계를 지정합니다. + **join\$1type ** 조인 유형을 지정합니다. 구문: `INNER | CROSS | LEFT OUTER` + **join\$1criteria ** 한 관계의 행을 다른 관계의 행과 결합하는 방법을 지정합니다. 구문: `ON boolean_expression | USING ( column_name [ , ... ] ) ` + **boolean\$1expression ** 반환 유형이 부울인 표현식을 지정합니다. **조인 유형** + **Inner Join** 내부 조인을 명시적으로 지정해야 합니다. 두 관계에서 일치하는 값이 있는 행을 선택합니다. 구문: `relation INNER JOIN relation [ join_criteria ] ` + **Left Join ** 왼쪽 조인은 왼쪽 관계의 모든 값과 오른쪽 관계의 일치하는 값을 반환하거나, 일치하는 값이 없는 경우 NULL을 추가합니다. 이를 왼쪽 외부 조인이라고도 합니다. 구문: `relation LEFT OUTER JOIN relation [ join_criteria ]` + **Cross Join ** 교차 조인은 두 관계의 카테시안 곱을 반환합니다. 구문: `relation CROSS JOIN relation [ join_criteria ]` **예시** ``` -- Use employee and department tables to demonstrate different type of joins. SELECT * FROM employee; +---+-----+------+ | id| name|deptno| +---+-----+------+ |105|Chloe| 5| |103| Paul| 3| |101| John| 1| |102| Lisa| 2| |104| Evan| 4| |106| Amy| 6| +---+-----+------+ SELECT * FROM department; +------+-----------+ |deptno| deptname| +------+-----------+ | 3|Engineering| | 2| Sales| | 1| Marketing| +------+-----------+ -- Use employee and department tables to demonstrate inner join. SELECT id, name, employee.deptno, deptname FROM employee INNER JOIN department ON employee.deptno = department.deptno; +---+-----+------+-----------| | id| name|deptno| deptname| +---+-----+------+-----------| |103| Paul| 3|Engineering| |101| John| 1| Marketing| |102| Lisa| 2| Sales| +---+-----+------+-----------| -- Use employee and department tables to demonstrate left join. SELECT id, name, employee.deptno, deptname FROM employee LEFT JOIN department ON employee.deptno = department.deptno; +---+-----+------+-----------| | id| name|deptno| deptname| +---+-----+------+-----------| |105|Chloe| 5| NULL| |103| Paul| 3|Engineering| |101| John| 1| Marketing| |102| Lisa| 2| Sales| |104| Evan| 4| NULL| |106| Amy| 6| NULL| +---+-----+------+-----------| -- Use employee and department tables to demonstrate cross join. SELECT id, name, employee.deptno, deptname FROM employee CROSS JOIN department; +---+-----+------+-----------| | id| name|deptno| deptname| +---+-----+------+-----------| |105|Chloe| 5|Engineering| |105|Chloe| 5| Marketing| |105|Chloe| 5| Sales| |103| Paul| 3|Engineering| |103| Paul| 3| Marketing| |103| Paul| 3| Sales| |101| John| 1|Engineering| |101| John| 1| Marketing| |101| John| 1| Sales| |102| Lisa| 2|Engineering| |102| Lisa| 2| Marketing| |102| Lisa| 2| Sales| |104| Evan| 4|Engineering| |104| Evan| 4| Marketing| |104| Evan| 4| Sales| |106| Amy| 4|Engineering| |106| Amy| 4| Marketing| |106| Amy| 4| Sales| +---+-----+------+-----------| ``` #### LIMIT 절 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). `LIMIT` 절은 `SELECT` 문에서 반환되는 행 수를 제한하는 데 사용됩니다. 일반적으로 이 절은 결과가 결정적임을 보장하기 위해 `ORDER BY`와 함께 사용됩니다. **구문** ``` LIMIT { ALL | integer_expression } ``` **파라미터** + **모두** 지정하면 쿼리에서 모든 행이 반환됩니다. 즉, 이 옵션을 지정하면 제한이 적용되지 않습니다. + **integer\$1expression ** 정수를 반환하는 접을 수 있는 표현식을 지정합니다. **예시** ``` CREATE TABLE person (name STRING, age INT); INSERT INTO person VALUES ('Jane Doe', 25), ('Pat C', 18), ('Nikki W', 16), ('John D', 25), ('Juan L', 18), ('Jorge S', 16); -- Select the first two rows. SELECT name, age FROM person ORDER BY name LIMIT 2; +-------+---+ | name|age| +-------+---+ | Pat C| 18| |Jorge S| 16| +------+---+ -- Specifying ALL option on LIMIT returns all the rows. SELECT name, age FROM person ORDER BY name LIMIT ALL; +--------+---+ | name|age| +--------+---+ | Pat C| 18| | Jorge S| 16| | Juan L| 18| | John D| 25| | Nikki W| 16| |Jane Doe| 25| +--------+---+ -- A function expression as an input to LIMIT. SELECT name, age FROM person ORDER BY name LIMIT length('OPENSEARCH'); +-------+---+ | name|age| +-------+---+ | Pat C| 18| |Jorge S| 16| | Juan L| 18| | John D| 25| |Nikki W| 16| +-------+---+ ``` #### CASE 절 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). `CASE` 절은 규칙을 사용하여 다른 프로그래밍 언어의 if/else 문과 마찬가지로 지정된 조건에 따라 특정 결과를 반환합니다. **구문** ``` CASE [ expression ] { WHEN boolean_expression THEN then_expression } [ ... ] [ ELSE else_expression ] END ``` **파라미터** + **boolean\$1expression ** 결과 유형 부울로 평가되는 표현식을 지정합니다. 논리 연산자(`AND`, `OR`)를 사용하여 둘 이상의 표현식을 결합할 수 있습니다. + **then\$1expression ** boolean\$1expression 조건에 따라 then 표현식을 지정합니다. `then_expression`과 `else_expression`은 모두 동일한 유형이거나 공통 유형으로 강제 변환될 수 있어야 합니다. + **else\$1expression ** 기본 표현식을 지정합니다. `then_expression`과 ` else_expression`은 모두 동일한 유형이거나 공통 유형으로 강제 변환될 수 있어야 합니다. **예시** ``` CREATE TABLE person (id INT, name STRING, age INT); INSERT INTO person VALUES (100, 'John', 30), (200, 'Mary', NULL), (300, 'Mike', 80), (400, 'Dan', 50); SELECT id, CASE WHEN id > 200 THEN 'bigger' ELSE 'small' END FROM person; +------+--------------------------------------------------+ | id | CASE WHEN (id > 200) THEN bigger ELSE small END | +------+--------------------------------------------------+ | 100 | small | | 200 | small | | 300 | bigger | | 400 | bigger | +------+--------------------------------------------------+ SELECT id, CASE id WHEN 100 then 'bigger' WHEN id > 300 THEN '300' ELSE 'small' END FROM person; +------+-----------------------------------------------------------------------------------------------+ | id | CASE WHEN (id = 100) THEN bigger WHEN (id = CAST((id > 300) AS INT)) THEN 300 ELSE small END | +------+-----------------------------------------------------------------------------------------------+ | 100 | bigger | | 200 | small | | 300 | small | | 400 | small | +------+-----------------------------------------------------------------------------------------------+ ``` #### 공통 테이블 표현식 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). 공통 테이블 표현식(CTE)은 사용자가 SQL 문의 범위 내에서 여러 번 참조할 수 있는 임시 결과 세트를 정의합니다. CTE는 주로 `SELECT` 문에 사용됩니다. **구문** ``` WITH common_table_expression [ , ... ] ``` `common_table_expression`는 다음과 같이 정의됩니다. ``` Syntexpression_name [ ( column_name [ , ... ] ) ] [ AS ] ( query ) ``` **파라미터** + **expression\$1name ** 공통 테이블 표현식의 이름을 지정합니다. + **query** `SELECT` 문입니다. **예시** ``` -- CTE with multiple column aliases WITH t(x, y) AS (SELECT 1, 2) SELECT * FROM t WHERE x = 1 AND y = 2; +---+---+ | x| y| +---+---+ | 1| 2| +---+---+ -- CTE in CTE definition WITH t AS ( WITH t2 AS (SELECT 1) SELECT * FROM t2 ) SELECT * FROM t; +---+ | 1| +---+ | 1| +---+ -- CTE in subquery SELECT max(c) FROM ( WITH t(c) AS (SELECT 1) SELECT * FROM t ); +------+ |max(c)| +------+ | 1| +------+ -- CTE in subquery expression SELECT ( WITH t AS (SELECT 1) SELECT * FROM t ); +----------------+ |scalarsubquery()| +----------------+ | 1| +----------------+ -- CTE in CREATE VIEW statement CREATE VIEW v AS WITH t(a, b, c, d) AS (SELECT 1, 2, 3, 4) SELECT * FROM t; SELECT * FROM v; +---+---+---+---+ | a| b| c| d| +---+---+---+---+ | 1| 2| 3| 4| +---+---+---+---+ ``` #### EXPLAIN **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). `EXPLAIN` 문은 입력 문에 대한 논리적/물리적 계획을 제공하는 데 사용됩니다. 기본적으로 이 절은 물리적 계획에 대한 정보만 제공합니다. **구문** ``` EXPLAIN [ EXTENDED | CODEGEN | COST | FORMATTED ] statement ``` **파라미터** + **EXTENDED** 구문 분석된 논리적 계획, 분석된 논리적 계획, 최적화된 논리적 계획 및 물리적 계획을 생성합니다. 구문 분석된 논리적 계획은 쿼리에서 추출된 해결되지 않은 계획입니다. 분석된 논리적 계획은 `unresolvedAttribute`와 `unresolvedRelation`을 완전한 형식의 객체로 변환합니다. 최적화된 논리적 계획은 일련의 최적화 규칙을 통해 변환되므로 물리적 계획이 생성됩니다. + **CODEGEN** 물리적 계획이 있는 경우 문에 대한 코드를 생성합니다. + **COST** 계획 노드 통계를 사용할 수 있는 경우, 논리적 계획과 통계를 생성합니다. + **FORMATTED** 물리적 계획 개요와 노드 세부 정보라는 두 섹션을 생성합니다. + **설명** 설명할 SQL 문을 지정합니다. **예시** ``` -- Default Output EXPLAIN select k, sum(v) from values (1, 2), (1, 3) t(k, v) group by k; +----------------------------------------------------+ | plan| +----------------------------------------------------+ | == Physical Plan == *(2) HashAggregate(keys=[k#33], functions=[sum(cast(v#34 as bigint))]) +- Exchange hashpartitioning(k#33, 200), true, [id=#59] +- *(1) HashAggregate(keys=[k#33], functions=[partial_sum(cast(v#34 as bigint))]) +- *(1) LocalTableScan [k#33, v#34] | +---------------------------------------------------- -- Using Extended EXPLAIN EXTENDED select k, sum(v) from values (1, 2), (1, 3) t(k, v) group by k; +----------------------------------------------------+ | plan| +----------------------------------------------------+ | == Parsed Logical Plan == 'Aggregate ['k], ['k, unresolvedalias('sum('v), None)] +- 'SubqueryAlias `t` +- 'UnresolvedInlineTable [k, v], [List(1, 2), List(1, 3)] == Analyzed Logical Plan == k: int, sum(v): bigint Aggregate [k#47], [k#47, sum(cast(v#48 as bigint)) AS sum(v)#50L] +- SubqueryAlias `t` +- LocalRelation [k#47, v#48] == Optimized Logical Plan == Aggregate [k#47], [k#47, sum(cast(v#48 as bigint)) AS sum(v)#50L] +- LocalRelation [k#47, v#48] == Physical Plan == *(2) HashAggregate(keys=[k#47], functions=[sum(cast(v#48 as bigint))], output=[k#47, sum(v)#50L]) +- Exchange hashpartitioning(k#47, 200), true, [id=#79] +- *(1) HashAggregate(keys=[k#47], functions=[partial_sum(cast(v#48 as bigint))], output=[k#47, sum#52L]) +- *(1) LocalTableScan [k#47, v#48] | +----------------------------------------------------+ -- Using Formatted EXPLAIN FORMATTED select k, sum(v) from values (1, 2), (1, 3) t(k, v) group by k; +----------------------------------------------------+ | plan| +----------------------------------------------------+ | == Physical Plan == * HashAggregate (4) +- Exchange (3) +- * HashAggregate (2) +- * LocalTableScan (1) (1) LocalTableScan [codegen id : 1] Output: [k#19, v#20] (2) HashAggregate [codegen id : 1] Input: [k#19, v#20] (3) Exchange Input: [k#19, sum#24L] (4) HashAggregate [codegen id : 2] Input: [k#19, sum#24L] | +----------------------------------------------------+ ``` #### LATERAL SUBQUERY 절 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). `LATERAL SUBQUERY`는 키워드 `LATERAL` 앞에 오는 하위 쿼리입니다. 이전 `FROM` 절의 열을 참조하는 방법을 제공합니다. `LATERAL` 키워드가 없으면 하위 쿼리는 외부 쿼리의 열만 참조할 수 있지만 `FROM` 절에서는 참조할 수 없습니다. `LATERAL SUBQUERY`는 복잡한 쿼리를 단순화하고 효율성을 높입니다. **구문** ``` [ LATERAL ] primary_relation [ join_relation ] ``` **파라미터** + **primary\$1relation ** 기본 관계를 지정합니다. 다음 중 하나가 될 수 있습니다. 1. 테이블 관계 1. 별칭이 지정된 쿼리 구문: `( query ) [ [ AS ] alias ] ` 1. 별칭이 지정된 관계 `Syntax: ( relation ) [ [ AS ] alias ]` **예시** ``` CREATE TABLE t1 (c1 INT, c2 INT); INSERT INTO t1 VALUES (0, 1), (1, 2); CREATE TABLE t2 (c1 INT, c2 INT); INSERT INTO t2 VALUES (0, 2), (0, 3); SELECT * FROM t1, LATERAL (SELECT * FROM t2 WHERE t1.c1 = t2.c1); +--------+-------+--------+-------+ | t1.c1 | t1.c2 | t2.c1 | t2.c2 | +-------+--------+--------+-------+ | 0 | 1 | 0 | 3 | | 0 | 1 | 0 | 2 | +-------+--------+--------+-------+ SELECT a, b, c FROM t1, LATERAL (SELECT c1 + c2 AS a), LATERAL (SELECT c1 - c2 AS b), LATERAL (SELECT a * b AS c); +--------+-------+--------+ | a | b | c | +-------+--------+--------+ | 3 | -1 | -3 | | 1 | -1 | -1 | +-------+--------+--------+ ``` #### LATERAL VIEW 절 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). `LATERAL VIEW` 절은 하나 이상의 행이 포함된 가상 테이블을 생성하는 `EXPLODE`와 같은 생성 함수와 함께 사용됩니다. `LATERAL VIEW`는 각 원래 출력 행에 이 행을 적용합니다. **구문** ``` LATERAL VIEW [ OUTER ] generator_function ( expression [ , ... ] ) [ table_alias ] AS column_alias [ , ... ] ``` **파라미터** + **외부** `OUTER`가 지정된 경우 입력 배열/맵이 비어 있거나 null인 경우 null을 반환합니다. + **generator\$1function ** 생성 함수(`EXPLODE`, `INLINE` 등)를 지정합니다. + **table\$1alias ** 선택 사항인 `generator_function`의 별칭입니다. + **column\$1alias** 출력 행에 사용할 수 있는 `generator_function`의 열 별칭을 나열합니다. `generator_function`에 출력 열이 여러 개 있는 경우 별칭이 여러 개 있을 수 있습니다. **예시** ``` CREATE TABLE person (id INT, name STRING, age INT, class INT, address STRING); INSERT INTO person VALUES (100, 'John', 30, 1, 'Street 1'), (200, 'Mary', NULL, 1, 'Street 2'), (300, 'Mike', 80, 3, 'Street 3'), (400, 'Dan', 50, 4, 'Street 4'); SELECT * FROM person LATERAL VIEW EXPLODE(ARRAY(30, 60)) tableName AS c_age LATERAL VIEW EXPLODE(ARRAY(40, 80)) AS d_age; +------+-------+-------+--------+-----------+--------+--------+ | id | name | age | class | address | c_age | d_age | +------+-------+-------+--------+-----------+--------+--------+ | 100 | John | 30 | 1 | Street 1 | 30 | 40 | | 100 | John | 30 | 1 | Street 1 | 30 | 80 | | 100 | John | 30 | 1 | Street 1 | 60 | 40 | | 100 | John | 30 | 1 | Street 1 | 60 | 80 | | 200 | Mary | NULL | 1 | Street 2 | 30 | 40 | | 200 | Mary | NULL | 1 | Street 2 | 30 | 80 | | 200 | Mary | NULL | 1 | Street 2 | 60 | 40 | | 200 | Mary | NULL | 1 | Street 2 | 60 | 80 | | 300 | Mike | 80 | 3 | Street 3 | 30 | 40 | | 300 | Mike | 80 | 3 | Street 3 | 30 | 80 | | 300 | Mike | 80 | 3 | Street 3 | 60 | 40 | | 300 | Mike | 80 | 3 | Street 3 | 60 | 80 | | 400 | Dan | 50 | 4 | Street 4 | 30 | 40 | | 400 | Dan | 50 | 4 | Street 4 | 30 | 80 | | 400 | Dan | 50 | 4 | Street 4 | 60 | 40 | | 400 | Dan | 50 | 4 | Street 4 | 60 | 80 | +------+-------+-------+--------+-----------+--------+--------+ SELECT c_age, COUNT(1) FROM person LATERAL VIEW EXPLODE(ARRAY(30, 60)) AS c_age LATERAL VIEW EXPLODE(ARRAY(40, 80)) AS d_age GROUP BY c_age; +--------+-----------+ | c_age | count(1) | +--------+-----------+ | 60 | 8 | | 30 | 8 | +--------+-----------+ SELECT * FROM person LATERAL VIEW EXPLODE(ARRAY()) tableName AS c_age; +-----+-------+------+--------+----------+--------+ | id | name | age | class | address | c_age | +-----+-------+------+--------+----------+--------+ +-----+-------+------+--------+----------+--------+ SELECT * FROM person LATERAL VIEW OUTER EXPLODE(ARRAY()) tableName AS c_age; +------+-------+-------+--------+-----------+--------+ | id | name | age | class | address | c_age | +------+-------+-------+--------+-----------+--------+ | 100 | John | 30 | 1 | Street 1 | NULL | | 200 | Mary | NULL | 1 | Street 2 | NULL | | 300 | Mike | 80 | 3 | Street 3 | NULL | | 400 | Dan | 50 | 4 | Street 4 | NULL | +------+-------+-------+--------+-----------+--------+ ``` #### LIKE 조건자 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). `LIKE` 조건자는 특정 패턴을 검색하는 데 사용됩니다. 이 조건자는 `ANY`, `SOME`, `ALL` 등의 한정자가 있는 여러 패턴도 지원합니다. **구문** ``` [ NOT ] { LIKE search_pattern [ ESCAPE esc_char ] | [ RLIKE | REGEXP ] regex_pattern } [ NOT ] { LIKE quantifiers ( search_pattern [ , ... ]) } ``` **파라미터** + **search\$1pattern ** LIKE 절로 검색할 문자열 패턴을 지정합니다. 다음과 같은 특수 패턴 일치 문자를 포함할 수 있습니다. + `%`는 0개 이상의 문자에 해당합니다. + `_`는 정확히 1문자에 해당합니다. + **esc\$1char ** 이스케이프 문자를 지정합니다. 기본 이스케이프 문자는 `\`입니다. + **regex\$1pattern ** `RLIKE` 또는 `REGEXP` 절로 검색할 정규식 검색 패턴을 지정합니다. + **quantifiers** `ANY`, `SOME`, `ALL` 등의 조건자 한정자를 지정합니다. `ANY` 또는 `SOME`는 패턴 중 하나가 입력과 일치하는 경우 true를 반환함을 의미합니다. `ALL`은 모든 패턴이 입력과 일치하는 경우 true를 반환함을 의미합니다. **예시** ``` CREATE TABLE person (id INT, name STRING, age INT); INSERT INTO person VALUES (100, 'John', 30), (200, 'Mary', NULL), (300, 'Mike', 80), (400, 'Dan', 50), (500, 'Evan_w', 16); SELECT * FROM person WHERE name LIKE 'M%'; +---+----+----+ | id|name| age| +---+----+----+ |300|Mike| 80| |200|Mary|null| +---+----+----+ SELECT * FROM person WHERE name LIKE 'M_ry'; +---+----+----+ | id|name| age| +---+----+----+ |200|Mary|null| +---+----+----+ SELECT * FROM person WHERE name NOT LIKE 'M_ry'; +---+------+---+ | id| name|age| +---+------+---+ |500|Evan_W| 16| |300| Mike| 80| |100| John| 30| |400| Dan| 50| +---+------+---+ SELECT * FROM person WHERE name RLIKE 'M+'; +---+----+----+ | id|name| age| +---+----+----+ |300|Mike| 80| |200|Mary|null| +---+----+----+ SELECT * FROM person WHERE name REGEXP 'M+'; +---+----+----+ | id|name| age| +---+----+----+ |300|Mike| 80| |200|Mary|null| +---+----+----+ SELECT * FROM person WHERE name LIKE '%\_%'; +---+------+---+ | id| name|age| +---+------+---+ |500|Evan_W| 16| +---+------+---+ SELECT * FROM person WHERE name LIKE '%$_%' ESCAPE '$'; +---+------+---+ | id| name|age| +---+------+---+ |500|Evan_W| 16| +---+------+---+ SELECT * FROM person WHERE name LIKE ALL ('%an%', '%an'); +---+----+----+ | id|name| age| +---+----+----+ |400| Dan| 50| +---+----+----+ SELECT * FROM person WHERE name LIKE ANY ('%an%', '%an'); +---+------+---+ | id| name|age| +---+------+---+ |400| Dan| 50| |500|Evan_W| 16| +---+------+---+ SELECT * FROM person WHERE name LIKE SOME ('%an%', '%an'); +---+------+---+ | id| name|age| +---+------+---+ |400| Dan| 50| |500|Evan_W| 16| +---+------+---+ SELECT * FROM person WHERE name NOT LIKE ALL ('%an%', '%an'); +---+----+----+ | id|name| age| +---+----+----+ |100|John| 30| |200|Mary|null| |300|Mike| 80| +---+----+----+ SELECT * FROM person WHERE name NOT LIKE ANY ('%an%', '%an'); +---+------+----+ | id| name| age| +---+------+----+ |100| John| 30| |200| Mary|null| |300| Mike| 80| |500|Evan_W| 16| +---+------+----+ SELECT * FROM person WHERE name NOT LIKE SOME ('%an%', '%an'); +---+------+----+ | id| name| age| +---+------+----+ |100| John| 30| |200| Mary|null| |300| Mike| 80| |500|Evan_W| 16| +---+------+----+ ``` #### OFFSET **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). `OFFSET` 절은 `SELECT` 문에서 반환된 행을 반환하기 전에 건너뛸 행 수를 지정하는 데 사용됩니다. 일반적으로 이 절은 결과가 결정적임을 보장하기 위해 `ORDER BY`와 함께 사용됩니다. **구문** ``` OFFSET integer_expression ``` **파라미터** + **integer\$1expression ** 정수를 반환하는 접을 수 있는 표현식을 지정합니다. **예시** ``` CREATE TABLE person (name STRING, age INT); INSERT INTO person VALUES ('Jane Doe', 25), ('Pat C', 18), ('Nikki W', 16), ('Juan L', 25), ('John D', 18), ('Jorge S', 16); -- Skip the first two rows. SELECT name, age FROM person ORDER BY name OFFSET 2; +-------+---+ | name|age| +-------+---+ | John D| 18| | Juan L| 25| |Nikki W| 16| |Jane Doe| 25| +-------+---+ -- Skip the first two rows and returns the next three rows. SELECT name, age FROM person ORDER BY name LIMIT 3 OFFSET 2; +-------+---+ | name|age| +-------+---+ | John D| 18| | Juan L| 25| |Nikki W| 16| +-------+---+ -- A function expression as an input to OFFSET. SELECT name, age FROM person ORDER BY name OFFSET length('WAGON'); +-------+---+ | name|age| +-------+---+ |Jane Doe| 25| +-------+---+ ``` #### PIVOT 절 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). `PIVOT` 절은 데이터와 관련하여 사용됩니다. 특정 열 값을 기반으로 집계된 값을 가져올 수 있으며, 이는 `SELECT` 절에 사용되는 여러 열로 전환됩니다. `PIVOT` 절은 테이블 이름 또는 하위 쿼리 뒤에 지정할 수 있습니다. **구문** ``` PIVOT ( { aggregate_expression [ AS aggregate_expression_alias ] } [ , ... ] FOR column_list IN ( expression_list ) ) ``` **파라미터** + **aggregate\$1expression** `(SUM(a)`, `COUNT(DISTINCT b)` 등의 집계 표현식을 지정합니다. + **aggregate\$1expression\$1alias** 집계 표현식의 별칭을 지정합니다. + **column\$1list** `FROM` 절에 새 열로 바꿀 열을 지정하는 열이 포함되어 있습니다. 대괄호를 사용하여 `(c1, c2)`와 같이 열을 묶을 수 있습니다. + **expression\$1list** `column_list`의 값을 집계 조건으로 매칭하는 데 사용되는 새 열을 지정합니다. 열의 별칭을 추가할 수도 있습니다. **예시** ``` CREATE TABLE person (id INT, name STRING, age INT, class INT, address STRING); INSERT INTO person VALUES (100, 'John', 30, 1, 'Street 1'), (200, 'Mary', NULL, 1, 'Street 2'), (300, 'Mike', 80, 3, 'Street 3'), (400, 'Dan', 50, 4, 'Street 4'); SELECT * FROM person PIVOT ( SUM(age) AS a, AVG(class) AS c FOR name IN ('John' AS john, 'Mike' AS mike) ); +------+-----------+---------+---------+---------+---------+ | id | address | john_a | john_c | mike_a | mike_c | +------+-----------+---------+---------+---------+---------+ | 200 | Street 2 | NULL | NULL | NULL | NULL | | 100 | Street 1 | 30 | 1.0 | NULL | NULL | | 300 | Street 3 | NULL | NULL | 80 | 3.0 | | 400 | Street 4 | NULL | NULL | NULL | NULL | +------+-----------+---------+---------+---------+---------+ SELECT * FROM person PIVOT ( SUM(age) AS a, AVG(class) AS c FOR (name, age) IN (('John', 30) AS c1, ('Mike', 40) AS c2) ); +------+-----------+-------+-------+-------+-------+ | id | address | c1_a | c1_c | c2_a | c2_c | +------+-----------+-------+-------+-------+-------+ | 200 | Street 2 | NULL | NULL | NULL | NULL | | 100 | Street 1 | 30 | 1.0 | NULL | NULL | | 300 | Street 3 | NULL | NULL | NULL | NULL | | 400 | Street 4 | NULL | NULL | NULL | NULL | +------+-----------+-------+-------+-------+-------+ ``` #### 집합 연산자 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). 집합 연산자는 두 입력 관계를 하나의 입력 관계로 결합하는 데 사용됩니다. OpenSearch SQL은 세 가지 유형의 집합 연산자를 지원합니다. + `EXCEPT` 또는 `MINUS` + `INTERSECT` + `UNION` 입력 관계는 각 열의 수와 호환되는 데이터 형식이 동일해야 합니다. **제외** `EXCEPT`와 `EXCEPT ALL`은 한 관계에서 찾을 수 있지만 다른 관계에서는 찾을 수 없는 행을 반환합니다. `EXCEPT`(또는 `EXCEPT DISTINCT`)는 고유한 행만 가져오고 `EXCEPT ALL`은 결과 행에서 중복을 제거하지 않습니다. `MINUS`는 `EXCEPT`의 별칭입니다. **구문** ``` [ ( ] relation [ ) ] EXCEPT | MINUS [ ALL | DISTINCT ] [ ( ] relation [ ) ] ``` **예시** ``` -- Use table1 and table2 tables to demonstrate set operators in this page. SELECT * FROM table1; +---+ | c| +---+ | 3| | 1| | 2| | 2| | 3| | 4| +---+ SELECT * FROM table2; +---+ | c| +---+ | 5| | 1| | 2| | 2| +---+ SELECT c FROM table1 EXCEPT SELECT c FROM table2; +---+ | c| +---+ | 3| | 4| +---+ SELECT c FROM table1 MINUS SELECT c FROM table2; +---+ | c| +---+ | 3| | 4| +---+ SELECT c FROM table1 EXCEPT ALL (SELECT c FROM table2); +---+ | c| +---+ | 3| | 3| | 4| +---+ SELECT c FROM table1 MINUS ALL (SELECT c FROM table2); +---+ | c| +---+ | 3| | 3| | 4| +---+ ``` **INTERSECT** `INTERSECT`와 `INTERSECT ALL`은 두 관계 모두에서 찾을 수 있는 행을 반환합니다. `INTERSECT`(또는 `INTERSECT DISTINCT`)는 고유한 행만 가져오고 `INTERSECT ALL`은 결과 행에서 중복을 제거하지 않습니다. **구문** ``` [ ( ] relation [ ) ] INTERSECT [ ALL | DISTINCT ] [ ( ] relation [ ) ] ``` **예시** ``` (SELECT c FROM table1) INTERSECT (SELECT c FROM table2); +---+ | c| +---+ | 1| | 2| +---+ (SELECT c FROM table1) INTERSECT DISTINCT (SELECT c FROM table2); +---+ | c| +---+ | 1| | 2| +---+ (SELECT c FROM table1) INTERSECT ALL (SELECT c FROM table2); +---+ | c| +---+ | 1| | 2| | 2| +---+ ``` **UNION** `UNION`와 `UNION ALL`은 두 관계 모두에서 찾을 수 없는 행을 반환합니다. `UNION`(또는 `UNION DISTINCT`)는 고유한 행만 가져오고 `UNION ALL`은 결과 행에서 중복을 제거하지 않습니다. **구문** ``` [ ( ] relation [ ) ] UNION [ ALL | DISTINCT ] [ ( ] relation [ ) ] ``` **예시** ``` (SELECT c FROM table1) UNION (SELECT c FROM table2); +---+ | c| +---+ | 1| | 3| | 5| | 4| | 2| +---+ (SELECT c FROM table1) UNION DISTINCT (SELECT c FROM table2); +---+ | c| +---+ | 1| | 3| | 5| | 4| | 2| +---+ SELECT c FROM table1 UNION ALL (SELECT c FROM table2); +---+ | c| +---+ | 3| | 1| | 2| | 2| | 3| | 4| | 5| | 1| | 2| | 2| +---+ ``` #### SORT BY 절 **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). `SORT BY` 절은 각 파티션 내에서 정렬된 결과 행을 사용자 지정 순서로 반환하는 데 사용됩니다. 파티션이 두 개 이상 있는 경우 `SORT BY`는 부분적으로 정렬된 결과를 반환할 수 있습니다. 이는 출력의 총 순서를 보장하는 `ORDER BY` 절과 다릅니다. **구문** ``` SORT BY { expression [ sort_direction | nulls_sort_order ] [ , ... ] } ``` **파라미터** + **SORT BY ** 각 파티션 내의 행을 정렬하는 데 사용되는 선택적 파라미터 sort\$1direction 및 nulls\$1sort\$1order와 함께 쉼표로 구분된 표현식 목록을 지정합니다. + **sort\$1direction ** 선택적으로, 행을 오름차순 또는 내림차순으로 정렬할지 여부를 지정합니다. 정렬 방향의 유효한 값은 오름차순을 의미하는 `ASC`와 내림차순을 의미하는 `DESC`입니다. 정렬 방향이 명시적으로 지정되지 않으면 기본적으로 행이 오름차순으로 정렬됩니다. 구문: `[ ASC | DESC ]` + **nulls\$1sort\$1order ** 선택적으로 NULL이 아닌 값 이전/이후에 NULL 값을 반환할지 여부를 지정합니다. `null_sort_order`를 지정하지 않으면 정렬 순서가 `ASC`인 경우 NULLs를 먼저 정렬하고 정렬 순서가 `DESC`인 경우 NULLS를 마지막으로 정렬합니다. 1. `NULLS FIRST`를 지정하면 정렬 순서에 관계없이 NULL 값이 먼저 반환됩니다. 2. `NULLS LAST`를 지정하면 정렬 순서에 관계없이 NULL 값이 마지막으로 반환됩니다. 구문: `[ NULLS { FIRST | LAST } ] ` **예시** ``` CREATE TABLE person (zip_code INT, name STRING, age INT); INSERT INTO person VALUES (94588, 'Shirley Rodriguez', 50), (94588, 'Juan Li', 18), (94588, 'Anil K', 27), (94588, 'John D', NULL), (94511, 'David K', 42), (94511, 'Aryan B.', 18), (94511, 'Lalit B.', NULL); -- Sort rows by `name` within each partition in ascending manner SELECT name, age, zip_code FROM person SORT BY name; +------------------+----+--------+ | name| age|zip_code| +------------------+----+--------+ | Anil K| 27| 94588| | Juan Li| 18| 94588| | John D|null| 94588| | Shirley Rodriguez| 50| 94588| | Aryan B.| 18| 94511| | David K| 42| 94511| | Lalit B.|null| 94511| +------------------+----+--------+ -- Sort rows within each partition using column position. SELECT name, age, zip_code FROM person SORT BY 1; +----------------+----+----------+ | name| age|zip_code| +------------------+----+--------+ | Anil K| 27| 94588| | Juan Li| 18| 94588| | John D|null| 94588| | Shirley Rodriguez| 50| 94588| | Aryan B.| 18| 94511| | David K| 42| 94511| | Lalit B.|null| 94511| +------------------+----+--------+ -- Sort rows within partition in ascending manner keeping null values to be last. SELECT age, name, zip_code FROM person SORT BY age NULLS LAST; +----+------------------+--------+ | age| name|zip_code| +----+------------------+--------+ | 18| Juan Li| 94588| | 27| Anil K| 94588| | 50| Shirley Rodriguez| 94588| |null| John D| 94588| | 18| Aryan B.| 94511| | 42| David K| 94511| |null| Lalit B.| 94511| +--------------+--------+--------+ -- Sort rows by age within each partition in descending manner, which defaults to NULL LAST. SELECT age, name, zip_code FROM person SORT BY age DESC; +----+------------------+--------+ | age| name|zip_code| +----+------------------+--------+ | 50| Shirley Rodriguez| 94588| | 27| Anil K| 94588| | 18| Juan Li| 94588| |null| John D| 94588| | 42| David K| 94511| | 18| Aryan B.| 94511| |null| Lalit B.| 94511| +----+------------------+--------+ -- Sort rows by age within each partition in descending manner keeping null values to be first. SELECT age, name, zip_code FROM person SORT BY age DESC NULLS FIRST; +----+------------------+--------+ | age| name|zip_code| +----+------------------+--------+ |null| John D| 94588| | 50| Shirley Rodriguez| 94588| | 27| Anil K| 94588| | 18| Juan Li| 94588| |null| Lalit B.| 94511| | 42| David K| 94511| | 18| Aryan B.| 94511| +--------------+--------+--------+ -- Sort rows within each partition based on more than one column with each column having -- different sort direction. SELECT name, age, zip_code FROM person SORT BY name ASC, age DESC; +------------------+----+--------+ | name| age|zip_code| +------------------+----+--------+ | Anil K| 27| 94588| | Juan Li| 18| 94588| | John D|null| 94588| | Shirley Rodriguez| 50| 94588| | Aryan B.| 18| 94511| | David K| 42| 94511| | Lalit B.|null| 94511| +------------------+----+--------+ ``` #### UNPIVOT **참고** 이 SQL 명령을 지원하는 AWS 데이터 소스 통합을 확인하려면 섹션을 참조하세요[지원되는 OpenSearch SQL 명령 및 함수](#supported-directquery-sql). `UNPIVOT` 절은 여러 열을 `SELECT` 절에 사용되는 여러 행으로 변환합니다. `UNPIVOT` 절은 테이블 이름 또는 하위 쿼리 뒤에 지정할 수 있습니다. **구문** ``` UNPIVOT [ { INCLUDE | EXCLUDE } NULLS ] ( { single_value_column_unpivot | multi_value_column_unpivot } ) [[AS] alias] single_value_column_unpivot: values_column FOR name_column IN (unpivot_column [[AS] alias] [, ...]) multi_value_column_unpivot: (values_column [, ...]) FOR name_column IN ((unpivot_column [, ...]) [[AS] alias] [, ...]) ``` **파라미터** + **unpivot\$1column ** 언피벗하려는 열을 지정하는 `FROM` 절의 열을 포함합니다. + **name\$1column ** 언피벗된 열의 이름을 포함하는 열의 이름입니다. + **values\$1column ** 언피벗된 열의 값을 포함하는 열의 이름입니다. **예시** ``` CREATE TABLE sales_quarterly (year INT, q1 INT, q2 INT, q3 INT, q4 INT); INSERT INTO sales_quarterly VALUES (2020, null, 1000, 2000, 2500), (2021, 2250, 3200, 4200, 5900), (2022, 4200, 3100, null, null); -- column names are used as unpivot columns SELECT * FROM sales_quarterly UNPIVOT ( sales FOR quarter IN (q1, q2, q3, q4) ); +------+---------+-------+ | year | quarter | sales | +------+---------+-------+ | 2020 | q2 | 1000 | | 2020 | q3 | 2000 | | 2020 | q4 | 2500 | | 2021 | q1 | 2250 | | 2021 | q2 | 3200 | | 2021 | q3 | 4200 | | 2021 | q4 | 5900 | | 2022 | q1 | 4200 | | 2022 | q2 | 3100 | +------+---------+-------+ -- NULL values are excluded by default, they can be included -- unpivot columns can be alias -- unpivot result can be referenced via its alias SELECT up.* FROM sales_quarterly UNPIVOT INCLUDE NULLS ( sales FOR quarter IN (q1 AS Q1, q2 AS Q2, q3 AS Q3, q4 AS Q4) ) AS up; +------+---------+-------+ | year | quarter | sales | +------+---------+-------+ | 2020 | Q1 | NULL | | 2020 | Q2 | 1000 | | 2020 | Q3 | 2000 | | 2020 | Q4 | 2500 | | 2021 | Q1 | 2250 | | 2021 | Q2 | 3200 | | 2021 | Q3 | 4200 | | 2021 | Q4 | 5900 | | 2022 | Q1 | 4200 | | 2022 | Q2 | 3100 | | 2022 | Q3 | NULL | | 2022 | Q4 | NULL | +------+---------+-------+ -- multiple value columns can be unpivoted per row SELECT * FROM sales_quarterly UNPIVOT EXCLUDE NULLS ( (first_quarter, second_quarter) FOR half_of_the_year IN ( (q1, q2) AS H1, (q3, q4) AS H2 ) ); +------+------------------+---------------+----------------+ | id | half_of_the_year | first_quarter | second_quarter | +------+------------------+---------------+----------------+ | 2020 | H1 | NULL | 1000 | | 2020 | H2 | 2000 | 2500 | | 2021 | H1 | 2250 | 3200 | | 2021 | H2 | 4200 | 5900 | | 2022 | H1 | 4200 | 3100 | +------+------------------+---------------+----------------+ ```