翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。 # サポートされている 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/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | 
SELECT 
    * 
FROM 
     
ORDER BY 
    status DESC
| | [JOIN 句](#supported-sql-join) ( `INNER` \$1 `CROSS` \$1 `LEFT` `OUTER` ) | 共通フィールドに基づいて 2 つのテーブルの結果を結合します。 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) 対応 (結合には `Inner` および `Left Outer` キーワードを使用する必要があります。SELECT ステートメントでサポートされている JOIN 操作は 1 回のみです) | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) 対応 (結合には Inner、Left Outer、Cross のキーワードを使用する必要があります) | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) 対応 (結合には Inner、Left Outer、Cross のキーワードを使用する必要があります) | 
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/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/opensearch-service/latest/developerguide/images/negative_icon.svg) サポート対象外 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/opensearch-service/latest/developerguide/images/negative_icon.svg) サポート対象外 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/opensearch-service/latest/developerguide/images/negative_icon.svg) サポート対象外 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/opensearch-service/latest/developerguide/images/negative_icon.svg) サポート対象外 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) クエリ内で LIMIT 句と組み合わせて使用する場合にサポートされます。例えば、次のようになります。[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/supported-directquery-sql.html) | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/opensearch-service/latest/developerguide/images/negative_icon.svg) サポート対象外 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/opensearch-service/latest/developerguide/images/negative_icon.svg) サポート対象外 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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) | 複数の行で計算を実行して 1 つの要約値を生成する組み込み関数。例えば、**sum**、**count**、**avg**、**max**、**min** などが挙げられます。 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg)サポートされている | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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) | SQL クエリ 内で JSON 形式のデータを解析、抽出、変更、クエリするための組み込み関数 (from\$1json、to\$1json、get\$1json\$1object、json\$1tuple など) により、データセット内の JSON 構造を操作できます。 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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 クエリで配列型の列を操作するための組み込み関数により、配列データ へのアクセス、変更、分析などの操作を可能にします (例: size、explode、array\$1contains など)。 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | 
SELECT 
    scores,
    size(scores) AS length,
    array_contains(scores, 90) AS has_90 
FROM
| | [Window 関数](#supported-sql-window) | 現在の行 (ウィンドウ) に関連する指定された行セット間で計算を実行する組み込み関数により、ランク付け、実行合計、移動平均などの操作を可能にします (例: ROW\$1NUMBER、RANK、LAG、LEAD など) | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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) | 条件を評価し、指定された条件またはパターンに基づいてブール値 (true/false) を返す組み込み関数 (IN、LIKE、BETWEEN、IS NULL、EXISTS など)。 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/opensearch-service/latest/developerguide/images/negative_icon.svg) サポート対象外 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/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/ja_jp/opensearch-service/latest/developerguide/images/negative_icon.svg) サポート対象外 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/opensearch-service/latest/developerguide/images/success_icon.svg) サポート対象 | ![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/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 段階までしかサポートされていません。 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` コマンドを使用できます。このコマンドは、1 つ以上のロググループに関連する 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 Logs Insights ユーザーと CloudWatch データをクエリする OpenSearch ユーザーの両方に適用されます。 CloudWatch Logs で使用できるサンプル SQL クエリの例については、Amazon CloudWatch Logs Insights コンソールの「**Saved and sample queries**」を参照してください。 OpenSearch Service から CloudWatch Logs をクエリするときに適用される制限については、「Amazon CloudWatch Logs ユーザーガイド」の「[CloudWatch Logs quotas](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) + [Window 関数](#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 からベース 64 文字列に変換します。 | | bit\$1length(expr) | 文字列データの場合はビット長、バイナリデータの場合はビット数を返します。。 | | btrim(str) | str から先頭と末尾のスペース文字を削除します。 | | btrim(str, trimStr) | str から先頭と末尾の trimStr 文字を削除します。 | | char(expr) | expr と同等のバイナリを持つ ASCII 文字を返します。n が 256 より大きい場合、結果は chr(n % 256) と同等になります。 | | char\$1length(expr) | 文字列データの場合は文字数、バイナリデータの場合はバイト数を返します。文字列データの長さには、末尾のスペースも含まれます。バイナリデータの長さには、バイナリゼロも含まれます。 | | character\$1length(expr) | 文字列データの場合は文字数、バイナリデータの場合はバイト数を返します。文字列データの長さには、末尾のスペースも含まれます。バイナリデータの長さには、バイナリゼロも含まれます。 | | chr(expr) | expr と同等のバイナリを持つ ASCII 文字を返します。n が 256 より大きい場合、結果は chr(n % 256) と同等になります。 | | concat\$1ws(sep[, str \$1 array(str)]\$1) | null 値をスキップして、sep で区切られた文字列の連結を返します。 | | contains(left, right) | ブール値を返します。left 中に right が見つかった場合、値は True になります。いずれかの入力式が NULL の場合、NULL を返します。それ以外の場合は、False を返します。left または right の両方が STRING または BINARY 型である必要があります。 | | decode(bin, charset) | 2 番目の引数文字セットを使用して最初の引数をデコードします。 | | decode(expr, search, result [, search, result ] ... [, default]) | expr を各検索値と順番に比較します。expr が検索値と等しい場合、デコードは対応する結果を返します。一致が見つからない場合は、デフォルト値を返します。デフォルト値を省略すると、null が返されます。 | | elt(n, input1, input2, ...) | n 番目の入力を返します。例えば、n が 2 の場合は input2 を返します。 | | encode(str, charset) | 2 番目の引数文字セットを使用して最初の引数をエンコードします。 | | 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) | 文字列データの場合は文字数、バイナリデータの場合はバイト数を返します。文字列データの長さには、末尾のスペースも含まれます。バイナリデータの長さには、バイナリゼロも含まれます。 | | length(expr) | 文字列データの場合は文字数、バイナリデータの場合はバイト数を返します。文字列データの長さには、末尾のスペースも含まれます。バイナリデータの長さには、バイナリゼロも含まれます。 | | levenshtein(str1, str2[, threshold]) | 指定された 2 つの文字列間の Levenshtein 距離を返します。しきい値を設定し、それを超える距離がある場合は、-1 を返します。 | | locate(substr, str[, pos]) | 位置 pos の後で str の中に substr が最初に出現した位置を返します。指定された pos および戻り値は 1 ベースです。 | | lower(str) | すべての文字を小文字に変更して str を返します。 | | lpad(str, len[, pad]) | str を pad で左詰めして、len の長さになるようして返します。str が len より長い場合、戻り値は len の文字数やバイト数まで短縮されます。pad が指定されていない場合、str は文字列の場合はスペース文字で左詰めされ、バイト列の場合はゼロで左詰めされます。 | | 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]) | 位置 pos の後で str の中に substr が最初に出現した位置を返します。指定された pos および戻り値は 1 ベースです。 | | printf(strfmt, obj, ...) | printf 形式の文字列からフォーマットされた文字列を返します。 | | regexp\$1count(str、regexp) | 正規表現パターン regexp が文字列 str 内で一致した回数をカウントして返します。 | | regexp\$1extract(str, regexp[, idx]) | regexp 式に一致し、正規表現グループインデックスに対応する str の最初の文字列を抽出します。 | | regexp\$1extract\$1all(str, regexp[, idx]) | regexp 式に一致し、正規表現グループインデックスに対応する str 内のすべての文字列を抽出します。 | | regexp\$1instr(str, regexp) | 文字列で正規表現を検索し、一致するサブ文字列の開始位置を示す整数を返します。位置は 1 ベースであり、0 ベースではありません。一致が見つからない場合は 0 を返します。 | | regexp\$1replace(str, regexp, rep[, position]) | str の中で regexp に一致するすべてのサブ文字列を 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]) | str を pad で右詰めして、len の長さになるようして返します。str が len より長い場合、戻り値は len の文字数まで短縮されます。pad が指定されていない場合、str は文字列の場合はスペース文字で右詰めされ、バイナリ列の場合はゼロで右詰めされます。 | | rtrim(str) | str から末尾のスペース文字を削除します。 | | sentences(str[, lang, country]) | str を単語単位で分割した配列の配列に分割します。 | | soundex(str) | 文字列の Soundex コードを返します。 | | space(n) | n スペースで構成される文字列を返します。 | | split(str, regex, limit) | 文字列 str を regex と一致する箇所で分割し、長さが最大で 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]) | 入力 str を指定された fmt に基づいてバイナリ値に変換します。fmt は、大文字小文字を区別しない文字列リテラルで、「hex」、「utf-8」、「utf8」、または「base64」のいずれかになります。デフォルトでは、fmt が省略されている場合、変換のバイナリ形式は「hex」です。入力パラメータの少なくとも 1 つが NULL の場合、関数は NULL を返します。 | | to\$1char(numberExpr, formatExpr) | formatExpr に基づいて numberExpr を文字列に変換します。いずれかの条件が失敗すると、例外をスローします。形式は、大文字と小文字を区別しない次の文字で構成できます。'0' または '9': 0～9 の予想される数字を指定します。形式文字列の 0 または 9 の並びは、入力値の数字列と一致し、形式文字列の対応する列と同じ長さの結果文字列を生成します。0/9 の並びが、小数点以下の値の対応部分よりも桁数が多く、0 で始まり、小数点より前にある場合、結果文字列は 0 で左側を埋めます。それ以外の場合は、スペースで埋められます。'.' または 'D': 小数点の位置を指定します (オプション、1 回のみ許可)。',' または 'G': グループ化 (1,000) 区切り記号 (,) の位置を指定します。各グループ化区切り文字の左右には 0 または 9 が必要です。 ' | | to\$1number(expr, fmt) | 文字列 ''expr' を文字列形式 'fmt' に基づく数値に変換します。いずれかの条件が失敗すると、例外をスローします。形式は、大文字と小文字を区別しない次の文字で構成できます。'0' または '9': 0～9 の予想される数字を指定します。形式文字列の 0 または 9 のシーケンスは、入力文字列の数字のシーケンスと一致します。0/9 シーケンスが 0 で始まり、小数点より前である場合は、同じサイズの数字列にしか一致しません。それ以外の場合、シーケンスが 9 で始まるか、小数点の後にある場合、じ桁数またはそれ以下の桁数の数字列と一致する可能性があります。'.' または 'D': 小数点の位置を指定します (オプション、1 回のみ指定可能)。',' または 'G': グループ区切り (千) 記号の位置を指定します (,)。各グループ区切り記号の左右には、0 または 9 を配置する必要があります。'expr'は、数字のサイズに適したグループ区切り記号と一致している必要があります。 ' | | to\$1varchar(numberExpr, formatExpr) | formatExpr に基づいて numberExpr を文字列に変換します。いずれかの条件が失敗すると、例外をスローします。形式は、大文字と小文字を区別しない次の文字で構成できます。'0' または '9': 0～9 の予想される数字を指定します。形式文字列の 0 または 9 の並びは、入力値の数字列と一致し、形式文字列の対応する列と同じ長さの結果文字列を生成します。0/9 の並びが、小数点以下の値の対応部分よりも桁数が多く、0 で始まり、小数点より前にある場合、結果文字列は 0 で左側を埋めます。それ以外の場合は、スペースで埋められます。'.' または 'D': 小数点の位置を指定します (オプション、1 回のみ許可)。',' または '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) | 文字列 'expr' を文字列形式 fmt に基づく数値に変換します。文字列 'expr' が予想される形式と一致しない場合、NULL を返します。形式は to\$1number 関数と同じセマンティクスに従います。 | | ucase(str) | すべての文字を大文字に変更して str を返します。 | | unbase64(str) | 引数をベース 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) | タイムゾーン sourceTs のないタイムスタンプを sourceTz タイムゾーンから 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) | タイムスタンプ ts を、形式モデル fmt で指定された単位に切り捨てて返します。 | | 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(タイムスタンプ) | 文字列/タイムスタンプの分の要素を返します。 | | month(date) | 日付/タイムスタンプの月の要素を返します。 | | months\$1between(timestamp1, timestamp2[, roundOff]) | timestamp1 が timestamp2 より後の場合、結果は正になります。timestamp1 と timestamp2 が同じ月の日付である場合、または両方とも月末の日付である場合、時刻情報は無視されます。それ以外の場合、その差分は 1 か月を 31 日として計算され、roundOff=false でない限り小数点以下 8 桁に丸められます。 | | next\$1day(start\$1date, day\$1of\$1week) | 指定された名前の start\$1date より後の最初の日付を返します。入力パラメータの少なくとも 1 つが NULL の場合、関数は NULL を返します。 | | now() | クエリ評価の開始時点の現在のタイムスタンプを返します。 | | quarter(date) | 日付の四半期を 1～4 の範囲で返します。 | | 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 週間は月曜日に開始されると見なされ、第 1 週は 3 日より多い日数の最初の週です。 | | window(time\$1column, window\$1duration[, slide\$1duration[, start\$1time]]) | 列を指定するタイムスタンプに基づき、行を 1 つ以上の時間枠にバケット化します。ウィンドウの開始は含まれますが、ウィンドウの終了は含まれません。例えば、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) を使用して、2 つ以上の式を組み合わせることができます。 **順序付きセット集計関数 ** これらの集計関数は、値を並び替える式 (通常は列名) を指定するため、ほかの集約関数とは異なる構文を使用します。 **構文 ** ``` { 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) を使用して、2 つ以上の式を組み合わせることができます。 **例** ``` 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 の場合、expr2 を返します。それ以外の場合は expr1 を返します。 | | nanvl(expr1, expr2) | NaN でない場合は expr1 を返します。それ以外の場合は expr2 を返します。 | | nullif(expr1, expr2) | expr1 が expr2 に等しい場合は null を返し、それ以外の場合は expr1 を返します。 | | nvl(expr1、expr2) | expr1 が null の場合、expr2 を返します。それ以外の場合は expr1 を返します。 | | nvl2(expr1, expr2, expr3) | expr1 が null でない場合は expr2 を返します。それ以外の場合は expr3 を返します。 | | 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) | array1 に含まれ、array2 には含まれていない要素を重複なしで返します。 | | 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 は、double/float 型について NaN 以外の要素よりも大きくなります。NULL 要素はスキップされます。 | | array\$1min(array) | 配列内の最小値を返します。NaN は、double/float 型について NaN 以外の要素よりも大きくなります。NULL 要素はスキップされます。 | | array\$1position(array, element) | 配列の最初に見つかった一致要素の (1 ベース) インデックスを、logn 型で返します。一致する要素が見つからない場合は 0 を返します。 | | array\$1prepend(array, element) | 最初の引数として渡された配列の先頭に要素を追加します。要素のタイプは、配列の要素のタイプと同じである必要があります。Null 要素も配列の先頭に付け加えられます。ただし、渡された配列が NULL の場合、出力も NULL になります | | array\$1remove(array, element) | 配列から要素と等しいすべての要素を削除します。 | | array\$1repeat(element, count) | 要素のカウント時間を含む配列を返します。 | | array\$1union(array1, array2) | array1 と array2 の和集合内の要素の配列を重複せずに返します。 | | arrays\$1overlap(a1, a2) | a1 に、a2 存在する NULL 以外の要素が少なくとも 1 つ含まれている場合は true を返します。配列に共通の要素がなく、両方とも空ではなく、どちらかに null 要素が含まれている場合は null が返され、それ以外の場合は false が返されます。 | | arrays\$1zip(a1, a2, ...) | 入力配列のすべての N 番目の値を含む N 番目の構造体を要素とする構造体のマージされた配列を返します。 | | flatten(arrayOfArrays) | 配列の配列を 1 つの配列に変換します。 | | get(array, index) | 指定された (0 ベースの) インデックスで配列の要素を返します。インデックスが配列の境界外を指す場合、この関数は NULL を返します。 | | sequence(start, stop, step) | 開始値から終了値まで (終了値を含む)、段階的に増分させながら要素の配列を生成します。戻り値の要素の型は、引数式の型と同じです。サポートされている型は、byte、short、integer、long、date、timestamp です。開始式と終了式は同じ型に解決する必要があります。開始式と終了式が 'date' 型または 'timestamp' 型に解決される場合、ステップ式は 'interval' 型、'year-month interval' 型、または 'day-time interval' 型に解決する必要があります。それ以外の場合は、開始式および終了式と同じ型に解決する必要があります。 | | shuffle(array) | 指定された配列のランダム順列を返します。 | | slice(x, start, length) | 指定された長さで、インデックスの開始から始まる配列 x の部分集合を抽出します (配列インデックスは 1 から始まり、開始が負の場合は末尾から始まります)。 | | sort\$1array(array[, ascendingOrder]) | 配列要素の自然な順序に従って、入力配列を昇順または降順にソートします。NaN は、double/float 型について 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]| +-----------------------------------------+ ``` #### Window 関数 **注記** この SQL コマンドをサポートする AWS データソース統合を確認するには、「」を参照してください[サポートされている OpenSearch SQL コマンドと関数](#supported-directquery-sql)。 ウィンドウ関数は、ウィンドウと呼ばれる行の集合に対して動作し、その集合に基づいて各行ごとに戻り値を計算します。ウィンドウ関数は、移動平均の計算、累積統計の計算、現在の行から相対的な位置にある行の値にアクセスするなどのタスク処理に有用です。 **[Syntax]** (構文) ``` 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` – ウィンドウ関数を評価するときに 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 | 論理否定。 | | 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 が大文字と小文字を区別せずに `pattern` に `escape` で一致する場合は 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 | 論理否定。 | | 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` の逆コサイン (a.k.a. arc cosine) を返します。 | | acosh(expr) | `expr` の逆双曲線コサインを返します。 | | asin(expr) | `java.lang.Math.asin` で計算された場合と同様に、`expr` の逆サイン (a.k.a. アークサイン) を返します。 | | asinh(expr) | `expr` の逆双曲線サインを返します。 | | atan(expr) | `java.lang.Math.atan` で計算された場合と同様に、`expr` の逆タンジェント (a.k.a. アークタンジェント) を返します。 | | atan2(exprY, exprX) | `java.lang.Math.atan2` で計算された場合と同様に、平面の正の x 軸と座標で指定されたポイント (`exprX`、`exprY`) の間の角度をラジアンで返します。 | | atanh(expr) | `expr` の逆双曲線タンジェントを返します。 | | bin(expr) | バイナリで表される長い値 `expr` の文字列表現を返します。 | | bround(expr, d) | HALF\$1EVEN 四捨五入モードを使用して、`expr` を `d` 小数位に四捨五入して返します。 | | 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() | オイラー数 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) | `expr` の対数を、`base` で計算して返します。 | | log10(expr) | `expr` の対数を、底 10 で計算して返します。 | | log1p(expr) | log(1 \$1 `expr`) を返します。 | | log2(expr) | `expr` の対数を、底 2 で計算して返します。 | | expr1 mod expr2 | `expr1`/`expr2` の余りを返します。 | | negative(expr) | `expr` の符号を反転させた値を返します。 | | pi() | pi を返します。 | | pmod(expr1, expr2) | `expr1` を `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]) | 標準正規分布 (平均 0、標準偏差 1) に従う、独立かつ同一分布 (i.i.d.) の乱数を返す。 | | random([seed]) | [0, 1) の範囲で一様分布に従う、独立かつ同一分布 (i.i.d.)の乱数を返します。 | | rint(expr) | 引数に最も近い値で、数学的に整数となる倍精度浮動小数点値を返します。 | | round(expr, d) | HALF\$1UP 四捨五入モードを使用して、`expr` を `d` 小数位に四捨五入して返します。 | | 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` から `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 は、1 つ以上のテーブルから結果セットを取得するために使用される `SELECT` ステートメントをサポートしています。次のセクションでは、次のセクションでは、クエリの全体的な構文と、クエリのさまざまな構成要素について説明します。 **[Syntax]** (構文) ``` 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` 句は、1 つ以上の行を含む仮想テーブルを生成する `EXPLODE` などのジェネレータ関数と組み合わせて使用されます。 `LATERAL VIEW` は、元の各出力行に行を適用します。 + **WHERE** 指定された述語に基づいて `FROM` 句の結果をフィルタリングします。 + **GROUP BY ** 行のグループ化に使用される式を指定します。 これは、集計関数 (`MIN`、`MAX`、`COUNT`、`SUM`、`AVG` など) と組み合わせて使用され、各グループのグループ化式と集計値に基づいて行をグループ化します。 `FILTER` 句が集計関数にアタッチされると、一致する行のみがその関数に渡されます。 + **HAVING** `GROUP BY` によって生成された行をフィルタリングする述語を指定します。 `HAVING` 句は、グループ化の実行後に行をフィルタリングするために使用されます。 `HAVING` が `GROUP BY` なしで指定されている場合、式をグループ化しないで (グローバル集計) `GROUP BY` を示します。 + **ORDER BY** クエリの完全な結果セットの行の順序を指定します。 出力行はパーティション間で順序付けられます。 このパラメータは `SORT BY` および `DISTRIBUTE BY` と相互に排他的であり、一緒に指定することはできません。 + **SORT BY ** 各パーティション内で行が並び替えられる順序を指定します。 このパラメータは `ORDER BY` と相互に排他的であり、一緒に指定することはできません。 + **LIMIT** ステートメントまたはサブクエリによって返される行の最大数を指定します。 この句は、決定的な結果を生成するために主に `ORDER BY` と組み合わせて使用されます。 + **boolean\$1expression ** 結果の型がブール値に評価される式を指定します。 論理演算子 (`AND`、`OR`) を使用して、2 つ以上の式を組み合わせることができます。 + **expression** 1 つ以上の値、演算子、SQL 関数を組み合わせて構成され、値として評価される式を指定します。 + **named\$1window ** 1 つ以上のソースウィンドウ仕様のエイリアスを指定します。 ソースウィンドウの仕様は、クエリのウィンドウ定義で参照できます。 #### WHERE 句 **注記** この SQL コマンドをサポートする AWS データソース統合を確認するには、「」を参照してください[サポートされている OpenSearch SQL コマンドと関数](#supported-directquery-sql)。 `WHERE` 句は、指定された条件に基づいてクエリまたはサブクエリの `FROM` 句の結果を制限するために使用されます。 **[Syntax]** (構文) ``` WHERE boolean_expression ``` パラメータ**** + **boolean\$1expression** 結果の型がブール値に評価される式を指定します。 論理演算子 (`AND`、`OR`) を使用して、2 つ以上の式を組み合わせることができます。 **例** ``` 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` 句は、指定されたグループ化式のセットに基づいて行をグループ化し、1 つ以上の指定された集計関数に基づいて行のグループで集計を計算するために使用されます。 システムは、`GROUPING SETS`、`CUBE`、`ROLLUP` 句を介して同じ入力レコードセットに対して複数の集計も実行します。グループ化式と高度な集計は、`GROUP BY` 句内で混在させることができ、また `GROUPING SETS ` 句内にネストさせることができます。詳細については、「`Mixed/Nested Grouping Analytics `」セクションを参照してください。 `FILTER` 句が集計関数にアタッチされると、一致する行のみがその関数に渡されます。 **[Syntax]** (構文) ``` 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 ** グループ化セットは、括弧内のゼロ個以上のカンマ区切り式で指定されます。グループ化セットに 1 つの要素しかない場合、括弧は省略できます。 例えば、`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**** 1 つのステートメントで複数のレベルの集計を指定します。この句は、複数のグループ化セットに基づいて集計を計算するために使用されます。`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` 句と組み合わせて使用されます。 **[Syntax]** (構文) ``` HAVING boolean_expression ``` パラメータ**** + **boolean\$1expression ** 結果の型がブール値に評価される式を指定します。論理演算子 (`AND`、`OR`) を使用して、2 つ以上の式を組み合わせることができます。 **注** `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 句とは異なり、この句は出力の合計順序を保証します。 **[Syntax]** (構文) ``` 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 結合は、結合条件に基づいて 2 つのリレーションの行を組み合わせるために使用されます。次のセクションでは、全体的な結合構文とさまざまなタイプの結合を例とともに説明します。 **[Syntax]** (構文) ``` relation INNER JOIN relation [ join_criteria ] ``` パラメータ**** + **リレーション ** 結合するリレーションを指定します。 + **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 ** クロス結合は、2 つのリレーションの直積集合を返します。 構文: `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` と組み合わせて使用され、結果が決定的であることを確認します。 **[Syntax]** (構文) ``` 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 ステートメントと同様に、指定された条件に基づいて特定の結果を返します。 **[Syntax]** (構文) ``` CASE [ expression ] { WHEN boolean_expression THEN then_expression } [ ... ] [ ELSE else_expression ] END ``` パラメータ**** + **boolean\$1expression ** 結果の型がブール値に評価される式を指定します。 論理演算子 (`AND`、`OR`) を使用して、2 つ以上の式を組み合わせることができます。 + **then\$1expression ** boolean\$1expression 条件に基づいて、次に式を指定します。 `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` ステートメントで使用されます。 **[Syntax]** (構文) ``` 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` ステートメントは、入力ステートメントの論理/物理プランを提供するために使用されます。デフォルトでは、この句は物理プランに関する情報のみを提供します。 **[Syntax]** (構文) ``` EXPLAIN [ EXTENDED | CODEGEN | COST | FORMATTED ] statement ``` パラメータ**** + **EXTENDED** 解析された論理計画、分析された論理計画、最適化された論理計画、物理計画を生成します。 解析された論理計画は、クエリから抽出された未解決の計画です。 分析された論理プランは、`unresolvedAttribute` と `unresolvedRelation` を完全型オブジェクトに変換します。 最適化論理プランは、一連の最適化ルールを通じて変換され、物理プランになります。 + **CODEGEN** および物理プランがある場合は、ステートメントのコードを生成します。 + **COST** 計画ノード統計が利用可能な場合、論理計画と統計を生成します。 + **FORMATTED** 物理プランの概要とノードの詳細の 2 つのセクションを生成します。 + **ステートメント** 説明する 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` は複雑なクエリをより簡単かつ効率的にします。 **[Syntax]** (構文) ``` [ 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` 句は、1 つ以上の行を含む仮想テーブルを生成する `EXPLODE` などのジェネレータ関数と組み合わせて使用されます。`LATERAL VIEW` は、元の各出力行にその行を適用します。 **[Syntax]** (構文) ``` 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` などの定量化子を持つ複数のパターンもサポートしています。 **[Syntax]** (構文) ``` [ 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` 句で検索する正規表現検索パターンを指定します。 + **数量詞** `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` と組み合わせて使用され、結果が決定的であることを確認します。 **[Syntax]** (構文) ``` 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` 句は、テーブル名またはサブクエリの後に指定できます。 **[Syntax]** (構文) ``` 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)。 セット演算子は、2 つの入力リレーションを 1 つのリレーションに結合するために使用されます。OpenSearch SQL は、次の 3 種類のセット演算子をサポートしています。 + `EXCEPT`、または `MINUS` + `INTERSECT` + `UNION` 入力リレーションには、それぞれの列に対して同じ数の列と互換性のあるデータ型が必要です。 **例外** `EXCEPT` と `EXCEPT ALL` は、あるリレーションで見つかった行を返しますが、他のリレーションでは返されません。`EXCEPT` (または `EXCEPT DISTINCT`) は個別の行のみを取りますが、`EXCEPT ALL` は結果行から重複を削除しません。`MINUS` は `EXCEPT` のエイリアスであることに注意してください。 **[Syntax]** (構文) ``` [ ( ] 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` は結果行から重複を削除しません。 **[Syntax]** (構文) ``` [ ( ] 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` は結果行から重複を削除しません。 **[Syntax]** (構文) ``` [ ( ] 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` 句とは異なります。 **[Syntax]** (構文) ``` 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` 句は、テーブル名またはサブクエリの後に指定できます。 **[Syntax]** (構文) ``` 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 | +------+------------------+---------------+----------------+ ```