Amazon Redshift は、パッチ 198 以降、新しい Python UDF の作成をサポートしなくなります。既存の Python UDF は、2026 年 6 月 30 日まで引き続き機能します。詳細については、[ブログ記事](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/)を参照してください。
# SQL リファレンス
Amazon Redshift を使用すると、SQL を活用して、データウェアハウスに保存されている大量のデータを効率的にクエリおよび分析できます。SQL リファレンスでは、SQL コマンド、データ型、関数、演算子などの構文と用途について説明しており、インサイトを抽出してデータドリブンな意思決定を行うことができます。このリファレンスを参照して、最適化されたクエリを記述し、データベースオブジェクトを作成および管理し、複雑なデータ変換を実行できます。以下のリファレンスでは、Amazon Redshift 環境内で SQL を使用してデータ分析要件を満たすための包括的な詳細を説明しています。
**Topics**
+ [Amazon Redshift SQL](c_redshift-sql.md)
+ [SQL の使用](c_SQL_reference.md)
+ [SQL コマンド](c_SQL_commands.md)
+ [SQL 関数リファレンス](c_SQL_functions.md)
+ [予約語](r_pg_keywords.md)
# Amazon Redshift SQL
**Topics**
+ [リーダーノードでサポートされる SQL 関数](c_sql-functions-leader-node.md)
+ [Amazon Redshift および PostgreSQL](c_redshift-and-postgres-sql.md)
Amazon Redshift は、業界標準の SQL をベースに構築され、大規模データセットを管理する機能やハイパフォーマンス分析および分析結果のレポートをサポートする機能が追加されています。
**注記**
単一 Amazon Redshift SQL ステートメントの最大サイズは 16 MB です。
# リーダーノードでサポートされる SQL 関数
一部のAmazon Redshift クエリはコンピューティングノードに配布され実行されます。ほかのクエリはリーダーノードのみで実行されます。
ユーザーによって作成されたテーブルまたはシステムテーブル (STL または STV プレフィックスが付いたテーブル、SVL または SVV プレフィックスが付いたシステムビュー) をクエリが参照するたびに、リーダーノードは SQL をコンピューティングノードに配布します。リーダーノード上の PG プレフィックス付きカタログ テーブル (PG\$1TABLE\$1DEF など) のみを参照するクエリや、いずれのテーブルも参照しないクエリは、リーダーノード上で排他的に実行されます。
Amazon Redshift SQL 関数の中にはリーダーノードのみでサポートされ、コンピューティングノードではサポートされないものがあります。リーダーノード専用関数を使用するクエリは、コンピューティングノードではなくリーダーノードのみで実行される必要があり、そうでなければエラーが返されます。
リーダーノードで排他的に実行されるべき関数がユーザー定義テーブルまたは Amazon Redshift システムテーブルを参照した場合、ドキュメントにメモとして説明されているとおり、エラーが返されます。リーダーノードで排他的に実行される関数については、「[リーダーノード専用関数](c_SQL_functions_leader_node_only.md)」を参照してください。
## 例
次の例では、TICKIT のサンプルデータベースを使用します。サンプルデータベースの詳細については、「[サンプルデータベース](c_sampledb.md)」を参照してください。
**CURRENT\$1SCHEMA**
CURRENT\$1SCHEMA 関数は、リーダーノード専用の関数です。この例では、クエリはテーブルを参照しないのでリーダーノードで排他的に実行されます。
```
select current_schema();
current_schema
---------------
public
```
次の例に示すクエリは、システムカタログテーブルを参照するので、リーダーノードで排他的に実行されます。
```
select * from pg_table_def
where schemaname = current_schema() limit 1;
schemaname | tablename | column | type | encoding | distkey | sortkey | notnull
------------+-----------+--------+----------+----------+---------+---------+---------
public | category | catid | smallint | none | t | 1 | t
```
次の例に示すクエリは、コンピューティングノード上の Amazon Redshift システムテーブルを参照するため、エラーを返します。
```
select current_schema(), userid from users;
INFO: Function "current_schema()" not supported.
ERROR: Specified types or functions (one per INFO message) not supported on Amazon Redshift tables.
```
**SUBSTR**
SUBSTR もリーダーノード専用の関数です。次の例では、クエリはテーブルを参照しないのでリーダーノードで排他的に実行されます。
```
SELECT SUBSTR('amazon', 5);
+--------+
| substr |
+--------+
| on |
+--------+
```
次の例に示すクエリは、コンピューティングノード上のテーブルを参照します。その結果、エラーが発生します。
```
SELECT SUBSTR(catdesc, 1) FROM category LIMIT 1;
ERROR: SUBSTR() function is not supported (Hint: use SUBSTRING instead)
```
前のクエリを正常に実行するには、[SUBSTRING](https://docs.aws.amazon.com/redshift/latest/dg/r_SUBSTRING.html) を使用してください。
```
SELECT SUBSTRING(catdesc, 1) FROM category LIMIT 1;
+---------------------------------+
| substring |
+---------------------------------+
| National Basketball Association |
+---------------------------------+
```
**FACTORIAL()**
FACTORIAL() はリーダーノード専用の関数です。次の例では、クエリはテーブルを参照しないのでリーダーノードで排他的に実行されます。
```
SELECT FACTORIAL(5);
factorial
-------------
120
```
次の例に示すクエリは、コンピューティングノード上のテーブルを参照します。これにより、クエリエディタ v2 を使用して実行すると、エラーが発生します。
```
create table t(a int);
insert into t values (5);
select factorial(a) from t;
ERROR: Specified types or functions (one per INFO message) not supported on Redshift tables.
Info: Function "factorial(bigint)" not supported.
```
# Amazon Redshift および PostgreSQL
**Topics**
+ [Amazon Redshift、PostgreSQL JDBC および ODBC](c_redshift-postgres-jdbc.md)
+ [実装方法が異なる機能](c_redshift-sql-implementated-differently.md)
+ [サポートされていない PostgreSQL 機能](c_unsupported-postgresql-features.md)
+ [サポートされていない PostgreSQL データ型](c_unsupported-postgresql-datatypes.md)
+ [サポートされていない PostgreSQL 関数](c_unsupported-postgresql-functions.md)
Amazon Redshift は PostgreSQL に基づいています。Amazon Redshift と PostgreSQL の間には非常に重要な相違点がいくつかあり、データウェアハウスアプリケーションを設計して開発するときはそれを考慮する必要があります。
Amazon Redshift は、具体的には、大規模データセットに対して複雑なクエリを行う必要があるオンライン分析処理 (OLAP) アプリケーションおよびビジネスインテリジェンス (BI) アプリケーション向けに設計されています。Amazon Redshift は多種多様な要件に対処するため、Amazon Redshift で使用する専用のデータストレージスキーマおよびクエリ実行エンジンは PostgreSQL の実装とは完全に異なります。例えば、オンライントランザクション処理 (OLTP) アプリケーションが一般的にデータを行に保存する場合、Amazon Redshift は、最適なメモリ使用量とディスク I/O のために特殊なデータ圧縮エンコードを使用してデータを列に保存します。セカンダリインデックスおよび効率的な単一行データオペレーションなど、小規模な OLTP 処理に適した一部の PostgreSQL 機能はパフォーマンスを向上させるために省略されています。
Amazon Redshift データウェアハウスシステムのアーキテクチャの詳細については、[Amazon Redshift アーキテクチャ](c_redshift_system_overview.md) を参照してください。
PostgreSQL 9.x には、Amazon Redshift によってサポートされていない機能が一部含まれています。さらに、Amazon Redshift SQL と PostgreSQL との間には、認識しておく必要がある重要な違いがあります。このセクションでは、Amazon Redshift と PostgreSQL との違いに焦点を当てるとともに、SQL 実装を十分に活用したデータウェアハウスを開発するためのガイダンスを提供します。
# Amazon Redshift、PostgreSQL JDBC および ODBC
Amazon Redshift は PostgreSQL に基づいているため、以前は JDBC4 Postgresql のドライバーバージョン 8.4.703 および psqlODBC バージョン 9.x ドライバーを使用することをお勧めしました。これらのドライバーを現在使用している場合は、新しい Amazon Redshift 特定のドライバーに移行することをお勧めします。ドライバーと接続の設定の詳細については、「*Amazon Redshift 管理ガイド*」の「[Amazon Redshift 用の JDBC および ODBC ドライバー](https://docs.aws.amazon.com/redshift/latest/mgmt/configuring-connections.html#connecting-drivers)」を参照してください。
JDBC を使用して大きなデータセットを取得する際にユーザー側でメモリ不足エラーが発生することを避けるため、JDBC フェッチサイズパラメータを指定して、クライアントがデータをバッチ単位でフェッチするように設定できます。詳細については、「[JDBC フェッチサイズパラメータの設定](set-the-JDBC-fetch-size-parameter.md)」を参照してください。
Amazon Redshift は JDBC maxRows パラメータを認識しません。その代わり、結果セットを制限するには [LIMIT](r_ORDER_BY_clause.md#order-by-clause-limit) 句を指定します。また、[OFFSET](r_ORDER_BY_clause.md#order-by-clause-offset) 句を使用して結果セット内の特定の開始点にスキップすることもできます。
# 実装方法が異なる機能
Amazon Redshift SQL の多くの言語要素は、対応する PostgreSQL 実装とはパフォーマンス特性が異なり、使用する構文およびセマンティクスもまったく異なるものとなっています。
**重要**
Amazon Redshift と PostgreSQL に含まれる共通要素のセマンティクスは同じであるとみなさないでください。判断しかねる差異については、*Amazon Redshift デベロッパーガイド*の [SQL コマンド](c_SQL_commands.md) を参照して確認してください。
具体的な例として [VACUUM](r_VACUUM_command.md) コマンドが挙げられます。これはテーブルのクリーンアップおよび再編成に使用されます。VACUUM は PostgreSQL バージョンの場合とは機能が異なり、異なるパラメータセットを使用します。Amazon Redshift での VACUUM の使用についての詳細は、[テーブルのバキューム処理](t_Reclaiming_storage_space202.md) を参照してください。
しばしば、データベース管理機能およびツールも異なることがあります。例えば、Amazon Redshift では、システムの稼働状況に関する情報を、一連のシステムテーブルおよびビューで確認できる仕組みになっています。詳細については、「[SYS モニタリングビュー](serverless_views-monitoring.md)」を参照してください。
Amazon Redshift 独自の実装を有する SQL 機能の例を以下に示します。
+ [CREATE TABLE](r_CREATE_TABLE_NEW.md)
Amazon Redshift では、テーブルスペース、テーブル分割、継承、および特定の制約をサポートしていません。Amazon Redshift の CREATE TABLE では、テーブルに対してソートおよびディストリビューションのアルゴリズムを定義することで、並列処理を最適化することができます。
Amazon Redshift Spectrum では、[CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md) コマンドを使用したテーブルのパーティショニングをサポートしています。
+ [ALTER TABLE](r_ALTER_TABLE.md)
ALTER COLUMN アクションのサブセットのみがサポートされています。
ADD COLUMN の場合、各 ALTER TABLE ステートメントで 1 つの列しか追加できません。
+ [COPY](r_COPY.md)
Amazon Redshift の COPY コマンドは、Amazon S3 バケットおよび Amazon DynamoDB テーブルからのデータのロードを可能にし、自動圧縮を容易にすることに特化されています。詳細については、「[Amazon Redshift でのデータのロード](t_Loading_data.md)」セクションおよび COPY コマンドリファレンスを参照してください。
+ [VACUUM](r_VACUUM_command.md)
VACUUM のパラメータは完全に異なります。例えば、PostgreSQL のデフォルトの VACUUM オペレーションは、単純に領域を再利用し、再び使用できるようにするだけです。一方で、Amazon Redshift のデフォルトの VACUUM オペレーションは VACUUM FULL です。これは、ディスク領域を再利用し、すべての行を再ソートします。
+ VARCHAR 値の末尾のスペースは、文字列値の比較時に無視されます。詳細については、「[末尾の空白の重要性](r_Character_types.md#r_Character_types-significance-of-trailing-blanks)」を参照してください。
# サポートされていない PostgreSQL 機能
Amazon Redshift でサポートされていないこれらの PostgreSQL 機能を示します。
**重要**
Amazon Redshift と PostgreSQL に含まれる共通要素のセマンティクスは同じであるとみなさないでください。判断しかねる差異については、*Amazon Redshift デベロッパーガイド*の [SQL コマンド](c_SQL_commands.md) を参照して確認してください。
+ クエリツール *psql* はサポートされていません。[Amazon Redshift RSQL](https://docs.aws.amazon.com/redshift/latest/mgmt/rsql-query-tool.html) クライアントはサポートされています。
+ テーブル分割 (範囲およびリストの分割)
+ テーブルスペース
+ 制約
+ Unique
+ 外部キー
+ 主キー
+ 検査制約
+ 排他制約
一意制約、主キー制約、および外部キー制約は許可されますが、情報提供専用です。これらの制約はシステムでは実施されませんが、クエリプランナーによって使用されます。
+ 継承
+ PostgreSQL システム列
Amazon Redshift SQL ではシステム列を暗黙的に定義しません。ただし、PostgreSQL システム列の名前 `oid`、`tableoid`、`xmin`、`cmin`、`xmax`、`cmax`、および `ctid` を、ユーザー定義の列の名前として使用することはできません。詳細については、[https://www.postgresql.org/docs/8.0/static/ddl-system-columns.html](https://www.postgresql.org/docs/8.0/static/ddl-system-columns.html) を参照してください。
+ インデックス
+ ウィンドウ関数の NULLS 句
+ 照合
Amazon Redshift では、ロケール固有の照合順序またはユーザー定義の照合順序をサポートしていません。「[照合順序](c_collation_sequences.md)」を参照してください。
+ 値式
+ 添字付き式
+ 配列コンストラクタ
+ 行コンストラクタ
+ トリガー
+ 外部データの管理 (SQL/MED)
+ テーブル関数
+ 定数テーブルとして使用される VALUES リスト
+ シーケンス
+ フルテキスト検索
+ RULE および TRIGGER アクセス許可。
Amazon Redshift は、GRANT ALL または REVOKE ALL を実行するときにこれらのアクセス許可を付与または取り消しますが、RULE と TRIGGER アクセス許可の有無は、いかなる場合も被付与者のアクセス許可に影響しません。
# サポートされていない PostgreSQL データ型
一般にクエリは、サポートされていないデータ型 (明示的または暗黙的なキャストなど) の使用を試みると、エラーを返します。ただし、サポートされていないデータ型を使用する一部のクエリはリーダーノードで実行されますが、コンピューティングノードでは実行されません。「[リーダーノードでサポートされる SQL 関数](c_sql-functions-leader-node.md)」を参照してください。
サポートされているデータ型のリストについては、「[データ型](c_Supported_data_types.md)」を参照してください。
Amazon Redshift でサポートされていないこれらの PostgreSQL データタイプを示します。
+ 配列
+ BIT、BIT VARYING
+ BYTEA
+ コンポジット型
+ 列挙型
+ ジオメトリ型 (ジオメトリ型の Amazon Redshift 実装は PostgreSQL とは異なります)
+ HSTORE
+ JSON
+ ネットワークアドレス型
+ 数値型
+ SERIAL、BIGSERIAL、SMALLSERIAL
+ MONEY
+ オブジェクト識別子型
+ 疑似型
+ 範囲型
+ 特殊な文字型
+ "char" – シングルバイトの内部型 (char というデータ型は引用符で囲まれている)。
+ name – オブジェクト名の内部型。
このような型の詳細については、PostgreSQL ドキュメントの「[特殊な文字型](https://www.postgresql.org/docs/8.0/datatype-character.html)」を参照してください。
+ テキスト検索型
+ TXID\$1SNAPSHOT
+ UUID
+ XML
# サポートされていない PostgreSQL 関数
サポートされている関数もその多くは、PostgreSQL とセマンティクスや用途が異なります。例えば、サポートされている関数の中にはリーダーノードでしか実行されないものがあります。また、サポートされていない関数の中には、リーダーノードで実行された場合、エラーを返さないものがあります。いくつかのケースでこれらの関数がエラーを返さないからといって、関数が Amazon Redshift によってサポートされていると受け取るべきではありません。
**重要**
Amazon Redshift と PostgreSQL に含まれる共通要素のセマンティクスは同じであるとみなさないでください。判断しかねる差異については、*Amazon Redshift データベースデベロッパーガイド*の [SQL コマンド](c_SQL_commands.md) を参照して確認してください。
詳細については、「[リーダーノードでサポートされる SQL 関数](c_sql-functions-leader-node.md)」を参照してください。
Amazon Redshift でサポートされていないこれらの PostgreSQL 機能を示します。
+ アクセス特権照会関数
+ アドバイザリロック関数
+ 集計関数
+ STRING\$1AGG()
+ ARRAY\$1AGG()
+ EVERY()
+ XML\$1AGG()
+ CORR()
+ COVAR\$1POP()
+ COVAR\$1SAMP()
+ REGR\$1AVGX()、REGR\$1AVGY()
+ REGR\$1COUNT()
+ REGR\$1INTERCEPT()
+ REGR\$1R2()
+ REGR\$1SLOPE()
+ REGR\$1SXX()、REGR\$1SXY()、REGR\$1SYY()
+ 配列関数と演算子
+ バックアップ管理関数
+ コメント情報関数
+ データベースオブジェクト位置関数
+ データベースオブジェクトサイズ関数
+ 日付/時刻関数と演算子
+ CLOCK\$1TIMESTAMP()
+ JUSTIFY\$1DAYS()、JUSTIFY\$1HOURS()、JUSTIFY\$1INTERVAL()
+ PG\$1SLEEP()
+ TRANSACTION\$1TIMESTAMP()
+ ENUM サポート関数
+ 幾何関数と演算子
+ 汎用ファイルアクセス関数
+ IS DISTINCT FROM
+ ネットワークアドレス関数と演算子
+ 数学関数
+ DIV()
+ SETSEED()
+ WIDTH\$1BUCKET()
+ セットを返す関数
+ GENERATE\$1SERIES()
+ GENERATE\$1SUBSCRIPTS()
+ 範囲関数と演算子
+ リカバリ制御関数
+ リカバリ情報関数
+ ROLLBACK\$1TO\$1SAVEPOINT 関数
+ スキーマ可視性照会関数
+ サーバーシグナリング関数
+ スナップショット同期関数
+ シーケンス操作関数
+ 文字列関数
+ BIT\$1LENGTH()
+ OVERLAY()
+ CONVERT()、CONVERT\$1FROM()、CONVERT\$1TO()
+ ENCODE()
+ FORMAT()
+ QUOTE\$1NULLABLE()
+ REGEXP\$1MATCHES()
+ REGEXP\$1SPLIT\$1TO\$1ARRAY()
+ REGEXP\$1SPLIT\$1TO\$1TABLE()
+ システムカタログ情報関数
+ システム情報関数
+ CURRENT\$1CATALOG CURRENT\$1QUERY()
+ INET\$1CLIENT\$1ADDR()
+ INET\$1CLIENT\$1PORT()
+ INET\$1SERVER\$1ADDR() INET\$1SERVER\$1PORT()
+ PG\$1CONF\$1LOAD\$1TIME()
+ PG\$1IS\$1OTHER\$1TEMP\$1SCHEMA()
+ PG\$1LISTENING\$1CHANNELS()
+ PG\$1MY\$1TEMP\$1SCHEMA()
+ PG\$1POSTMASTER\$1START\$1TIME()
+ PG\$1TRIGGER\$1DEPTH()
+ SHOW VERSION()
+ テキスト検索関数と演算子
+ トランザクション ID およびスナップショット関数
+ トリガー関数
+ XML 関数
# SQL の使用
**Topics**
+ [SQL リファレンスの規則](c_SQL_reference_conventions.md)
+ [基本的要素](c_Basic_elements.md)
+ [式](r_expressions.md)
+ [条件](r_conditions.md)
SQL 言語は、データベースおよびデータベースオブジェクトを操作するために使用するコマンドおよび関数から構成されています。SQL 言語はまた、データ型、式、およびリテラルに関するルールを適用します。
# SQL リファレンスの規則
このセクションでは、SQL リファレンスのセクションに記載されている SQL の式、コマンド、および関数の構文を記述する際に使用される規則について説明します。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/c_SQL_reference_conventions.html)
# 基本的要素
**Topics**
+ [名前と識別子](r_names.md)
+ [リテラル](r_Literals.md)
+ [Null](r_Nulls.md)
+ [データ型](c_Supported_data_types.md)
+ [照合順序](c_collation_sequences.md)
このセクションでは、データベースオブジェクトの名前、リテラル、Null、およびデータ型を操作するためのルールについて説明します。
# 名前と識別子
名前は、データベースオブジェクト (テーブルや列など) と、ユーザーおよびパスワードを識別します。*名前*という用語と*識別子*という用語は、ほとんど同じ意味で使用できます。2 種類の識別子があります。標準的な識別子と、引用符で囲まれた (すなわち、区切り記号付き) 識別子です。識別子は UTF-8 印字可能文字のみで構成する必要があります。標準的な識別子と区切り記号付き識別子の ASCII 文字は、大文字と小文字の区別がありませんが、データベースでは小文字で表記されます。クエリの結果では、列名は、デフォルトで小文字で返されます。列名を大文字で返すには、[describe\$1field\$1name\$1in\$1uppercase](r_describe_field_name_in_uppercase.md) 設定パラメータを **true** に設定します。
## 標準的な識別子
標準的な SQL 識別子はルールセットに準拠するものであり、以下の条件を満たしている必要があります。
+ ASCII のシングルバイトのアルファベット文字または下線文字、または UTF-8 のマルチバイト文字 (2 バイトから 4 バイト) で開始します。
+ 後続の文字には、ASCII のシングルバイトの英数字、下線、またはドル記号、またはマルチバイトの UTF-8 文字 (2 バイトから 4 バイト) を使用できます。
+ 長さが 1～127 バイトで、区切り記号として引用符を含まない。
+ 引用符とスペースは含めない。
+ 予約された SQL キーワードではない。
## 区切り記号付き識別子
区切り記号付き識別子 (引用符で囲まれた識別子とも言う) は、二重引用符 (") で囲まれます。区切り記号付き識別子を使用する場合は、そのオブジェクトへのすべての参照で二重引用符を使用する必要があります。この識別子には、二重引用符以外の標準の UTF-8 印字可能文字を含めることができます。したがって、任意の文字列 (スペースやパーセント記号など本来なら無効な文字も含む) で列またはテーブルの名前を作成できます。
区切り記号付き識別子の ASCII 文字は、大文字と小文字の区別がありませんが、小文字で表記されます。文字列内で二重引用符を使用するには、その二重引用符の前に別の二重引用符文字を付ける必要があります。
## 大文字と小文字を区別する識別子
大文字と小文字を区別する識別子 (大文字と小文字が混在する識別子とも呼ぶ) には、大文字と小文字の両方を使用することができます。大文字と小文字を区別する識別子を使用するには、構成 `enable_case_sensitive_identifier` を `true` に設定します。この構成は、クラスターまたはセッションに対して設定できます。詳細については、「*Amazon Redshift 管理ガイド*」の「[デフォルトパラメータ値](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-parameter-groups.html#default-param-group-values)」および「[enable\$1case\$1sensitive\$1identifier](r_enable_case_sensitive_identifier.md)」を参照してください。
## システム列名
ただし、次の PostgreSQL システム列の名前を、ユーザー定義の列の名前として使用することはできません。詳細については、[https://www.postgresql.org/docs/8.0/static/ddl-system-columns.html](https://www.postgresql.org/docs/8.0/static/ddl-system-columns.html) を参照してください。
+ `oid`
+ `tableoid`
+ `xmin`
+ `cmin`
+ `xmax`
+ `cmax`
+ `ctid`
## 例
次の表に、区切り記号付き識別子の例、結果として生じる出力、および説明を示します。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_names.html)
this "is it" という名前の列を持つ group という名前のテーブルを作成するには、以下のように記述します。
```
create table "group" (
"This ""IS IT""" char(10));
```
次のクエリは同じ結果を返します。
```
select "This ""IS IT"""
from "group";
this "is it"
--------------
(0 rows)
```
```
select "this ""is it"""
from "group";
this "is it"
--------------
(0 rows)
```
次に示す完全に修飾された `table.column` 構文も同じ結果を返します。
```
select "group"."this ""is it"""
from "group";
this "is it"
--------------
(0 rows)
```
次の CREATE TABLE コマンドは、列名にスラッシュを含むテーブルを作成します。
```
create table if not exists city_slash_id(
"city/id" integer not null,
state char(2) not null);
```
# リテラル
リテラルまたは定数は固定データ値であり、一連の文字または数値定数から構成されます。Amazon Redshift は、次のようないくつかのタイプのリテラルをサポートしています。
+ 数値リテラル。整数、10 進数、および浮動小数点数に使用されます。詳細については、「[整数リテラルと浮動小数点リテラル](r_numeric_literals201.md)」を参照してください。
+ 文字リテラル。文字列、キャラクタ文字列、または文字定数とも呼ばれます。
+ 日時データ型で使用される、日時および間隔のリテラル。詳細については、「[日付、時刻、およびタイムスタンプのリテラル](r_Date_and_time_literals.md)」および「[間隔のデータ型とリテラル](r_interval_data_types.md)」を参照してください。
# Null
行内で列が見つからない場合、列が不明である場合、または列が適用できない場合、その列は Null 値であり、または Null を含んでいるといわれます。Null は、主キー制約または NOT NULL 制約によって制限されないデータ型のフィールドに表示される場合があります。Null は値ゼロまたは空の文字列と等価ではありません。
Null を含む演算式の結果はいずれも常に Null になります。null の引数またはオペランドを指定した場合、すべての演算子は null を返します。
Null かどうかをテストするには、比較条件 IS NULL および IS NOT NULL を使用します。Null はデータが不足していることを表現するものなので、Null はいずれかの値または別の Null に等しいわけでも等しくないわけでもありません。
# データ型
**Topics**
+ [マルチバイト文字](#c_Supported_data_types-multi-byte-characters)
+ [数値型](r_Numeric_types201.md)
+ [文字型](r_Character_types.md)
+ [日時型](r_Datetime_types.md)
+ [ブール型](r_Boolean_type.md)
+ [HLLSKETCH タイプ](r_HLLSKTECH_type.md)
+ [SUPER タイプ](r_SUPER_type.md)
+ [VARBYTE 型](r_VARBYTE_type.md)
+ [型の互換性と変換](#r_Type_conversion)
Amazon Redshift によって保存または取得される各値は、データ型と一定の関連するプロパティセットを持ちます。データ型はテーブルの作成時に宣言されます。データ型は、列または引数に含めることができる値セットを制限します。
次の表に、Amazon Redshift テーブルで使用できるデータ型を一覧表示します。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/c_Supported_data_types.html)
**注記**
サポートされていないデータ型 (「char」は引用符で囲まれています) については、[サポートされていない PostgreSQL データ型](c_unsupported-postgresql-datatypes.md) を参照してください。
## マルチバイト文字
VARCHAR データ型では、最大 4 バイトの UTF-8 マルチバイト文字をサポートします。5 バイト以上の文字はサポートされていません。マルチバイト文字を含む VARCHAR 列のサイズを計算するには、文字数と 1 文字当たりのバイト数を掛けます。例えば、文字列に漢字が 4 文字含まれ、各文字のサイズが 3 バイトである場合は、文字列を格納するのに VARCHAR(12) 列が必要です。
VARCHAR データ型は、次に示す無効な UTF-8 コードポイントをサポートしていません:
`0xD800 – 0xDFFF`(バイトシーケンス:`ED A0 80` –`ED BF BF` )
CHAR データ型は、マルチバイト文字をサポートしていません。
# 数値型
**Topics**
+ [整数型](#r_Numeric_types201-integer-types)
+ [DECIMAL 型または NUMERIC 型](#r_Numeric_types201-decimal-or-numeric-type)
+ [128 ビットの DECIMAL または NUMERIC の列の使用に関する注意事項](#r_Numeric_types201-notes-about-using-128-bit-decimal-or-numeric-columns)
+ [浮動小数点型](#r_Numeric_types201-floating-point-types)
+ [数値に関する計算](r_numeric_computations201.md)
+ [整数リテラルと浮動小数点リテラル](r_numeric_literals201.md)
+ [数値型を使用する例](r_Examples_with_numeric_types201.md)
数値データ型には、整数型、10 進数型、および浮動小数点数型などがあります。
## 整数型
SMALLINT、INTEGER、および BIGINT の各データ型を使用して、各種範囲の数値全体を格納します。各データ型の許容範囲の外にある値を格納することはできません。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_Numeric_types201.html)
## DECIMAL 型または NUMERIC 型
DECIMAL データ型または NUMERIC データ型を使用し、*ユーザー定義の精度*で値を格納します。DECIMAL キーワードと NUMERIC キーワードは同じように使用できます。このドキュメントでは、このデータ型を表す用語として *decimal* を優先的に使用します。*numeric* という用語は一般的に整数、10 進数、および浮動小数点のデータ型を称する場合に使用します。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_Numeric_types201.html)
テーブル内に DECIMAL 列を定義するには、*precision* と *scale* を次のように指定します。
```
decimal(precision, scale)
```
*precision*
値全体での有効な桁の合計。小数点の両側の桁数。例えば、数値 `48.2891` の場合は精度が 6、スケールが 4 となります。指定がない場合、デフォルトの精度は 18 です。最大精度は 38 です。
入力値で小数点の左側の桁数が、列の精度から列のスケールを引いて得られた桁数を超えている場合、入力値を列にコピー (または挿入も更新も) することはできません。このルールは、列の定義を外れるすべての値に適用されます。例えば、`numeric(5,2)` 列の値の許容範囲は、`-999.99`～`999.99` です。
*scale*
小数点の右側に位置する、値の小数部における小数の桁数です。整数のスケールはゼロです。列の仕様では、スケール値は精度値以下である必要があります。指定がなければ、デフォルトのスケールは 0 です。最大スケールは 37 です。
テーブルにロードされた入力値のスケールが列のスケールより大きい場合、値は指定されたスケールに丸められます。SALES テーブルの PRICEPAID 列が DECIMAL(8,2) 列である場合を例にとります。DECIMAL(8,4) の値を PRICEPAID 列に挿入すると、値のスケールは 2 に丸められます。
```
insert into sales
values (0, 8, 1, 1, 2000, 14, 5, 4323.8951, 11.00, null);
select pricepaid, salesid from sales where salesid=0;
pricepaid | salesid
-----------+---------
4323.90 | 0
(1 row)
```
ただし、テーブルから選択された値の明示的なキャストの結果は丸められません。
**注記**
DECIMAL(19,0) 列に挿入できる最大の正の値は、`9223372036854775807` (263 -1) です。最大の負の値は `-9223372036854775808` です。例えば、値 `9999999999999999999` (19 桁の 9 の並び) の挿入を試みると、オーバーフローエラーが発生します。小数点の位置に関係なく、Amazon Redshift が DECIMAL 数として表現できる最大の文字列は `9223372036854775807` です。例えば、DECIMAL(19,18) 列にロードできる最大値は `9.223372036854775807` です。
これらの規則は、有効桁数が 19 桁以下の DECIMAL 値は内部で 8 バイトの整数として格納され、有効桁数が 20～38 桁の DECIMAL 値は 16 バイトの整数として格納されるためです。
## 128 ビットの DECIMAL または NUMERIC の列の使用に関する注意事項
アプリケーションがそのような精度を必要とすることが明確でない限り、最大精度を DECIMAL 列に任意に割り当てないでください。128 ビット値は、64 ビット値の 2 倍のディスク容量を使用するので、クエリの実行時間が長くなる可能性があります。
## 浮動小数点型
*可変精度*の数値を格納するには、REAL および DOUBLE PRECISION のデータ型を使用します。これらのデータ型は*非正確*型です。すなわち、一部の値が近似値として格納されるため、特定の値を格納して返すと若干の相違が生じる場合があります。正確な格納および計算が必要な場合は (金額の場合など)、DECIMAL データ型を使用します。
REAL は、IEEE 標準 754 の 2 進浮動小数点演算に従って単精度浮動小数点形式を表します。精度は約 6 桁で、範囲は約 1E-37 から 1E\$137 です。このデータ型を FLOAT4 として指定することもできます。
DOUBLE PRECISION は、IEEE 標準 754 の 2 進浮動小数点演算に従って倍精度浮動小数点形式を表します。精度は約 15 桁で、範囲は約 1E-307 から 1E\$1308 です。このデータ型を FLOAT または FLOAT8 として指定することもできます。
通常の数値に加えて、浮動小数点型にはいくつかの特別な値があります。SQL でこれらの値を使用するときは、一重引用符で囲んでください。
+ `NaN` - Not a Number (非数)
+ `Infinity` — Infinity (無限大)
+ `-Infinity` — Negative Infinity (負の無限大)
例えば、`customer_activity` テーブルの `day_charge` 列に非数を挿入するには、次の SQL を実行します。
```
insert into customer_activity(day_charge) values('NaN');
```
# 数値に関する計算
ここで、*計算*とは加算、減算、乗算、および除算といった 2 進算術演算を示しています。このセクションでは、このような演算の予期される戻り型について、さらに DECIMAL データ型が必要な場合に精度とスケールを決定するのに適用される特定の計算式について説明します。
クエリ処理中に数値の計算が行われる場合には、計算が不可能であるためにクエリが数値オーバーフローエラーを返すといった状況が発生することがあります。さらに、算出される値のスケールが、変化したり予期せぬものであったりする状況が発生することもあります。一部の演算については、明示的なキャスト (型の上位変換) または Amazon Redshift 設定パラメータを使用してこれらの問題を解決できます。
SQL 関数を使用した同様の計算の結果の詳細については、「[集計関数](c_Aggregate_Functions.md)」を参照してください。
## 計算の戻り型
Amazon Redshift で一連の数値データ型がサポートされていると仮定して、次の表に加算、減算、乗算、および除算の予期される戻り型を示します。表の左側の最初の列は計算の 1 番目のオペランドを示し、一番上の行は 2 番目のオペランドを示します。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_numeric_computations201.html)
## DECIMAL の計算結果の精度とスケール
次の表に、算術演算で DECIMAL 型の結果が返されるときに算出結果の精度とスケールに適用されるルールの概要を示します。この表で、`p1` と `s1` は計算における 1 番目のオペランドの精度とスケールを示し、`p2` と `s2` は 2 番目のオペランドの精度とスケールを示します (これらの計算に関係なく、結果の最大精度は 38、結果の最大スケールは 38 です)。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_numeric_computations201.html)
例えば、SALES テーブルの PRICEPAID 列と COMMISSION 列は両方とも DECIMAL(8,2) 列です。PRICEPAID を COMMISSION で除算する場合 (または COMMISSION を PRICEPAID で除算する場合)、計算式は次のように適用されます。
```
Precision = 8-2 + 2 + max(4,2+8-2+1)
= 6 + 2 + 9 = 17
Scale = max(4,2+8-2+1) = 9
Result = DECIMAL(17,9)
```
次の計算は、UNION、INTERSECT、EXCEPT などの集合演算子および COALESCE や DECODE などの関数を使用して DECIMAL 値に対して演算を実行した場合に、結果として生じる精度とスケールを計算するための汎用的なルールです。
```
Scale = max(s1,s2)
Precision = min(max(p1-s1,p2-s2)+scale,19)
```
例えば、DECIMAL(7,2) 列が 1 つ含まれる DEC1 テーブルと、DECIMAL(15,3) 列が 1 つ含まれる DEC2 テーブルを結合して DEC3 テーブルを作成します。DEC3 のスキーマを確認すれば、列が NUMERIC(15,3) 列になることが分かります。
```
create table dec3 as select * from dec1 union select * from dec2;
```
結果
```
select "column", type, encoding, distkey, sortkey
from pg_table_def where tablename = 'dec3';
column | type | encoding | distkey | sortkey
-------+---------------+----------+---------+---------
c1 | numeric(15,3) | none | f | 0
```
上記の例では、計算式は次のように適用されます。
```
Precision = min(max(7-2,15-3) + max(2,3), 19)
= 12 + 3 = 15
Scale = max(2,3) = 3
Result = DECIMAL(15,3)
```
## 除算演算に関する注意事項
除算演算の場合、ゼロ除算を行うとエラーが返されます。
精度とスケールが計算されると、スケール制限 100 が適用されます。算出された結果スケールが 100 より大きい場合、除算結果は次のようにスケーリングされます。
+ 精度 = ` precision - (scale - max_scale)`
+ スケール = ` max_scale `
算出された精度が最大精度 (38) より高い場合、精度は 38 に引き下げられ、スケールは `max((38 + scale - precision), min(4, 100))` で計算された結果となります。
## オーバーフロー条件
すべての数値計算についてオーバーフローが調べられます。精度が 19 以下の DECIMAL データは 64 ビットの整数として格納されます。精度が 19 を上回る DECIMAL データは 128 ビットの整数として格納されます。すべての DECIMAL 値の最大精度は 38 であり、最大スケールは 37 です。値がこれらの制限を超えるとオーバーフローエラーが発生します。このルールは中間結果セットと最終結果セットの両方に適用されます。
+ 特定のデータ値がキャスト関数で指定された所定の精度またはスケールに適合していない場合、明示的なキャストでは実行時オーバーフローエラーが生じます。例えば、SALES テーブルの PRICEPAID 列 (DECIMAL(8,2) 列) からの値をすべてキャストできるとは限らないので、結果として DECIMAL(7,3) を返すことはできません。
```
select pricepaid::decimal(7,3) from sales;
ERROR: Numeric data overflow (result precision)
```
このエラーは、PRICEPAID 列に含まれる大きな値の*いくつか*をキャストできないために発生します。
+ 乗算演算によって得られる結果では、結果スケールが各オペランドのスケールを足し算した値となります。例えば、両方のオペランドとも 4 桁のスケールを持っている場合、結果としてスケールは 8 桁となり、小数点の左側には 10 桁のみが残ります。したがって、有効スケールを持つ 2 つの大きな数値を乗算する場合は、比較的簡単にオーバーフロー状態に陥ります。
次の例はオーバーフローエラーになります。
```
SELECT CAST(1 AS DECIMAL(38, 20)) * CAST(10 AS DECIMAL(38, 20));
ERROR: 128 bit numeric data overflow (multiplication)
```
乗算の代わりに除算を使用することでオーバーフローエラーを回避できます。次の例を使用して、1 を元の除数で割って除算します。
```
SELECT CAST(1 AS DECIMAL(38, 20)) / (1 / CAST(10 AS DECIMAL(38, 20)));
+----------+
| ?column? |
+----------+
| 10 |
+----------+
```
## INTEGER 型および DECIMAL 型での数値計算
計算式のオペランドの一方が INTEGER データ型を持っており、他方のオペランドが DECIMAL データ型を持っている場合、INTEGER オペランドは DECIMAL として暗黙的にキャストされます。
+ INT2 (SMALLINT) は、DECIMAL(5,0) としてキャストされます。
+ INT4 (INTEGER) は、DECIMAL(10,0) としてキャストされます。
+ INT8 (BIGINT) は、DECIMAL(19,0) としてキャストされます。
例えば、DECIMAL(8,2) 列の SALES.COMMISSION と、SMALLINT 列の SALES.QTYSOLD を乗算する場合、この計算は次のようにキャストされます。
```
DECIMAL(8,2) * DECIMAL(5,0)
```
# 整数リテラルと浮動小数点リテラル
数値を表現するリテラルまたは定数は、整数または浮動小数点数になり得ます。
## 整数リテラル
整数定数は一連の 0～9 の数字であり、この一連の数字の先頭にはオプションで正 (\$1) 符号または負 (-) 符号が付けられます。
## 構文
```
[ + | - ] digit ...
```
## 例
以下は有効な整数です。
```
23
-555
+17
```
## 浮動小数点リテラル
浮動小数点リテラル (10 進リテラル、数値リテラル、分数リテラルとも呼ばれる) は、小数点を含むことができるほか、必要に応じて指数マーカー (e) も含むことができる一連の数字です。
## 構文
```
[ + | - ] digit ... [ . ] [ digit ...]
[ e | E [ + | - ] digit ... ]
```
## 引数
e \$1 E
e または E は、数値が科学的表記で指定されていることを示します。
## 例
以下は有効な浮動小数点リテラルです。
```
3.14159
-37.
2.0e19
-2E-19
```
# 数値型を使用する例
## CREATE TABLE ステートメント
次の CREATE TABLE ステートメントでは、さまざまな数値データ型を実際に宣言しています。
```
create table film (
film_id integer,
language_id smallint,
original_language_id smallint,
rental_duration smallint default 3,
rental_rate numeric(4,2) default 4.99,
length smallint,
replacement_cost real default 25.00);
```
## 範囲外の整数を挿入する試み
次の例では、値 33000 を SMALLINT 列に挿入しようとしています。
```
insert into film(language_id) values(33000);
```
SMALLINT の範囲は、-32768～\$132767 であるため、Amazon Redshift はエラーを返します。
```
An error occurred when executing the SQL command:
insert into film(language_id) values(33000)
ERROR: smallint out of range [SQL State=22003]
```
## 整数列への 10 進値の挿入
次の例では、10 進値を INT 列に挿入します。
```
insert into film(language_id) values(1.5);
```
この値は挿入されますが、整数値 2 に切り上げられます。
## 10 進値のスケールが丸められるため挿入に成功する場合
次の例では、列よりも上位の精度を持つ 10 進値を挿入します。
```
insert into film(rental_rate) values(35.512);
```
この例では、値 `35.51` が列に挿入されます。
## 範囲外の 10 進値を挿入する試み
この場合、値 `350.10` は範囲外です。DECIMAL 列内の値の桁数は、列の精度からそのスケールを引いた結果となります (RENTAL\$1RATE 列の場合は 4 から 2 を引いた結果)。すなわち、`DECIMAL(4,2)` 列の許容範囲は、`-99.99`～`99.99` です。
```
insert into film(rental_rate) values (350.10);
ERROR: numeric field overflow
DETAIL: The absolute value is greater than or equal to 10^2 for field with precision 4, scale 2.
```
## REAL 列への可変精度値の挿入
次の例では可変精度値を REAL 列に挿入します。
```
insert into film(replacement_cost) values(1999999.99);
insert into film(replacement_cost) values(1999.99);
select replacement_cost from film;
+------------------+
| replacement_cost |
+------------------+
| 2000000 |
| 1999.99 |
+------------------+
```
値 `1999999.99` は、`REAL` 列の精度要件を満たすために `2000000` に変換されます。値 `1999.99` はそのままロードされます。
# 文字型
**Topics**
+ [ストレージと範囲](#r_Character_types-storage-and-ranges)
+ [CHAR または CHARACTER](#r_Character_types-char-or-character)
+ [VARCHAR または CHARACTER VARYING](#r_Character_types-varchar-or-character-varying)
+ [NCHAR 型および NVARCHAR 型](#r_Character_types-nchar-and-nvarchar-types)
+ [TEXT 型および BPCHAR 型](#r_Character_types-text-and-bpchar-types)
+ [末尾の空白の重要性](#r_Character_types-significance-of-trailing-blanks)
+ [文字型を使用する例](r_Examples_with_character_types.md)
文字データ型には、CHAR (文字) や VARCHAR (可変文字) などがあります。
## ストレージと範囲
CHAR および VARCHAR のデータ型は、文字単位でなくバイト単位で定義されます。CHAR 列にはシングルバイト文字のみを含めることができます。したがって、CHAR(10) 列には、最大 10 バイト長の文字列を含めることができます。VARCHAR にはマルチバイト文字 (1 文字あたり最大で 4 バイトまで) を含めることができます。例えば、VARCHAR(12) 列には、シングルバイト文字なら 12 個、2 バイト文字なら 6 個、3 バイト文字なら 4 個、4 バイト文字なら 3 個含めることができます。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_Character_types.html)
**注記**
CREATE TABLE 構文では、文字データ型の MAX キーワードをサポートします。例えば、次のようになります。
```
create table test(col1 varchar(max));
```
CHAR の場合、MAX は列幅を 4096 バイトとして定義します。
VARCHAR の場合、MAX は CREATE TABLE ステートメントの列幅を 65,535 バイトとして定義します。メモリ内のオペレーションの場合、VARCHAR (MAX) は最大 16,000,000 バイトをサポートします。
## CHAR または CHARACTER
固定長の文字列を格納するには、CHAR または CHARACTER を使用します。これらの文字列は空白で埋められるので、CHAR(10) 列は常に 10 バイトのストレージを占有します。
```
char(10)
```
長さの指定がない場合 CHAR 列は、CHAR(1) 列になります。
## VARCHAR または CHARACTER VARYING
一定の制限を持つ可変長の文字列を格納するには、VARCHAR 列または CHARACTER VARYING 列を使用します。これらの文字列は空白で埋められないので、VARCHAR(120) 列は、最大で 120 個のシングルバイト文字、60 個の 2 バイト文字、40 個の 3 バイト文字、または 30 個の 4 バイト文字で構成されます。
```
varchar(120)
```
CREATE TABLE ステートメントで長さの指定子なしで VARCHAR データ型を使用すると、デフォルト長は 256 になります。
[文字列関数](String_functions_header.md) は最大 16,000,000 バイトをサポートするようになりました。例えば、CONCAT 関数の出力は以前は 65,535 バイトに制限されていましたが、最大 16,000,000 バイトをサポートするようになりました。
```
SELECT LEN(CONCAT(REPEAT('A', 5000000), REPEAT('B', 5000000))) AS total_length;
total_length
--------------
10000000
```
## NCHAR 型および NVARCHAR 型
NCHAR 型および NVARCHAR 型 (NATIONAL CHARACTER 型および NATIONAL CHARACTER VARYING 型と呼ぶこともある) で、列を作成できます。これらの型はそれぞれ CHAR 型と VARCHAR 型に変換され、指定されたバイト数で格納されます。
長さを指定しない場合、NCHAR 列は CHAR(1) 列に変換されます。
長さを指定しない場合、NVARCHAR 列は VARCHAR(256) 列に変換されます。
## TEXT 型および BPCHAR 型
TEXT 列を使用して Amazon Redshift テーブルを作成できますが、この列は最大 256 文字の可変長値を受け入れる VARCHAR(256) 列に変換されます。
BPCHAR (空白で埋められる文字) 型を使用して Amazon Redshift 列を作成できますが、この列によって固定長の CHAR(256) 列に変換されます。
## 末尾の空白の重要性
CHAR と VARCHAR のデータ型は両方とも、最大 *n* バイト長の文字列を格納できます。それよりも長い文字列をこれらの型の列に格納しようとすると、エラーが発生します。ただし、余分な文字がすべてスペース (空白) ならば例外で、文字列は最大長に切り捨てられます。文字列の長さが最大長よりも短い場合、CHAR 値は空白で埋められますが、VARCHAR 値では空白なしで文字列を格納します。
CHAR 値の末尾の空白はいつも意味的に重要であるとは限りません。末尾の空白は、LENGTH 計算を含めないで 2 つの CHAR 値を比較するときは無視され、CHAR 値を別の文字列型に変換するときは削除されます。
VARCHAR および CHAR の値の末尾の空白は、値が比較されるとき、意味的に重要でないものとして扱われます。
長さの計算によって返される VARCHAR キャラクタ文字列の長さには末尾の空白が含められます。固定長のキャラクタ文字列の長さを計算する場合、末尾の空白はカウントされません。
# 文字型を使用する例
## CREATE TABLE ステートメント
次の CREATE TABLE ステートメントでは、VARCHAR および CHAR データタイプの使用を示しています。
```
create table address(
address_id integer,
address1 varchar(100),
address2 varchar(50),
district varchar(20),
city_name char(20),
state char(2),
postal_code char(5)
);
```
次の例ではこの表を使用しています。
## 可変キャラクタ文字列における末尾の空白
ADDRESS1 は VARCHAR 列であるため、2 番目の挿入アドレスの末尾の空白は意味的に重要ではありません。すなわち、これらの 2 つの挿入アドレスは*一致します*。
```
insert into address(address1) values('9516 Magnolia Boulevard');
insert into address(address1) values('9516 Magnolia Boulevard ');
```
```
select count(*) from address
where address1='9516 Magnolia Boulevard';
count
-------
2
(1 row)
```
もし ADDRESS1 列が CHAR 列であり、同じ値が挿入されたと仮定すると、COUNT(\$1) クエリはキャラクタ文字列を同じものとして認識し、`2` を返します。
## LENGTH 関数の結果
LENGTH 関数は、VARCHAR 列内の末尾の空白を認識します。
```
select length(address1) from address;
length
--------
23
25
(2 rows)
```
CHAR 列である CITY\$1NAME 列の `Augusta` の値は、入力文字列内の末尾の空白に関係なく常に 7 文字になります。
## 列の長さを超える値
文字列は、宣言した列幅に適合するように切り捨てられることはありません。
```
insert into address(city_name) values('City of South San Francisco');
ERROR: value too long for type character(20)
```
この問題の解決策は、値を列のサイズにキャストすることです。
```
insert into address(city_name)
values('City of South San Francisco'::char(20));
```
この場合は、文字列の最初の 20 文字 (`City of South San Fr`) が列にロードされます。
# 日時型
**Topics**
+ [ストレージと範囲](#r_Datetime_types-storage-and-ranges)
+ [DATE](#r_Datetime_types-date)
+ [TIME](#r_Datetime_types-time)
+ [TIMETZ](#r_Datetime_types-timetz)
+ [TIMESTAMP](#r_Datetime_types-timestamp)
+ [TIMESTAMPTZ](#r_Datetime_types-timestamptz)
+ [日時型を使用する例](r_Examples_with_datetime_types.md)
+ [日付、時刻、およびタイムスタンプのリテラル](r_Date_and_time_literals.md)
+ [間隔のデータ型とリテラル](r_interval_data_types.md)
日時データ型には DATE、TIME、TIMETZ、TIMESTAMP、TIMESTAMPTZ があります。
## ストレージと範囲
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_Datetime_types.html)
## DATE
タイムスタンプなしで単純にカレンダー日付だけを保存するには DATE データ型を使用します。
## TIME
TIME は、TIME WITHOUT TIME ZONE のエイリアスです。
時刻を保存するには、TIME データ型を使用します。
TIME 列に値を保存する場合、小数秒の精度については最大で 6 桁まで保存されます。
デフォルトでは、ユーザーテーブルと Amazon Redshift システムテーブルでは、TIME 値は協定世界時 (UTC) になります。
## TIMETZ
TIMETZ は、TIME WITH TIME ZONE のエイリアスです。
TIMETZ データ型を使用して、時刻とタイムゾーンを保存します。
TIMETZ 列に値を保存する場合、小数秒の精度については最大で 6 桁まで保存されます。
デフォルトでは、ユーザーテーブルと Amazon Redshift システムテーブルの両方で、TIMETZ 値は UTC です。
## TIMESTAMP
TIMESTAMP は、TIMESTAMP WITHOUT TIME ZONE のエイリアスです。
日付と時刻を含む完全なタイムスタンプ値を保存するには TIMESTAMP データ型を使用します。
TIMESTAMP 列に値を保存する場合、小数秒の精度については最大で 6 桁まで保存されます。
TIMESTAMP 列に日付または部分的なタイムスタンプ値を持つ日付を挿入すると、値は暗黙的に完全なタイムスタンプ値に変換されます。この完全なタイムスタンプ値には、時間、分、および秒が抜けている場合のデフォルト値 (00) があります。入力文字列のタイムゾーン値は無視されます。
デフォルトでは、ユーザーテーブルと Amazon Redshift システムテーブルの両方で、TIMESTAMP 値は UTC です。
## TIMESTAMPTZ
TIMESTAMPTZ は、TIMESTAMP WITH TIME ZONE のエイリアスです。
日付、時刻、タイムゾーンを含む完全なタイムスタンプ値を入力するには TIMESTAMPTZ データ型を使用します。入力値にタイムゾーンが含まれる場合、Amazon Redshift はタイムゾーンを使用して値を UTC に変換し、UTC 値を保存します。
サポートされるタイムゾーン名のリストを表示するには、次のコマンドを実行します。
```
select pg_timezone_names();
```
サポートされるタイムゾーン省略形のリストを表示するには、次のコマンドを実行します。
```
select pg_timezone_abbrevs();
```
タイムゾーンの最新情報については、「[IANA Time Zone Database](https://www.iana.org/time-zones)」も参照してください。
次の表に、タイムゾーン形式の例を示します。
| 形式 | 例 |
| --- | --- |
| dd mon hh:mi:ss yyyy tz | 17 Dec 07:37:16 1997 PST |
| mm/dd/yyyy hh:mi:ss.ss tz | 12/17/1997 07:37:16.00 PST |
| mm/dd/yyyy hh:mi:ss.ss tz | 12/17/1997 07:37:16.00 US/Pacific |
| yyyy-mm-dd hh:mi:ss\$1/-tz | 1997-12-17 07:37:16-08 |
| dd.mm.yyyy hh:mi:ss tz | 17.12.1997 07:37:16.00 PST |
TIMESTAMPTZ 列に値を保存する場合、小数秒の精度については最大で 6 桁まで保存されます。
TIMESTAMPTZ 列に日付または部分的なタイムスタンプを持つ日付を挿入すると、値は暗黙的に完全なタイムスタンプ値に変換されます。この完全なタイムスタンプ値には、時間、分、および秒が抜けている場合のデフォルト値 (00) があります。
TIMESTAMPTZ 値は、ユーザーテーブルでは UTC です。
# 日時型を使用する例
以下に、Amazon Redshift でサポートされている日時タイプを操作する例を示します。
## 日付の例
次の例では、形式が異なる複数の日付を挿入して、出力を表示します。
```
create table datetable (start_date date, end_date date);
```
```
insert into datetable values ('2008-06-01','2008-12-31');
insert into datetable values ('Jun 1,2008','20081231');
```
```
select * from datetable order by 1;
start_date | end_date
-----------------------
2008-06-01 | 2008-12-31
2008-06-01 | 2008-12-31
```
DATE 列にタイムスタンプ値を挿入した場合、時刻部分が無視され、日付のみロードされます。
## 時間の例
次の例では、形式の異なる複数の TIME および TIMETZ 値を挿入して、出力を表示します。
```
create table timetable (start_time time, end_time timetz);
```
```
insert into timetable values ('19:11:19','20:41:19 UTC');
insert into timetable values ('191119', '204119 UTC');
```
```
select * from timetable order by 1;
start_time | end_time
------------------------
19:11:19 | 20:41:19+00
19:11:19 | 20:41:19+00
```
## タイムスタンプの例
日付を TIMESTAMP 列または TIMESTAMPTZ 列に挿入すると、時刻はデフォルトでは午前 0 時になります。例えば、リテラル `20081231` を挿入すると、格納される値は `2008-12-31 00:00:00` です。
現在のセッションのタイムゾーンを変更するには、[SET](r_SET.md) コマンドを使用して [timezone](r_timezone_config.md) 設定パラメータを設定します。
次の例では、形式の異なる複数のタイムスタンプを挿入して、結果のテーブルを表示します。
```
create table tstamp(timeofday timestamp, timeofdaytz timestamptz);
insert into tstamp values('Jun 1,2008 09:59:59', 'Jun 1,2008 09:59:59 EST' );
insert into tstamp values('Dec 31,2008 18:20','Dec 31,2008 18:20');
insert into tstamp values('Jun 1,2008 09:59:59 EST', 'Jun 1,2008 09:59:59');
SELECT * FROM tstamp;
+---------------------+------------------------+
| timeofday | timeofdaytz |
+---------------------+------------------------+
| 2008-06-01 09:59:59 | 2008-06-01 14:59:59+00 |
| 2008-12-31 18:20:00 | 2008-12-31 18:20:00+00 |
| 2008-06-01 09:59:59 | 2008-06-01 09:59:59+00 |
+---------------------+------------------------+
```
# 日付、時刻、およびタイムスタンプのリテラル
Amazon Redshift によってサポートされている日付、時刻、およびタイムスタンプリテラルを使用する際に従うべきルールは次のとおりです。
## 日付
次に示す入力日付はすべて、Amazon Redshift テーブルにロードできる DATE データ型の有効な日付リテラル値の例です。デフォルトの `MDY DateStyle` モードが有効であると想定されます。このモードでは、`1999-01-08` や `01/02/00` などの文字列で月の値が日の値より前にあることを意味します。
**注記**
日付またはタイムスタンプのリテラルをテーブルにロードするには、それらのリテラルを引用符で囲む必要があります。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_Date_and_time_literals.html)
## Times
次に示す入力時間はすべて、Amazon Redshift テーブルにロードできる TIME データ型および TIMETZ データ型の有効な時刻リテラル値の例です。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_Date_and_time_literals.html)
## タイムスタンプ
次に示す入力タイムスタンプはすべて、Amazon Redshift テーブルにロードできる TIMESTAMP データ型および TIMESTAMPTZ データ型の有効な時刻リテラル値の例です。有効な日付リテラルはすべて、以下の時刻リテラルと結合することができます。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_Date_and_time_literals.html)
## 特殊な日時値
次に示す特殊な値は、日時リテラルとして、および日付関数に渡す引数として使用できます。このような特殊な値は、一重引用符を必要とし、クエリの処理時に正規のタイムスタンプ値に変換されます。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_Date_and_time_literals.html)
次の例では、`now` および `today` が DATEADD 関数でどのように動作するかを示しています。
```
select dateadd(day,1,'today');
date_add
---------------------
2009-11-17 00:00:00
(1 row)
select dateadd(day,1,'now');
date_add
----------------------------
2009-11-17 10:45:32.021394
(1 row)
```
# 間隔のデータ型とリテラル
間隔のデータ型を使用して、`seconds`、`minutes`、`hours`、`days`、`months`、`years` などの単位で期間を保存できます。間隔のデータ型とリテラルは、日付とタイムスタンプへの間隔の追加、間隔の合計、日付またはタイムスタンプからの間隔の減算など、日時の計算に使用できます。間隔リテラルは、テーブル内の間隔データ型列への入力値として使用できます。
## 間隔データ型の構文
期間を年数と月数で保存する間隔データ型を指定するには:
```
INTERVAL year_to_month_qualifier
```
期間を日数、時間数、分数、および秒数で保存する間隔データ型を指定するには:
```
INTERVAL day_to_second_qualifier [ (fractional_precision) ]
```
## 間隔リテラルの構文
間隔リテラルを指定して、期間を年数と月数で定義するには:
```
INTERVAL quoted-string year_to_month_qualifier
```
間隔リテラルを指定して、期間を日数、時間数、分数、および秒数で定義するには:
```
INTERVAL quoted-string day_to_second_qualifier [ (fractional_precision) ]
```
## 引数
*quoted-string*
数量と日時単位を入力文字列として指定する正または負の数値を指定します。quoted-string に数値のみが含まれている場合、Amazon Redshift は year\$1to\$1month\$1qualifier または day\$1to\$1second\$1qualifier から単位を決定します。******例えば、`'23' MONTH` は `1 year 11 months`、`'-2' DAY` は `-2 days 0 hours 0 minutes 0.0 seconds`、`'1-2' MONTH` は `1 year 2 months`、`'13 day 1 hour 1 minute 1.123 seconds' SECOND` は `13 days 1 hour 1 minute 1.123 seconds` を表します。間隔の出力形式の詳細については、「[間隔スタイル](#r_interval_data_types-interval-styles)」を参照してください。
*year\$1to\$1month\$1qualifier*
間隔の範囲を指定します。修飾子を使用して、修飾子よりも小さい時間単位で間隔を作成すると、Amazon Redshift ではそれより小さい間隔の単位を切り捨てて破棄します。year\$1to\$1month\$1qualifier の有効な値は次のとおりです。**
+ `YEAR`
+ `MONTH`
+ `YEAR TO MONTH`
*day\$1to\$1second\$1qualifier*
間隔の範囲を指定します。修飾子を使用して、修飾子よりも小さい時間単位で間隔を作成すると、Amazon Redshift ではそれより小さい間隔の単位を切り捨てて破棄します。day\$1to\$1second\$1qualifier の有効な値は次のとおりです。**
+ `DAY`
+ `HOUR`
+ `MINUTE`
+ `SECOND`
+ `DAY TO HOUR`
+ `DAY TO MINUTE`
+ `DAY TO SECOND`
+ `HOUR TO MINUTE`
+ `HOUR TO SECOND`
+ `MINUTE TO SECOND`
INTERVAL リテラルの出力は、指定された最小の INTERVAL コンポーネントで切り捨てられます。例えば、MINUTE 修飾子を使用すると、Amazon Redshift は MINUTE より小さい時間単位を破棄します。
```
select INTERVAL '1 day 1 hour 1 minute 1.123 seconds' MINUTE
```
結果の値は `'1 day 01:01:00'` で切り捨てられます。
*Fractional\$1precision*
間隔で使用できる小数点以下の桁数を指定するオプションのパラメータ。fractional\$1precision 引数は、間隔に SECOND が含まれている場合にのみ指定する必要があります。**例えば、`SECOND(3)` は、1.234 秒など、小数点以下 3 桁のみを許可する間隔を作成します。小数点以下の最大桁数は 6 です。
セッション設定 `interval_forbid_composite_literals` は、YEAR TO MONTH と DAY TO SECOND の両方のパートを使用して間隔を指定している場合に、エラーを返すかどうかを決定します。詳細については、「[interval\$1forbid\$1composite\$1literals](r_interval_forbid_composite_literals.md)」を参照してください。
## 区間演算
間隔の値を他の日時値と一緒に使用して算術演算を実行できます。次の表は、使用可能な演算と、各演算の結果であるデータ型を示しています。
**注記**
`date` と `timestamp` の両方の結果を生成できる演算は、式に関連する最小時間単位に基づいて行われます。例えば、`interval` を `date` に追加すると、YEAR TO MONTH 間隔の場合、結果は `date` になり、DAY TO SECOND 間隔の場合、結果はタイムスタンプになります。
最初のオペランドが `interval` の演算は、指定された 2 番目のオペランドに対して次の結果を生成します。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_interval_data_types.html)
最初のオペランドが `date` の演算は、指定された 2 番目のオペランドに対して次の結果を生成します。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_interval_data_types.html)
最初のオペランドが `timestamp` の演算は、指定された 2 番目のオペランドに対して次の結果を生成します。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_interval_data_types.html)
## 間隔スタイル
SQL [SET](r_SET.md) コマンドを使用すると、間隔値の出力表示形式を変更できます。SQL で間隔データ型を使用する場合は、テキストにキャストして、予想される間隔スタイル (`YEAR TO MONTH::text` など) を確認します。`IntervalStyle` 値を設定するために使用できる値は、次のとおりです。
+ `postgres` — PostgreSQL スタイルに従います。これがデフォルトです。
+ `postgres_verbose` — PostgreSQL の詳細スタイルに従います。
+ `sql_standard` — SQL 標準間隔リテラルスタイルに従います。
次のコマンドは、間隔スタイルを `sql_standard` に設定します。
```
SET IntervalStyle to 'sql_standard';
```
**postgres 出力形式**
`postgres` 間隔スタイルの出力形式は、次のとおりです。各数値は負の値にすることができます。
```
' [, ...]'
```
```
select INTERVAL '1-2' YEAR TO MONTH::text
varchar
---------------
1 year 2 mons
```
```
select INTERVAL '1 2:3:4.5678' DAY TO SECOND::text
varchar
------------------
1 day 02:03:04.5678
```
**postgres\$1verbose 出力形式**
postgres\$1verbose 構文は postgres と似ていますが、postgres\$1verbose 出力には時間の単位も含まれています。
```
'[@] [, ...] [direction]'
```
```
select INTERVAL '1-2' YEAR TO MONTH::text
varchar
-----------------
@ 1 year 2 mons
```
```
select INTERVAL '1 2:3:4.5678' DAY TO SECOND::text
varchar
---------------------------
@ 1 day 2 hours 3 mins 4.56 secs
```
**sql\$1standard 出力形式**
間隔値 year to month は次のようにフォーマットされます。間隔の前にマイナス記号を指定すると、間隔が負の値になり、間隔全体に適用されます。
```
'[-]yy-mm'
```
間隔値 day to second は次のようにフォーマットされます。
```
'[-]dd hh:mm:ss.ffffff'
```
```
SELECT INTERVAL '1-2' YEAR TO MONTH::text
varchar
-------
1-2
```
```
select INTERVAL '1 2:3:4.5678' DAY TO SECOND::text
varchar
---------------
1 2:03:04.5678
```
## 間隔データ型の例
以下の例は、テーブルでの INTERVAL データ型の使用方法を示しています。
```
create table sample_intervals (y2m interval month, h2m interval hour to minute);
insert into sample_intervals values (interval '20' month, interval '2 days 1:1:1.123456' day to second);
select y2m::text, h2m::text from sample_intervals;
y2m | h2m
---------------+-----------------
1 year 8 mons | 2 days 01:01:00
```
```
update sample_intervals set y2m = interval '2' year where y2m = interval '1-8' year to month;
select * from sample_intervals;
y2m | h2m
---------+-----------------
2 years | 2 days 01:01:00
```
```
delete from sample_intervals where h2m = interval '2 1:1:0' day to second;
select * from sample_intervals;
y2m | h2m
-----+-----
```
## 間隔リテラルの例
以下の例は、間隔スタイルを `postgres` に設定して実行します。
次の例は、1 年の INTERVAL リテラルを作成する方法を示しています。
```
select INTERVAL '1' YEAR
intervaly2m
---------------
1 years 0 mons
```
修飾子を超える quoted-string を指定すると、残りの時間単位が間隔から切り捨てられます。**次の例では、13 か月の間隔は 1 年と 1 か月になりますが、YEAR 修飾子により残りの 1 か月が除外されます。
```
select INTERVAL '13 months' YEAR
intervaly2m
---------------
1 years 0 mons
```
間隔文字列を下回る修飾子を使用すると、残った単位が含まれます。
```
select INTERVAL '13 months' MONTH
intervaly2m
---------------
1 years 1 mons
```
間隔で精度を指定すると、小数桁数が指定された精度まで切り捨てられます。
```
select INTERVAL '1.234567' SECOND (3)
intervald2s
--------------------------------
0 days 0 hours 0 mins 1.235 secs
```
精度を指定しない場合は、Amazon Redshift では最大精度 6 が使用されます。
```
select INTERVAL '1.23456789' SECOND
intervald2s
-----------------------------------
0 days 0 hours 0 mins 1.234567 secs
```
次の例では、範囲指定した間隔を作成する方法を示します。
```
select INTERVAL '2:2' MINUTE TO SECOND
intervald2s
------------------------------
0 days 0 hours 2 mins 2.0 secs
```
修飾子は、指定する単位を指定します。例えば、次の例では前の例と同じ quoted-string (2:2) を使用していますが、Amazon Redshift では、修飾子に基づいて異なる時間単位を使用していると認識します。**
```
select INTERVAL '2:2' HOUR TO MINUTE
intervald2s
------------------------------
0 days 2 hours 2 mins 0.0 secs
```
各単位の略語と複数形もサポートされています。例えば、`5s`、`5 second`、`5 seconds` は同じ間隔です。サポートされている単位は、年、月、日、時間、分、秒です。
```
select INTERVAL '5s' SECOND
intervald2s
------------------------------
0 days 0 hours 0 mins 5.0 secs
```
```
select INTERVAL '5 HOURS' HOUR
intervald2s
------------------------------
0 days 5 hours 0 mins 0.0 secs
```
```
select INTERVAL '5 h' HOUR
intervald2s
------------------------------
0 days 5 hours 0 mins 0.0 secs
```
# 修飾子構文を使用しない間隔リテラルの例
**注記**
以下の例は、`YEAR TO MONTH` または `DAY TO SECOND` 修飾子を使用しない間隔リテラルを示しています。修飾子を使用した間隔リテラルの推奨例については、「[間隔のデータ型とリテラル](r_interval_data_types.md)」を参照してください。
`12 hours` または `6 months` など、特定の期間を識別するには、間隔リテラルを使用します。これらの間隔リテラルは、日時式を必要とする条件および計算の中で使用できます。
間隔リテラルは、INTERVAL キーワードに数量およびサポートされている日付パートを組み合わせて表現します。例えば、`INTERVAL '7 days'` または `INTERVAL '59 minutes'` のようになります。複数の数量および単位をつなぎ合わせることで、より正確な間隔を作成できます (例えば、`INTERVAL '7 days, 3 hours, 59 minutes'`)。各単位の省略形および複数形もサポートされています。例えば、`5 s`、`5 second`、および `5 seconds` は等価な間隔です。
日付部分を指定しない場合、間隔値は秒数を示します。数量値は小数として指定できます (例えば、`0.5 days`)。
次の例に、さまざまな間隔値を使用した一連の計算を示します。
以下は、指定された日付に 1 秒を追加します。
```
select caldate + interval '1 second' as dateplus from date
where caldate='12-31-2008';
dateplus
---------------------
2008-12-31 00:00:01
(1 row)
```
以下は、指定された日付に 1 分を追加します。
```
select caldate + interval '1 minute' as dateplus from date
where caldate='12-31-2008';
dateplus
---------------------
2008-12-31 00:01:00
(1 row)
```
以下では、指定された日付に 3 時間と 35 分を追加します。
```
select caldate + interval '3 hours, 35 minutes' as dateplus from date
where caldate='12-31-2008';
dateplus
---------------------
2008-12-31 03:35:00
(1 row)
```
以下は、指定された日付に 52 週を追加します。
```
select caldate + interval '52 weeks' as dateplus from date
where caldate='12-31-2008';
dateplus
---------------------
2009-12-30 00:00:00
(1 row)
```
以下では、指定された日付に 1 週、1 時間、1 分、および 1 秒を追加します。
```
select caldate + interval '1w, 1h, 1m, 1s' as dateplus from date
where caldate='12-31-2008';
dateplus
---------------------
2009-01-07 01:01:01
(1 row)
```
以下は、指定された日付に 12 時間 (半日) を追加します。
```
select caldate + interval '0.5 days' as dateplus from date
where caldate='12-31-2008';
dateplus
---------------------
2008-12-31 12:00:00
(1 row)
```
以下では、2023 年 2 月 15 日から 4 か月を引いて、結果が 2022 年 10 月 15 日になります。
```
select date '2023-02-15' - interval '4 months';
?column?
---------------------
2022-10-15 00:00:00
```
以下では、2023 年 3 月 31 日から 4 か月を引いて、結果が 2022 年 11 月 30 日になります。計算では、1 か月の日数を考慮します。
```
select date '2023-03-31' - interval '4 months';
?column?
---------------------
2022-11-30 00:00:00
```
# ブール型
シングルバイト列に true 値および false 値を格納するには、BOOLEAN データ型を使用します。次の表に、ブール値の取り得る 3 つの状態と、各状態をもたらすリテラル値について説明します。入力文字列に関係なく、ブール列では、true の場合は「t」を、false の場合は「f」を格納および出力します。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_Boolean_type.html)
IS 比較を使用すると、ブール値を WHERE 句の述語としてのみチェックできます。SELECT リストのブール値に対して IS 比較を使用することはできません。
## 例
BOOLEAN 列を使用すれば、CUSTOMER テーブル内の顧客ごとに「アクティブ/非アクティブ」状態を格納できます。
```
create table customer(
custid int,
active_flag boolean default true);
```
```
insert into customer values(100, default);
```
```
select * from customer;
custid | active_flag
-------+--------------
100 | t
```
CREATE TABLE ステートメントにデフォルト値 (`true` または `false`) が指定されていない場合は、デフォルト値を挿入しても Null が挿入されます。
この例では、クエリによって、スポーツは好きだが映画館は好きでないユーザーが USERS テーブルから選択されます。
```
select firstname, lastname, likesports, liketheatre
from users
where likesports is true and liketheatre is false
order by userid limit 10;
firstname | lastname | likesports | liketheatre
----------+------------+------------+-------------
Lars | Ratliff | t | f
Mufutau | Watkins | t | f
Scarlett | Mayer | t | f
Shafira | Glenn | t | f
Winifred | Cherry | t | f
Chase | Lamb | t | f
Liberty | Ellison | t | f
Aladdin | Haney | t | f
Tashya | Michael | t | f
Lucian | Montgomery | t | f
(10 rows)
```
次の例では、ロックミュージックを好むかどうか不明なユーザーが USERS テーブルから選択されます。
```
select firstname, lastname, likerock
from users
where likerock is unknown
order by userid limit 10;
firstname | lastname | likerock
----------+----------+----------
Rafael | Taylor |
Vladimir | Humphrey |
Barry | Roy |
Tamekah | Juarez |
Mufutau | Watkins |
Naida | Calderon |
Anika | Huff |
Bruce | Beck |
Mallory | Farrell |
Scarlett | Mayer |
(10 rows)
```
次の例では、SELECT リストで IS 比較を使用しているため、エラーが返されます。
```
select firstname, lastname, likerock is true as "check"
from users
order by userid limit 10;
[Amazon](500310) Invalid operation: Not implemented
```
次の例は、IS 比較ではなく SELECT リストで等号比較 ( = ) を使用しているため成功します。
```
select firstname, lastname, likerock = true as "check"
from users
order by userid limit 10;
firstname | lastname | check
----------+-----------+------
Rafael | Taylor |
Vladimir | Humphrey |
Lars | Ratliff | true
Barry | Roy |
Reagan | Hodge | true
Victor | Hernandez | true
Tamekah | Juarez |
Colton | Roy | false
Mufutau | Watkins |
Naida | Calderon |
```
# HLLSKETCH タイプ
HyperLogLog スケッチには HLLSKETCH データ型を使用します。Amazon Redshift は、スパースまたはデンスの HyperLogLog スケッチ表現をサポートしています。スケッチはスパースとして開始され、使用するメモリフットプリントを最小化するために、デンス形式がより効率的になるとデンスに切り替わります。
Amazon Redshift は、次の JSON 形式でスケッチをインポート、エクスポート、または印刷するときに、スパースの HyperLogLog スケッチを自動的に移行します。
```
{"logm":15,"sparse":{"indices":[4878,9559,14523],"values":[1,2,1]}}
```
Amazon Redshift は、Base64 形式の文字列表現を使用して、デンスの HyperLogLog スケッチを表します。
Amazon Redshift は、デンスの HyperLogLog スケッチを表現するために、Base64 形式の次の文字列表現を使用します。
```
"ABAABA..."
```
raw 圧縮で使用する場合、HLLSKETCH オブジェクトの最大サイズは 24,580 バイトです。
# SUPER タイプ
SUPER データ型を使用して、半構造化データまたはドキュメントを値として保存します。Amazon Redshift は VARCHAR を使用してこのような値を保存できますが、代わりに SUPER データ型を使用することをお勧めします。
半構造化データは、SQL データベースで使用されるリレーショナルデータモデルの厳密な表形式の構造に準拠していません。これには、データ内の個別のエンティティを参照するタグが含まれます。配列やネストされた構造体、JSON などのシリアル化形式に関連付けられているその他の複雑な構造体などの複雑な値を含めることができます。SUPER データ型は、Amazon Redshift の他のスカラー型をすべて含む一連のスキーマレス配列と構造体の値です。
SUPER データ型は、SUPER オブジェクトごとに最大 16 MB のデータをサポートします。SUPER データ型の詳細 (テーブルへの実装例を含む) については、「[Amazon Redshift の半構造化データ](super-overview.md)」を参照してください。
Amazon Redshift は、COPY コマンドを使用して次の半構造化データ形式を取り込むための組み込みサポートを提供します。
+ JSON
+ 配列
+ TEXT
+ CSV
1 MB を超える SUPER オブジェクトは、以下のファイル形式からのみ取り込むことができます。
+ Parquet
+ JSON
+ TEXT
+ CSV
SUPER データ型には、以下のプロパティがあります。
+ Amazon Redshift のスカラー値:
+ null
+ ブール型
+ smallint、integer、bigint、decimal、または浮動小数点 (float4 や float8) などの数値
+ varchar や char などの文字列値
+ 複雑な値:
+ スカラーまたは複素数を含む値の配列
+ タプルまたはオブジェクトとも呼ばれる構造体。属性名と値 (スカラーまたは複合体) のマップです。
2 種類の複素数値のいずれにも、規則性の制限なしに、独自のスカラーまたは複素数値が含まれています。
SUPER データ型のデフォルトの圧縮エンコードは ZSTD です。圧縮エンコードに関する詳細は、「[圧縮エンコード](c_Compression_encodings.md)」を参照してください。
SUPER データ型は、スキーマレス形式の半構造化データの永続性をサポートします。階層データモデルは変更できますが、データの古いバージョンは同じ SUPER 列に共存することができます。
Amazon Redshift は PartiQL を使用して配列と構造体へのナビゲーションを有効にします。また、Amazon Redshift は PartiQL 構文を使用しながら SUPER 配列を反復処理します。詳細については、「[PartiQL – Amazon Redshift用の SQL 互換クエリ言語](super-partiql.md)」を参照してください。
Amazon Redshift では、動的型付けを使用して、クエリで使用する前にデータ型を宣言することなく、スキーマレスの SUPER データを処理します。詳細については、「[動的型付け](query-super.md#dynamic-typing-lax-processing)」を参照してください。
SUPER 型の列のパス上のスカラー値に動的データマスキングポリシーを適用できます。動的データマスキングの詳細については、「[動的データマスキング](t_ddm.md)」を参照してください。動的データマスキングを SUPER データ型と使用する方法の詳細については、「[SUPER データタイプパスでの動的データマスキングの使用](t_ddm-super.md)」を参照してください。
SUPER データを使用する場合は、`r_enable_case_sensitive_super_attribute` 設定オプションを true に設定することをお勧めします。詳細については、「[enable\$1case\$1sensitive\$1super\$1attribute](r_enable_case_sensitive_super_attribute.md)」を参照してください。
# VARBYTE 型
一定の制限を持つ可変長のバイナリ値を格納するには、VARBYTE 列、VARBINARY 列または BINARY VARYING 列を使用します。
```
varbyte [ (n) ]
```
最大バイト数 (*n*) の範囲は 1～16,777,216 です。デフォルト値は 64,000 です。
以下に、VARBYTE データ型を使用する場合の例をいくつか示します。
+ VARBYTE 列でのテーブルの結合。
+ VARBYTE 列を含むマテリアライズドビューの作成。VARBYTE 列を含むマテリアライズド・ビューでは、増分更新がサポートされます。ただし、VARBYTE 列の COUNT、MIN、MAX および GROUP BY 以外の集計関数は、増分更新をサポートしません。
すべてのバイトが表示可能な文字であることを保証するために、Amazon Redshift は 16 進数形式を使用して VARBYTE 値を出力します。例えば、次の SQL では 16 進数の文字列 `6162` をバイナリ値に変換しています。戻り値がバイナリ値であっても、結果は 16 進数の `6162` で出力されます。
```
select from_hex('6162');
from_hex
----------
6162
```
Amazon Redshift では、VARBYTE と以下に示すデータ型間でのキャストがサポートされています。
+ CHAR
+ VARCHAR
+ SMALLINT
+ INTEGER
+ BIGINT
CHAR と VARCHAR をキャストする場合は、UTF-8 形式が使用されます。UTF-8 形式の詳細については、「[TO\$1VARBYTE](r_TO_VARBYTE.md)」を参照してください。SMALLINT、INTEGER、BIGINT からキャストする場合、元のデータ型のバイト数は維持されます。つまり、SMALLINT の場合は 2 バイト、INTEGER の場合は 4 バイト、BIGINT の場合は 8 バイトとなります。
次の SQL ステートメントは、VARCHAR 文字列を VARBYTE にキャストします。戻り値がバイナリ値であっても、結果は 16 進数の `616263` で出力されます。
```
select 'abc'::varbyte;
varbyte
---------
616263
```
次の SQL ステートメントは、列内の CHAR 値を VARBYTE にキャストします。次の使用例では、CHAR (10) 列 (c) を持つテーブルを作成し、長さが 10 より短い文字値を挿入します。出力されるキャストでは、スペース文字 (hex'20') を使用して、定義された列サイズに結果がパディングされます。戻り値がバイナリ値の場合でも、結果は 16 進数で表示されます。
```
create table t (c char(10));
insert into t values ('aa'), ('abc');
select c::varbyte from t;
c
----------------------
61612020202020202020
61626320202020202020
```
次の SQL ステートメントは、SMALLINT 文字列を VARBYTE にキャストします。戻り値がバイナリ値の場合でも、この結果は 16 進数 `0005` (2 バイトつまり 4 桁の 16 進数文字列) として表示されます。
```
select 5::smallint::varbyte;
varbyte
---------
0005
```
次の SQL ステートメントは、INTEGER を VARBYTE にキャストします。戻り値がバイナリ値の場合でも、この結果は 16 進数 `00000005` (4 バイトつまり 8 桁の16進数文字列) として出力されます。
```
select 5::int::varbyte;
varbyte
----------
00000005
```
次の SQL ステートメントは、BIGINT を VARBYTE にキャストします。戻り値がバイナリ値の場合でも、この結果は 16 進数 `0000000000000005` (8 バイトつまり 16 桁の 16 進数文字列) として出力されます。
```
select 5::bigint::varbyte;
varbyte
------------------
0000000000000005
```
VARBYTE データ型をサポートする Amazon Redshift の各機能は以下のとおりです。
+ [VARBYTE 演算子](r_VARBYTE_OPERATORS.md)
+ [CONCAT](r_CONCAT.md)
+ [LEN](r_LEN.md)
+ [LENGTH 関数](r_LENGTH.md)
+ [OCTET\$1LENGTH](r_OCTET_LENGTH.md)
+ [SUBSTRING 関数](r_SUBSTRING.md)
+ [FROM\$1HEX](r_FROM_HEX.md)
+ [TO\$1HEX](r_TO_HEX.md)
+ [FROM\$1VARBYTE](r_FROM_VARBYTE.md)
+ [TO\$1VARBYTE](r_TO_VARBYTE.md)
+ [GETBIT](r_GETBIT.md)
+ [VARBYTE データ型の列のロード](copy-usage-varbyte.md)
+ [VARBYTE データ型の列のアップロード](r_UNLOAD.md#unload-usage-notes)
## Amazon Redshift で VARBYTE データ型を使用する際の制約事項
Amazon Redshift で VARBYTE データを使用する際の制約事項を以下に示します。
+ Amazon Redshift Spectrum は、Parquet ファイルと ORC ファイルに対してのみ VARBYTE データ型をサポートします。
+ Amazon Redshift のクエリエディタと Amazon Redshift クエリエディタ v2 は、現段階で VARBYTE データ型を完全にはサポートしていません。したがって、VARBYTE 表現を処理する際には、他の SQL クライアントを使用してください。
クエリエディタを使用する際の回避策として、データの長さが 16,000,000 バイト 以下で、かつコンテンツが有効な UTF-8 で構成されている場合は、VARBYTE 値を VARCHAR にキャストできます。次にこの例を示します。
```
select to_varbyte('6162', 'hex')::varchar;
```
+ Python または Lambda ユーザー定義関数 (UDF) では VARBYTE データ型を使用することはできません。
+ VARBYTE 列から HLLSKETCH 列を作成したり、VARBYTE 列で APPROXIMATE COUNT DISTINCT を使用したりすることはできません。
+ 1 MB を超える VARBYTE 値は、以下のファイル形式からのみ取り込むことができます。
+ Parquet
+ テキスト
+ カンマ区切り値 (CSV)
## 型の互換性と変換
Amazon Redshift における型変換ルールおよびデータ型の互換性についての説明を以下に示します。
### 互換性
データ型のマッチング、リテラル値および定数のデータ型とのマッチングは、以下のようなさまざまなデータベース操作で発生します。
+ テーブルにおけるデータ操作言語 (DML) オペレーション
+ UNION、INTERSECT、および EXCEPT のクエリ
+ CASE 式
+ LIKE や IN など、述語の評価
+ データの比較または抽出を行う SQL 関数の評価
+ 算術演算子との比較
これらの操作の結果は、型変換ルールおよびデータ型の互換性に左右されます。*互換性*は、特定の値と特定のデータ型との 1 対 1 のマッチングが必ずしも必要でないことを暗示しています。一部のデータ型は*互換性*があるため、暗黙変換、または*強制*が可能です (詳細については、「[暗黙的な変換型](#implicit-conversion-types)」を参照)。データ型に互換性がない場合は、明示変換関数を使用することにより、値をあるデータ型から別のデータ型に変換することが可能な場合があります。
### 互換性と変換に関する全般的なルール
次に示す互換性と変換に関するルールに注意してください。
+ 一般に、同じデータ型のカテゴリに属するデータ型 (各種の数値データ型) は互換性があり、暗黙的に変換することができます。
例えば、暗黙的な変換では、10 進値を整数列に変換できます。10 進値は整数に四捨五入されます。または、`2008` のような数値を日付から抽出し、その値を整数列に挿入することができます。
+ 数値データ型では、範囲外の値を挿入しようとしたときに発生するオーバーフロー条件を適用します。例えば、精度が 5 桁の 10 進値は、4 桁の精度で定義された 10 進列に適合しません。整数または 10 進値の整数部は決して切り捨てられません。しかし、10 進値の小数部は、適宜、切り上げまたは切り捨てることができます。ただし、テーブルから選択された値の明示的なキャストの結果は丸められません。
+ 各種のキャラクタ文字列型には互換性があります。シングルバイトデータを含む VARCHAR 列の文字列と CHAR 列の文字列は互換性があり、暗黙的に変換することができます。マルチバイトデータを含む VARCHAR 文字列には互換性がありません。また、キャラクタ文字列については、文字列が適切なリテラル値であれば、日付、時間、タイムスタンプ、または数値に変換することができます。先頭のスペースまたは末尾のスペースはいずれも無視されます。逆に、日付、時間、タイムスタンプ、または数値は、固定長または可変長の文字列に変換することができます。
**注記**
数値型にキャストするキャラクタ文字列には、数字の文字表現が含まれている必要があります。例えば、文字列 `'1.0'` または `'5.9'` を 10 進値にキャストすることはできますが、文字列 `'ABC'` はいずれの数値型にもキャストできません。
+ DECIMAL 値を文字列と比較すると、Amazon Redshift は文字列を DECIMAL 値に変換しようとします。他のすべての数値と文字列を比較する場合、数値は文字列に変換されます。反対方向の変換 (文字列を整数に変換する、DECIMAL 値を文字列に変換するなど) を実行するには、[CAST](r_CAST_function.md) などの明示的な関数を使用します。
+ 64 ビットの DECIMAL または NUMERIC の値を上位の精度に変換するには、CAST や CONVERT などの明示的な変換関数を使用する必要があります。
+ DATE または TIMESTAMP を TIMESTAMPTZ に変換する場合、または TIME を TIMETZ に変換する場合、タイムゾーンは現在のセッションのタイムゾーンに設定されます。セッションのタイムゾーンは、デフォルト値の UTC です。セッションのタイムゾーンを設定する方法の詳細については、「[timezone](r_timezone_config.md)」を参照してください。
+ 同様に、TIMESTAMPTZ は、現在のセッションのタイムゾーンに基づいて DATE、TIME または TIMESTAMP に変換されます。セッションのタイムゾーンは、デフォルト値の UTC です。変換後、タイムゾーン情報は削除されます。
+ 指定されたタイムゾーンを含むタイムスタンプを表す文字列は、現在のセッションタイムゾーン (デフォルトでは UTC) を使用して TIMESTAMPTZ に変換されます。同様に、タイムゾーンが指定されている時刻を表す文字列は、現在のセッションのタイムゾーン (デフォルトでは UTC) を使用して TIMETZ に変換されます。
### 暗黙的な変換型
暗黙的な変換には、2 つのタイプがあります。
+ 割り当てにおける暗黙的な変換 (INSERT コマンドまたは UPDATE コマンドで値を設定するなど)
+ 式における暗黙的な変換 (WHERE 句で比較を実行するなど)
次の表に、割り当てまたは式において暗黙的に変換できるデータ型を一覧表示します。これらの変換は、明示的な変換関数を使用して実行することもできます。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/c_Supported_data_types.html)
**注記**
TIMESTAMPTZ、TIMESTAMP、DATE、TIME、TIMETZ、またはキャラクタ文字列間の暗黙的な変換では、現在のセッションのタイムゾーンが使用されます。現在のタイムゾーンの設定については、「[timezone](r_timezone_config.md)」を参照してください。
GEOMETRY および GEOGRAPHY データ型は、互いに変換する場合を除き、暗黙的に他のデータ型に変換することはできません。詳細については、「[CAST 関数](r_CAST_function.md)」を参照してください。
VARBYTE データ型は、暗黙的に他のデータ型に変換できません。詳細については、「[CAST 関数](r_CAST_function.md)」を参照してください。
### SUPER データ型での動的型付けの使用
Amazon Redshift では、動的型付けを使用して、クエリで使用する前にデータ型を宣言することなく、スキーマレスの SUPER データを処理します。動的型付けでは、明示的に Amazon Redshift 型にキャストすることなく、SUPER データ列に移動した結果が使用されます。SUPER データ型に対する動的型付けを使用する方法の詳細については、[動的型付け](query-super.md#dynamic-typing-lax-processing) を参照してください。
一部の例外を除いて、他のデータ型との間で SUPER 値をキャストすることができます。詳細については、「[制限事項](limitations-super.md)」を参照してください。
# 照合順序
Amazon Redshift では、ロケール固有の照合順序またはユーザー定義の照合順序をサポートしていません。一般に、コンテキストでの述語の結果は、データ値のソートおよび比較に関するロケール固有のルールがないことに影響を受ける可能性があります。例えば、ORDER BY 式と、MIN、MAX、および RANK などの関数は、ロケール固有の文字を考慮に入れないデータのバイナリ UTF8 順序付けに基づいて結果を返します。
# 式
**Topics**
+ [単純式](#r_expressions-simple-expressions)
+ [複合式](r_compound_expressions.md)
+ [式リスト](r_expression_lists.md)
+ [スカラーサブクエリ](r_scalar_subqueries.md)
+ [関数式](r_function_expressions.md)
式は、1 つまたは複数の値、演算子、または関数 (評価して値を返す) の組み合わせです。式のデータ型は、一般にそのコンポーネントのデータ型と同じです。
## 単純式
単純式は以下のいずれかとなります。
+ 定数またはリテラル値
+ 列名または列参照
+ スカラー関数
+ 集計 (set) 関数
+ ウィンドウ関数
+ スカラーサブクエリ
単純式には次のようなものがあります。
```
5+12
dateid
sales.qtysold * 100
sqrt (4)
max (qtysold)
(select max (qtysold) from sales)
```
# 複合式
複合式は、一連の単純式が算術演算子によって結合されたものです。複合式内で使用される単純式は、数値を返す必要があります。
## 構文
```
expression
operator
expression | (compound_expression)
```
## 引数
*expression*
評価して値を返す単純式。
*operator*
複合演算式は、以下の演算子 (優先順位は列記順) を使用して作成することができます。
+ ( ) : 評価の順番を制御する括弧
+ \$1 , - : 正および負の符号/演算子
+ ^ , \$1/ , \$1\$1/ : 指数、平方根、立方根
+ \$1 , / , % : 乗算演算子、除算演算子、モジュロ演算子
+ @ : 絶対値
+ \$1 , - : 加算および減算
+ & , \$1, \$1, \$1, <<, >> : AND、OR、NOT、左シフト、右シフトのビット演算子
+ \$1\$1: 連結
*(compound\$1expression)*
複合式は括弧を使用して入れ子にすることができます。
## 例
複合式の例を以下に示します。
```
('SMITH' || 'JONES')
sum(x) / y
sqrt(256) * avg(column)
rank() over (order by qtysold) / 100
(select (pricepaid - commission) from sales where dateid = 1882) * (qtysold)
```
また、一部の関数は、他の関数内に入れ子にすることができます。例えば、任意のスカラー関数を別のスカラー関数内に入れ子にすることができます。次の例では、一連の数の絶対値の合計を返します。
```
sum(abs(qtysold))
```
ウィンドウ関数は、集計関数または他のウィンドウ関数の引数として使用できません。次の式は、エラーを返すことになります。
```
avg(rank() over (order by qtysold))
```
ウィンドウ関数には入れ子にした集計関数を含めることができます。次の式は、値セットの合計を出し、ランク付けします。
```
rank() over (order by sum(qtysold))
```
# 式リスト
式リストは、式の組み合わせであり、メンバーシップおよび比較条件 (WHERE 句) 内、および GROUP BY 句内に指定できます。
## 構文
```
expression , expression , ... | (expression, expression, ...)
```
## 引数
*expression*
評価して値を返す単純式。式リストには、1 つまたは複数のカンマ区切り式、または 1 つまたは複数のカンマ区切り式セットを含めることができます。複数の式セットがある場合、各セットはそれぞれ同じ個数の式を含み、括弧で区切る必要があります。各セット内の式の個数は、条件内の演算子の前にある式の個数と一致する必要があります。
## 例
条件内の式リストの例を次に示します。
```
(1, 5, 10)
('THESE', 'ARE', 'STRINGS')
(('one', 'two', 'three'), ('blue', 'yellow', 'green'))
```
各セット内の式の個数は、ステートメントの最初の部分にある式の個数と一致する必要があります。
```
select * from venue
where (venuecity, venuestate) in (('Miami', 'FL'), ('Tampa', 'FL'))
order by venueid;
venueid | venuename | venuecity | venuestate | venueseats
---------+-------------------------+-----------+------------+------------
28 | American Airlines Arena | Miami | FL | 0
54 | St. Pete Times Forum | Tampa | FL | 0
91 | Raymond James Stadium | Tampa | FL | 65647
(3 rows)
```
# スカラーサブクエリ
スカラーサブクエリとは、ちょうど 1 つの値 (1 つの列を含む 1 つの行) を返す、括弧で囲まれた通常の SELECT クエリです。実行されたこのクエリが返す値は、外部のクエリで使用されます。サブクエリが 0 行ゼロを返した場合、サブクエリ式の値は Null になります。サブクエリが複数の行を返した場合、Amazon Redshift はエラーを返します。サブクエリは親クエリからの変数を参照することができます。この変数はサブクエリの起動時中には定数として働きます。
式を呼び出すほとんどのステートメントでスカラーサブクエリを使用できます。次のような場合、スカラーサブクエリは有効な式でなくなります。
+ 式のデフォルト値として使用
+ GROUP BY 句および HAVING 句内に使用
## 例
次のサブクエリは 2008 年の 1 年を通して販売 1 回あたりに支払われた平均料金を計算します。次に、外側のクエリが出力にその値を使用して、四半期ごとの販売 1 回あたりの平均料金と比較します。
```
select qtr, avg(pricepaid) as avg_saleprice_per_qtr,
(select avg(pricepaid)
from sales join date on sales.dateid=date.dateid
where year = 2008) as avg_saleprice_yearly
from sales join date on sales.dateid=date.dateid
where year = 2008
group by qtr
order by qtr;
qtr | avg_saleprice_per_qtr | avg_saleprice_yearly
-------+-----------------------+----------------------
1 | 647.64 | 642.28
2 | 646.86 | 642.28
3 | 636.79 | 642.28
4 | 638.26 | 642.28
(4 rows)
```
# 関数式
## 構文
組み込み関数は式として使用できます。関数呼び出しの構文は、関数名の後に、その引数リストを括弧に囲んで配置する形式をとります。
```
function ( [expression [, expression...]] )
```
## 引数
* 関数*
組み込み関数。サンプルの関数については、「[SQL 関数リファレンス](c_SQL_functions.md)」を参照してください。
*expression*
関数によって予期されるデータ型およびパラメータの個数と一致する式。
## 例
```
abs (variable)
select avg (qtysold + 3) from sales;
select dateadd (day,30,caldate) as plus30days from date;
```
# 条件
**Topics**
+ [構文](#r_conditions-synopsis)
+ [比較条件](r_comparison_condition.md)
+ [論理条件](r_logical_condition.md)
+ [パターンマッチング条件](pattern-matching-conditions.md)
+ [BETWEEN 範囲条件](r_range_condition.md)
+ [Null 条件](r_null_condition.md)
+ [EXISTS 条件](r_exists_condition.md)
+ [IN 条件](r_in_condition.md)
条件は、評価結果として true、false、または unknown を返す、1 つまたは複数の式および論理演算子から成るステートメントです。条件は述語と呼ばれることもあります。
**注記**
すべての文字列比較および LIKE パターンマッチングでは、大文字と小文字が区別されます。例えば、「A」と「a」は一致しません。ただし、ILIKE 述語を使用すれば、大文字小文字を区別しないパターンマッチングを行うことができます。
## 構文
```
comparison_condition
| logical_condition
| range_condition
| pattern_matching_condition
| null_condition
| EXISTS_condition
| IN_condition
```
# 比較条件
比較条件では、2 つの値の間の論理的な関係を指定します。比較条件はすべて、ブール型の戻り値を返す 2 項演算子です。Amazon Redshift では、次のテーブルで説明する比較演算子をサポートしています。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_comparison_condition.html)
## 使用に関する注意事項
= ANY \$1 SOME
ANY と SOME のキーワードは *IN* 条件と同義であり、1 つまたは複数の値を返すサブクエリによって返された少なくとも 1 つの値に対して比較が true である場合に true を返します。Amazon Redshift は、ANY および SOME に対して = (等しい) 条件のみをサポートします。不等条件はサポートされていません。
ALL 述語はサポートされていません。
<> ALL
ALL キーワードは NOT IN ([IN 条件](r_in_condition.md) 条件を参照) と同義であり、サブクエリの結果に式が含まれていない場合に true を返します。Amazon Redshift は、ALL に対して <> または \$1= (等しくない) 条件のみをサポートします。他の比較条件はサポートされていません。
IS TRUE/FALSE/UNKNOWN
ゼロ以外の値は TRUE と等しく、0 は FALSE に等しく、Null は UNKNOWN に等しくなります。「[ブール型HLLSKETCH タイプ](r_Boolean_type.md)」データ型を参照してください。
## 例
ここで、比較条件の簡単な例をいくつか示します。
```
a = 5
a < b
min(x) >= 5
qtysold = any (select qtysold from sales where dateid = 1882
```
次のクエリは、VENUE テーブルから席数が 10000 席を超える会場を返します。
```
select venueid, venuename, venueseats from venue
where venueseats > 10000
order by venueseats desc;
venueid | venuename | venueseats
---------+--------------------------------+------------
83 | FedExField | 91704
6 | New York Giants Stadium | 80242
79 | Arrowhead Stadium | 79451
78 | INVESCO Field | 76125
69 | Dolphin Stadium | 74916
67 | Ralph Wilson Stadium | 73967
76 | Jacksonville Municipal Stadium | 73800
89 | Bank of America Stadium | 73298
72 | Cleveland Browns Stadium | 73200
86 | Lambeau Field | 72922
...
(57 rows)
```
この例では、USERS テーブルからロックミュージックが好きなユーザー (USERID) を選択します。
```
select userid from users where likerock = 't' order by 1 limit 5;
userid
--------
3
5
6
13
16
(5 rows)
```
この例では、USERS テーブルから、ロックミュージックを好きかどうか不明であるユーザー (USERID) を選択します。
```
select firstname, lastname, likerock
from users
where likerock is unknown
order by userid limit 10;
firstname | lastname | likerock
----------+----------+----------
Rafael | Taylor |
Vladimir | Humphrey |
Barry | Roy |
Tamekah | Juarez |
Mufutau | Watkins |
Naida | Calderon |
Anika | Huff |
Bruce | Beck |
Mallory | Farrell |
Scarlett | Mayer |
(10 rows
```
## TIME 列の例
次のテーブルの TIME\$1TEST の例には、3 つの値が挿入された列 TIME\$1VAL (タイプ TIME) があります。
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
次の例では、各 timetz\$1val から時間を抽出します。
```
select time_val from time_test where time_val < '3:00';
time_val
---------------
00:00:00.5550
00:58:00
```
次の例では、2 つの時刻リテラルを比較します。
```
select time '18:25:33.123456' = time '18:25:33.123456';
?column?
----------
t
```
## TIMETZ 列の例
次のテーブルの TIMETZ\$1TEST の例には、3 つの値が挿入された列 TIMETZ\$1VAL (タイプ TIMETZ) があります。
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
次の例では、`3:00:00 UTC` 未満の TIMETZ 値のみを選択します。値を UTC に変換した後に比較が行われます。
```
select timetz_val from timetz_test where timetz_val < '3:00:00 UTC';
timetz_val
---------------
00:00:00.5550+00
```
次の例では、2 つの TIMETZ リテラルを比較します。タイムゾーンは、比較のために無視されます。
```
select time '18:25:33.123456 PST' < time '19:25:33.123456 EST';
?column?
----------
t
```
# 論理条件
論理条件は、2 つの条件の結果を結合して 1 つの結果を作成します。論理条件はすべて、ブール型の戻り値を返す 2 項演算子です。
## 構文
```
expression
{ AND | OR }
expression
NOT expression
```
論理条件では 3 値ブール論理を使用します。この場合、Null 値は unknown 関係を表現します。次の表で論理条件の結果について説明します。ここで、`E1` と `E2` は式を表します。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_logical_condition.html)
NOT 演算子は AND 演算子より先に評価され、AND 演算子は OR 演算子より先に評価されます。括弧が使用されている場合、評価のデフォルトの順序より優先されます。
### 例
次の例では、USERS テーブルから、ラスベガスもスポーツも好きであるユーザーの USERID および USERNAME を返します。
```
select userid, username from users
where likevegas = 1 and likesports = 1
order by userid;
userid | username
--------+----------
1 | JSG99FHE
67 | TWU10MZT
87 | DUF19VXU
92 | HYP36WEQ
109 | FPL38HZK
120 | DMJ24GUZ
123 | QZR22XGQ
130 | ZQC82ALK
133 | LBN45WCH
144 | UCX04JKN
165 | TEY68OEB
169 | AYQ83HGO
184 | TVX65AZX
...
(2128 rows)
```
次の例では、USERS テーブルから、ラスベガスが好き、スポーツが好き、または両方が好きのいずれかに該当するユーザーの USERID と USERNAME を返します。このクエリでは、前の例の出力と、ラスベガスのみ好き、またはスポーツのみ好きなユーザーとをすべて返します。
```
select userid, username from users
where likevegas = 1 or likesports = 1
order by userid;
userid | username
--------+----------
1 | JSG99FHE
2 | PGL08LJI
3 | IFT66TXU
5 | AEB55QTM
6 | NDQ15VBM
9 | MSD36KVR
10 | WKW41AIW
13 | QTF33MCG
15 | OWU78MTR
16 | ZMG93CDD
22 | RHT62AGI
27 | KOY02CVE
29 | HUH27PKK
...
(18968 rows)
```
次のクエリでは、`OR` 条件を囲む括弧を使用して、マクベスが上演されたニューヨークあるいはカリフォルニアの劇場を探します。
```
select distinct venuename, venuecity
from venue join event on venue.venueid=event.venueid
where (venuestate = 'NY' or venuestate = 'CA') and eventname='Macbeth'
order by 2,1;
venuename | venuecity
----------------------------------------+---------------
Geffen Playhouse | Los Angeles
Greek Theatre | Los Angeles
Royce Hall | Los Angeles
American Airlines Theatre | New York City
August Wilson Theatre | New York City
Belasco Theatre | New York City
Bernard B. Jacobs Theatre | New York City
...
```
この例の括弧を削除すると、クエリの論理および結果が変更されます。
次の例では、`NOT` 演算子を使用します。
```
select * from category
where not catid=1
order by 1;
catid | catgroup | catname | catdesc
-------+----------+-----------+--------------------------------------------
2 | Sports | NHL | National Hockey League
3 | Sports | NFL | National Football League
4 | Sports | NBA | National Basketball Association
5 | Sports | MLS | Major League Soccer
...
```
次の例では、`NOT` 条件の後に `AND` 条件を使用しています。
```
select * from category
where (not catid=1) and catgroup='Sports'
order by catid;
catid | catgroup | catname | catdesc
-------+----------+---------+---------------------------------
2 | Sports | NHL | National Hockey League
3 | Sports | NFL | National Football League
4 | Sports | NBA | National Basketball Association
5 | Sports | MLS | Major League Soccer
(4 rows)
```
# パターンマッチング条件
**Topics**
+ [LIKE](r_patternmatching_condition_like.md)
+ [SIMILAR TO](pattern-matching-conditions-similar-to.md)
+ [POSIX 演算子](pattern-matching-conditions-posix.md)
パターンマッチング演算子は、条件式で指定されたパターンが存在するかどうか文字列を調べ、該当するパターンが見つかったかどうかに応じて true または false を返します。Amazon Redshift は、パターン一致に 3 つの方法を使用します。
+ LIKE 式
LIKE 演算子は、列名などの文字列式を、ワイルドカード文字 `%` (パーセント) および `_` (アンダースコア) を使用したパターンと比較します。LIKE パターンマッチングは常に文字列全体を網羅します。LIKE は大文字小文字を区別するマッチングを実行し、ILIKE は大文字小文字を区別しないマッチングを実行します。
+ SIMILAR TO 正規表現
SIMILAR TO 演算子は、文字列式を、SQL の標準的な正規表現パターンと突き合わせます。このパターンには、LIKE 演算子でサポートされている 2 つを含む一連のパターンマッチングメタ文字を含めることができます。SIMILAR TO は、文字列全体をマッチングし、大文字小文字を区別するマッチングを実行します。
+ POSIX スタイルの正規表現
POSIX 正規表現は、LIKE および SIMILAR TO の演算子の場合よりも強力なパターンマッチング手段を提供します。POSIX 正規表現パターンでは、文字列の任意の部分をマッチングすることができ、大文字小文字を区別するマッチングを実行します。
SIMILAR TO または POSIX の演算子を使用する正規表現マッチングは、計算コストが高くなります。非常に多くの行を処理する場合は特に、可能な限り、LIKE を使用することをお勧めします。例えば、以下に示す各クエリは機能的には同じですが、LIKE を使用したクエリは、正規表現を使用したクエリよりも数倍速く実行できます。
```
select count(*) from event where eventname SIMILAR TO '%(Ring|Die)%';
select count(*) from event where eventname LIKE '%Ring%' OR eventname LIKE '%Die%';
```
# LIKE
LIKE 演算子は、列名などの文字列式を、ワイルドカード文字 % (パーセント) および \$1 (アンダースコア) を使用したパターンと比較します。LIKE パターンマッチングは常に文字列全体を網羅します。文字列内の任意の場所にあるシーケンスをマッチングするには、パターンがパーセント符号で始まりパーセント符号で終了する必要があります。
LIKE は大文字小文字を区別し、ILIKE は大文字小文字を区別しません。
## 構文
```
expression [ NOT ] LIKE | ILIKE pattern [ ESCAPE 'escape_char' ]
```
## 引数
*expression*
列名など、有効な UTF-8 文字式。
LIKE \$1 ILIKE
LIKE は大文字小文字を区別するパターンマッチングを実行します。ILIKE は、シングルバイト UTF-8 (ASCII) 文字に対して大文字小文字を区別しないパターンマッチングを実行します。マルチバイト文字に対して大文字と小文字を区別しないパターンの一致を実行するには、LIKE 条件の *pattern* と *pattern* で [LOWER](r_LOWER.md) 関数を使用します。
= や <> などの比較述語とは対照的に、述語 LIKE と ILIKE は、末尾の空白を暗黙的に無視しません。末尾のスペースを無視するには、RTRIM を使用するか、または CHAR 列を VARCHAR に明示的にキャストします。
`~~` 演算子は LIKE に相当し、`~~*` は ILIKE に相当します。また、`!~~` および `!~~*` 演算子は、NOT LIKE および NOT ILIKE に相当します。
*pattern*
マッチングするパターンが含まれる有効な UTF-8 文字式。
*escape\$1char*
パターン内でメタ文字をエスケープする文字式。デフォルトは 2 個のバックスラッシュ (「\$1\$1」) です。
*pattern* にメタ文字が含まれていない場合、pattern は文字列そのものを表現するにすぎません。その場合、LIKE は等号演算子と同じ働きをします。
どちらの文字式も CHAR または VARCHAR のデータ型になることができます。文字式の型が異なる場合、Amazon Redshift は *pattern* のデータ型を *expression* のデータ型に変換します。
LIKE では、次のパターンマッチングメタ文字をサポートしています。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_patternmatching_condition_like.html)
## 例
次の例では、LIKE を使用したパターンマッチングの例を示します。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_patternmatching_condition_like.html)
次の例では、名前が「E」で始まるすべての市を見つけます。
```
select distinct city from users
where city like 'E%' order by city;
city
---------------
East Hartford
East Lansing
East Rutherford
East St. Louis
Easthampton
Easton
Eatontown
Eau Claire
...
```
次の例では、姓に「ten」が含まれるユーザーを見つけます。
```
select distinct lastname from users
where lastname like '%ten%' order by lastname;
lastname
-------------
Christensen
Wooten
...
```
次の例は、複数のパターンを一致させる方法を示しています。
```
select distinct lastname from tickit.users
where lastname like 'Chris%' or lastname like '%Wooten' order by lastname;
lastname
-------------
Christensen
Christian
Wooten
...
```
次の例では、3 番目と 4 番目の文字が「ea」になっている市を見つけます。コマンドでは ILIKE を使用して、大文字小文字の区別なしを実演します。
```
select distinct city from users where city ilike '__EA%' order by city;
city
-------------
Brea
Clearwater
Great Falls
Ocean City
Olean
Wheaton
(6 rows)
```
次の例では、デフォルトのエスケープ文字列 (\$1\$1) を使用して「start\$1」を含む文字列を検索します (テキスト `start`、それに続いてアンダースコア `_`)。
```
select tablename, "column" from pg_table_def
where "column" like '%start\\_%'
limit 5;
tablename | column
-------------------+---------------
stl_s3client | start_time
stl_tr_conflict | xact_start_ts
stl_undone | undo_start_ts
stl_unload_log | start_time
stl_vacuum_detail | start_row
(5 rows)
```
次の例では、エスケープ文字として '^' を指定し、そのエスケープ文字を使用して「start\$1」を含む文字列を検索します (テキスト `start`、それに続いてアンダースコア `_`)。
```
select tablename, "column" from pg_table_def
where "column" like '%start^_%' escape '^'
limit 5;
tablename | column
-------------------+---------------
stl_s3client | start_time
stl_tr_conflict | xact_start_ts
stl_undone | undo_start_ts
stl_unload_log | start_time
stl_vacuum_detail | start_row
(5 rows)
```
次の例では、`~~*` 演算子を使用して「Ag」で始まる都市の大文字と小文字を区別しない (ILIKE) 検索を行います。
```
select distinct city from users where city ~~* 'Ag%' order by city;
city
------------
Agat
Agawam
Agoura Hills
Aguadilla
```
# SIMILAR TO
SIMILAR TO 演算子は、列名などの文字列式を、SQL の標準的な正規表現パターンと突き合わせます。SQL の正規表現パターンには、[LIKE](r_patternmatching_condition_like.md) 演算子によってサポートされる 2 つを含む、一連のパターンマッチングメタ文字を含めることができます。
SIMILAR TO 演算子の場合は、POSIX の正規表現の動作 (パターンは文字列の任意の部分と一致できる) とは異なり、パターンが文字全体と一致した場合にのみ true を返します。
SIMILAR TO は大文字小文字を区別するマッチングを実行します。
**注記**
SIMILAR TO を使用する正規表現マッチングは、計算コストが高くなります。非常に多くの行を処理する場合は特に、可能な限り、LIKE を使用することをお勧めします。例えば、以下に示す各クエリは機能的には同じですが、LIKE を使用したクエリは、正規表現を使用したクエリよりも数倍速く実行できます。
```
select count(*) from event where eventname SIMILAR TO '%(Ring|Die)%';
select count(*) from event where eventname LIKE '%Ring%' OR eventname LIKE '%Die%';
```
## 構文
```
expression [ NOT ] SIMILAR TO pattern [ ESCAPE 'escape_char' ]
```
## 引数
*expression*
列名など、有効な UTF-8 文字式。
SIMILAR TO
SIMILAR TO は、*expression* 内の文字列全体について、大文字小文字を区別するパターンマッチングを実行します。
* パターン*
SQL の標準的な正規表現パターンを表現する有効な UTF-8 文字式。
*escape\$1char*
パターン内でメタ文字をエスケープする文字式。デフォルトは 2 個のバックスラッシュ (「\$1\$1」) です。
*pattern* にメタ文字が含まれていない場合、pattern は文字列そのものを表現するにすぎません。
どちらの文字式も CHAR または VARCHAR のデータ型になることができます。文字式の型が異なる場合、Amazon Redshift は *pattern* のデータ型を *expression* のデータ型に変換します。
SIMILAR TO では、次のパターンマッチングメタ文字をサポートしています。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/pattern-matching-conditions-similar-to.html)
## 例
次の表に、SIMILAR TO を使用したパターンマッチングの例を示します。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/pattern-matching-conditions-similar-to.html)
次の例では、名前に「E」または「H」が含まれる市を見つけます。
```
SELECT DISTINCT city FROM users
WHERE city SIMILAR TO '%E%|%H%' ORDER BY city LIMIT 5;
city
-----------------
Agoura Hills
Auburn Hills
Benton Harbor
Beverly Hills
Chicago Heights
```
次の例では、デフォルトのエスケープ文字列 ('`\\`') を使用して「`_`」を含む文字列を検索します。
```
SELECT tablename, "column" FROM pg_table_def
WHERE "column" SIMILAR TO '%start\\_%'
ORDER BY tablename, "column" LIMIT 5;
tablename | column
--------------------------+---------------------
stcs_abort_idle | idle_start_time
stcs_abort_idle | txn_start_time
stcs_analyze_compression | start_time
stcs_auto_worker_levels | start_level
stcs_auto_worker_levels | start_wlm_occupancy
```
次の例では、エスケープ文字列として '`^`' を指定し、エスケープ文字列を使用して「`_`」を含む文字列を検索します。
```
SELECT tablename, "column" FROM pg_table_def
WHERE "column" SIMILAR TO '%start^_%' ESCAPE '^'
ORDER BY tablename, "column" LIMIT 5;
tablename | column
--------------------------+---------------------
stcs_abort_idle | idle_start_time
stcs_abort_idle | txn_start_time
stcs_analyze_compression | start_time
stcs_auto_worker_levels | start_level
stcs_auto_worker_levels | start_wlm_occupancy
```
# POSIX 演算子
POSIX 正規表現は、マッチパターンを指定する一連の文字です。文字列が正規表現で記述された正規セットのメンバーであれば、その文字列は正規表現と一致します。
POSIX 正規表現は、[LIKE](r_patternmatching_condition_like.md) および [SIMILAR TO](pattern-matching-conditions-similar-to.md) の演算子の場合よりも強力なパターンマッチング手段を提供します。POSIX 正規表現のパターンは、パターンが文字列全体と一致した場合にのみ true を返す SIMILAR TO 演算子の場合とは異なり、文字列の任意の部分と一致することができます。
**注記**
POSIX 演算子を使用する正規表現マッチングは、計算コストが高くなります。非常に多くの行を処理する場合は特に、可能な限り、LIKE を使用することをお勧めします。例えば、以下に示す各クエリは機能的には同じですが、LIKE を使用したクエリは、正規表現を使用したクエリよりも数倍速く実行できます。
```
select count(*) from event where eventname ~ '.*(Ring|Die).*';
select count(*) from event where eventname LIKE '%Ring%' OR eventname LIKE '%Die%';
```
## 構文
```
expression [ ! ] ~ pattern
```
## 引数
*expression*
列名など、有効な UTF-8 文字式。
\$1
拒否演算子。正規表現パターンに一致しません。
\$1
*式*の部分文字列に対して大文字/小文字を区別するマッチングを実行します。
`~~` は [LIKE](r_patternmatching_condition_like.md) の同義語です。
* パターン*
正規表現パターンを表す文字列リテラル。
*pattern* にワイルドカード文字が含まれていない場合、pattern は文字列そのものを表現するにすぎません。
'`. * | ? `' などのメタ文字を含む文字列を検索するには、2 つのバックスラッシュ ('` \\`') を使用して文字をエスケープします。`SIMILAR TO` や `LIKE` と異なり、POSIX 正規表現の構文はユーザー定義のエスケープ文字をサポートしていません。
どちらの文字式も CHAR または VARCHAR のデータ型になることができます。文字式の型が異なる場合、Amazon Redshift は *pattern* のデータ型を *expression* のデータ型に変換します。
文字式はすべて CHAR または VARCHAR のデータ型にすることができます。文字式のデータ型が異なる場合、Amazon Redshift はそれらのデータ型を *expression* のデータ型に変換します。
POSIX パターンマッチングでは、以下のメタ文字がサポートされています。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/pattern-matching-conditions-posix.html)
Amazon Redshift では、以下の POSIX 文字クラスがサポートされています。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/pattern-matching-conditions-posix.html)
Amazon Redshift では、Perl の影響を受けた以下の演算子が正規表現でサポートされています。2 つのバックスラッシュ (「`\\`」) を使用して演算子をエスケープします。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/pattern-matching-conditions-posix.html)
## 例
次の表に、POSIX 演算子を使用したパターンマッチングの例を示します。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/pattern-matching-conditions-posix.html)
以下の例では、名前に `E` または `H` が含まれる市を見つけます。
```
SELECT DISTINCT city FROM users
WHERE city ~ '.*E.*|.*H.*' ORDER BY city LIMIT 5;
city
-----------------
Agoura Hills
Auburn Hills
Benton Harbor
Beverly Hills
Chicago Heights
```
以下の例では、名前に `E` または `H` が含まれない市を見つけます。
```
SELECT DISTINCT city FROM users WHERE city !~ '.*E.*|.*H.*' ORDER BY city LIMIT 5;
city
-----------------
Aberdeen
Abilene
Ada
Agat
Agawam
```
以下の例では、エスケープ文字列 ('`\\`') を使用してピリオドを含む文字列を検索します。
```
SELECT venuename FROM venue
WHERE venuename ~ '.*\\..*'
ORDER BY venueid;
venuename
------------------------------
St. Pete Times Forum
Jobing.com Arena
Hubert H. Humphrey Metrodome
U.S. Cellular Field
Superpages.com Center
E.J. Nutter Center
Bernard B. Jacobs Theatre
St. James Theatre
```
# BETWEEN 範囲条件
`BETWEEN` 条件では、キーワード `BETWEEN` および `AND` を使用して、値が範囲内に入っているかどうか式をテストします。
## 構文
```
expression [ NOT ] BETWEEN expression AND expression
```
式は、数値データ型、文字データ型、または日時データ型とすることができますが、互換性を持つ必要があります。範囲は両端を含みます。
## 例
最初の例では、2、3、または 4 のいずれかのチケットの販売を登録したトランザクション数をカウントします。
```
select count(*) from sales
where qtysold between 2 and 4;
count
--------
104021
(1 row)
```
範囲条件は開始値と終了値を含みます。
```
select min(dateid), max(dateid) from sales
where dateid between 1900 and 1910;
min | max
-----+-----
1900 | 1910
```
範囲条件内の最初の式は最小値、2 番目の式は最大値である必要があります。次の例は、式の値のせいで、常にゼロ行を返します。
```
select count(*) from sales
where qtysold between 4 and 2;
count
-------
0
(1 row)
```
しかし、NOT 修飾子を加えると、論理が反転し、すべての行がカウントされます。
```
select count(*) from sales
where qtysold not between 4 and 2;
count
--------
172456
(1 row)
```
次のクエリは、20000～50000 席を備えた会場のリストを返します。
```
select venueid, venuename, venueseats from venue
where venueseats between 20000 and 50000
order by venueseats desc;
venueid | venuename | venueseats
---------+-------------------------------+------------
116 | Busch Stadium | 49660
106 | Rangers BallPark in Arlington | 49115
96 | Oriole Park at Camden Yards | 48876
...
(22 rows)
```
次の例は、日付値に BETWEEN を使用する方法を示しています。
```
select salesid, qtysold, pricepaid, commission, saletime
from sales
where eventid between 1000 and 2000
and saletime between '2008-01-01' and '2008-01-03'
order by saletime asc;
salesid | qtysold | pricepaid | commission | saletime
--------+---------+-----------+------------+---------------
65082 | 4 | 472 | 70.8 | 1/1/2008 06:06
110917 | 1 | 337 | 50.55 | 1/1/2008 07:05
112103 | 1 | 241 | 36.15 | 1/2/2008 03:15
137882 | 3 | 1473 | 220.95 | 1/2/2008 05:18
40331 | 2 | 58 | 8.7 | 1/2/2008 05:57
110918 | 3 | 1011 | 151.65 | 1/2/2008 07:17
96274 | 1 | 104 | 15.6 | 1/2/2008 07:18
150499 | 3 | 135 | 20.25 | 1/2/2008 07:20
68413 | 2 | 158 | 23.7 | 1/2/2008 08:12
```
BETWEEN の範囲は包括的ですが、日付はデフォルトで 00:00:00 の時刻値であることに注意してください。サンプルクエリで有効な 1 月 3 日の行は、販売時間が `1/3/2008 00:00:00` の行だけです。
# Null 条件
Null 条件は、値が見つからないか、値が不明であるときに、Null かどうかテストします。
## 構文
```
expression IS [ NOT ] NULL
```
## 引数
*expression*
列のような任意の式。
IS NULL
式の値が Null の場合は true で、式が値を持つ場合は false です。
IS NOT NULL
式の値が Null の場合は false で、式が値を持つ場合は true です。
## 例
この例では、SALES テーブルの QTYSOLD フィールドで Null が何回検出されるかを示します。
```
select count(*) from sales
where qtysold is null;
count
-------
0
(1 row)
```
# EXISTS 条件
EXISTS 条件は、サブクエリ内に行が存在するかどうかをテストし、サブクエリが少なくとも 1 つの行を返した場合に true を返します。NOT が指定されると、条件はサブクエリが行を返さなかった場合に true を返します。
## 構文
```
[ NOT ] EXISTS (table_subquery)
```
## 引数
EXISTS
*table\$1subquery* が少なくとも 1 つの行を返した場合に true となります。
NOT EXISTS
*table\$1subquery* が行を返さない場合に true になります。
*table\$1subquery*
評価結果として 1 つまたは複数の列と 1 つまたは複数の行を持つテーブルを返します。
## 例
この例では、任意の種類の販売があった日付ごとに、1 回ずつ、すべての日付識別子を返します。
```
select dateid from date
where exists (
select 1 from sales
where date.dateid = sales.dateid
)
order by dateid;
dateid
--------
1827
1828
1829
...
```
# IN 条件
IN 条件は、一連の値の中に、またはサブクエリ内にあるメンバーシップの値をテストします。
## 構文
```
expression [ NOT ] IN (expr_list | table_subquery)
```
## 引数
*expression*
*expr\$1list* または *table\$1subquery* に対して評価される数値、文字、または日時であり、当該リストまたはサブクエリのデータ型との互換性が必要です。
*expr\$1list*
1 つまたは複数のカンマ区切り式、あるいは括弧で囲まれたカンマ区切り式の 1 つまたは複数のセット。
*table\$1subquery*
評価結果として 1 つまたは複数の行を持つテーブルを返すサブクエリですが、その選択リスト内の列数は 1 個に制限されています。
IN \$1 NOT IN
IN は、式が式リストまたはクエリのメンバーである場合に true を返します。NOT IN は、式がメンバーでない場合に true を返します。*expression* の結果が Null である場合、または、一致する *expr\$1list* 値または *table\$1subquery* 値がなく、これらの比較行の 1 つ以上の結果が Null である場合、IN と NOT IN は NULL を返し、行は返されません。
## 例
次の条件は、リストされた値の場合にのみ true を返します。
```
qtysold in (2, 4, 5)
date.day in ('Mon', 'Tues')
date.month not in ('Oct', 'Nov', 'Dec')
```
## 大規模 IN リストの最適化
クエリのパフォーマンスを最適化するために、10 個を超える値が含まれる IN リストは内部的にスカラー配列として評価されます。10 個未満の値が含まれる IN リストは一連の OR 述語として評価されます。SMALLINT、INTEGER、BIGINT、REAL、DOUBLE PRECISION、BOOLEAN、CHAR、VARCHAR、DATE、TIMESTAMP、および TIMESTAMPTZ データ型では最適化がサポートされています。
この最適化の効果を確認するには、クエリの EXPLAIN 出力を調べてください。次に例を示します。
```
explain select * from sales
QUERY PLAN
--------------------------------------------------------------------
XN Seq Scan on sales (cost=0.00..6035.96 rows=86228 width=53)
Filter: (salesid = ANY ('{1,2,3,4,5,6,7,8,9,10,11}'::integer[]))
(2 rows)
```
# SQL コマンド
SQL 言語は、データベースオブジェクトの作成と操作、クエリの実行、テーブルのロード、およびテーブルデータの変更に使用するコマンドから構成されます。
Amazon Redshift は PostgreSQL に基づいています。Amazon Redshift と PostgreSQL の間には非常に重要な相違点がいくつかあり、データウェアハウスアプリケーションの開発や設計に際しては、それらを念頭に置く必要があります。Amazon Redshift SQL と PostgreSQL の違いについては、[Amazon Redshift および PostgreSQL](c_redshift-and-postgres-sql.md)を参照してください。
**注記**
単一 SQL ステートメントの最大サイズは 16 MB です。
**Topics**
+ [ABORT](r_ABORT.md)
+ [ALTER DATABASE](r_ALTER_DATABASE.md)
+ [ALTER DATASHARE](r_ALTER_DATASHARE.md)
+ [ALTER DEFAULT PRIVILEGES](r_ALTER_DEFAULT_PRIVILEGES.md)
+ [ALTER EXTERNAL SCHEMA](r_ALTER_EXTERNAL_SCHEMA.md)
+ [ALTER EXTERNAL VIEW](r_ALTER_EXTERNAL_VIEW.md)
+ [ALTER FUNCTION](r_ALTER_FUNCTION.md)
+ [ALTER GROUP](r_ALTER_GROUP.md)
+ [他の ID プロバイダー](r_ALTER_IDENTITY_PROVIDER.md)
+ [ALTER MASKING POLICY](r_ALTER_MASKING_POLICY.md)
+ [ALTER MATERIALIZED VIEW](r_ALTER_MATERIALIZED_VIEW.md)
+ [RLS ポリシーの変更](r_ALTER_RLS_POLICY.md)
+ [ALTER ROLE](r_ALTER_ROLE.md)
+ [ALTER PROCEDURE](r_ALTER_PROCEDURE.md)
+ [ALTER SCHEMA](r_ALTER_SCHEMA.md)
+ [ALTER SYSTEM](r_ALTER_SYSTEM.md)
+ [ALTER TABLE](r_ALTER_TABLE.md)
+ [ALTER TABLE APPEND](r_ALTER_TABLE_APPEND.md)
+ [ALTER TEMPLATE](r_ALTER_TEMPLATE.md)
+ [ALTER USER](r_ALTER_USER.md)
+ [ANALYZE](r_ANALYZE.md)
+ [ANALYZE COMPRESSION](r_ANALYZE_COMPRESSION.md)
+ [ATTACH MASKING POLICY](r_ATTACH_MASKING_POLICY.md)
+ [ATTACH RLS POLICY](r_ATTACH_RLS_POLICY.md)
+ [BEGIN](r_BEGIN.md)
+ [CALL](r_CALL_procedure.md)
+ [CANCEL](r_CANCEL.md)
+ [CLOSE](close.md)
+ [COMMENT](r_COMMENT.md)
+ [COMMIT](r_COMMIT.md)
+ [COPY](r_COPY.md)
+ [CREATE DATABASE](r_CREATE_DATABASE.md)
+ [CREATE DATASHARE](r_CREATE_DATASHARE.md)
+ [CREATE EXTERNAL FUNCTION](r_CREATE_EXTERNAL_FUNCTION.md)
+ [CREATE EXTERNAL MODEL](r_create_external_model.md)
+ [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md)
+ [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md)
+ [CREATE EXTERNAL VIEW](r_CREATE_EXTERNAL_VIEW.md)
+ [CREATE FUNCTION](r_CREATE_FUNCTION.md)
+ [CREATE GROUP](r_CREATE_GROUP.md)
+ [ID プロバイダーを作成する](r_CREATE_IDENTITY_PROVIDER.md)
+ [ライブラリを作成する](r_CREATE_LIBRARY.md)
+ [CREATE MASKING POLICY](r_CREATE_MASKING_POLICY.md)
+ [CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md)
+ [モデルを作成する](r_CREATE_MODEL.md)
+ [CREATE PROCEDURE](r_CREATE_PROCEDURE.md)
+ [CREATE RLS POLICY](r_CREATE_RLS_POLICY.md)
+ [CREATE ROLE](r_CREATE_ROLE.md)
+ [CREATE SCHEMA](r_CREATE_SCHEMA.md)
+ [CREATE TABLE](r_CREATE_TABLE_NEW.md)
+ [CREATE TABLE AS](r_CREATE_TABLE_AS.md)
+ [CREATE TEMPLATE](r_CREATE_TEMPLATE.md)
+ [CREATE USER](r_CREATE_USER.md)
+ [CREATE VIEW](r_CREATE_VIEW.md)
+ [DEALLOCATE](r_DEALLOCATE.md)
+ [DECLARE](declare.md)
+ [DELETE](r_DELETE.md)
+ [DESC DATASHARE](r_DESC_DATASHARE.md)
+ [DESC ID プロバイダー](r_DESC_IDENTITY_PROVIDER.md)
+ [DETACH MASKING POLICY](r_DETACH_MASKING_POLICY.md)
+ [DETACH RLS POLICY](r_DETACH_RLS_POLICY.md)
+ [DROP DATABASE](r_DROP_DATABASE.md)
+ [DROP DATASHARE](r_DROP_DATASHARE.md)
+ [DROP EXTERNAL VIEW](r_DROP_EXTERNAL_VIEW.md)
+ [DROP FUNCTION](r_DROP_FUNCTION.md)
+ [DROP GROUP](r_DROP_GROUP.md)
+ [DROP ID プロバイダー](r_DROP_IDENTITY_PROVIDER.md)
+ [DROP LIBRARY](r_DROP_LIBRARY.md)
+ [DROP MASKING POLICY](r_DROP_MASKING_POLICY.md)
+ [DROP MODEL](r_DROP_MODEL.md)
+ [DROP MATERIALIZED VIEW](materialized-view-drop-sql-command.md)
+ [DROP PROCEDURE](r_DROP_PROCEDURE.md)
+ [DROP RLS POLICY](r_DROP_RLS_POLICY.md)
+ [DROP ROLE](r_DROP_ROLE.md)
+ [DROP SCHEMA](r_DROP_SCHEMA.md)
+ [DROP TABLE](r_DROP_TABLE.md)
+ [DROP TEMPLATE](r_DROP_TEMPLATE.md)
+ [DROP USER](r_DROP_USER.md)
+ [DROP VIEW](r_DROP_VIEW.md)
+ [END](r_END.md)
+ [EXECUTE](r_EXECUTE.md)
+ [EXPLAIN](r_EXPLAIN.md)
+ [FETCH](fetch.md)
+ [GRANT](r_GRANT.md)
+ [INSERT](r_INSERT_30.md)
+ [INSERT (外部テーブル)](r_INSERT_external_table.md)
+ [LOCK](r_LOCK.md)
+ [MERGE](r_MERGE.md)
+ [PREPARE](r_PREPARE.md)
+ [REFRESH MATERIALIZED VIEW](materialized-view-refresh-sql-command.md)
+ [RESET](r_RESET.md)
+ [REVOKE](r_REVOKE.md)
+ [ROLLBACK](r_ROLLBACK.md)
+ [SELECT](r_SELECT_synopsis.md)
+ [SELECT INTO](r_SELECT_INTO.md)
+ [SET](r_SET.md)
+ [SET SESSION AUTHORIZATION](r_SET_SESSION_AUTHORIZATION.md)
+ [SET SESSION CHARACTERISTICS](r_SET_SESSION_CHARACTERISTICS.md)
+ [SHOW](r_SHOW.md)
+ [SHOW COLUMN GRANTS](r_SHOW_COLUMN_GRANTS.md)
+ [SHOW COLUMNS](r_SHOW_COLUMNS.md)
+ [SHOW CONSTRAINTS](r_SHOW_CONSTRAINTS.md)
+ [SHOW EXTERNAL TABLE](r_SHOW_EXTERNAL_TABLE.md)
+ [SHOW DATABASES](r_SHOW_DATABASES.md)
+ [SHOW FUNCTIONS](r_SHOW_FUNCTIONS.md)
+ [SHOW GRANTS](r_SHOW_GRANTS.md)
+ [SHOW MODEL](r_SHOW_MODEL.md)
+ [SHOW DATASHARES](r_SHOW_DATASHARES.md)
+ [SHOW PARAMETERS](r_SHOW_PARAMETERS.md)
+ [SHOW POLICIES](r_SHOW_POLICIES.md)
+ [SHOW PROCEDURE](r_SHOW_PROCEDURE.md)
+ [SHOW PROCEDURE](r_SHOW_PROCEDURES.md)
+ [SHOW SCHEMAS](r_SHOW_SCHEMAS.md)
+ [テーブルを表示する](r_SHOW_TABLE.md)
+ [SHOW TABLES](r_SHOW_TABLES.md)
+ [SHOW TEMPLATE](r_SHOW_TEMPLATE.md)
+ [SHOW TEMPLATES](r_SHOW_TEMPLATES.md)
+ [ビューを表示する](r_SHOW_VIEW.md)
+ [START TRANSACTION](r_START_TRANSACTION.md)
+ [TRUNCATE](r_TRUNCATE.md)
+ [UNLOAD](r_UNLOAD.md)
+ [UPDATE](r_UPDATE.md)
+ [使用](r_USE_command.md)
+ [VACUUM](r_VACUUM_command.md)
# ABORT
現在実行中のトランザクションを停止し、そのトランザクションで行われたすべての更新を破棄します。ABORT はすでに完了したトランザクションに対しては影響を与えません。
このコマンドは ROLLBACK コマンドと同じ機能を実行します。詳細については、[ROLLBACK](r_ROLLBACK.md)を参照してください。
## 構文
```
ABORT [ WORK | TRANSACTION ]
```
## パラメータ
WORK
オプションキーワード
TRANSACTION
オプションキーワード。WORK と TRANSACTION は同義語です。
## 例
次の例では、テーブルを作成し、データがそのテーブルに挿入されるトランザクションを開始します。次に、ABORT コマンドはデータの挿入をロールバックし、テーブルを空にします。
次のコマンドを実行すると、MOVIE\$1GROSS という名前のテーブルが作成されます。
```
create table movie_gross( name varchar(30), gross bigint );
```
次のコマンドセットを実行すると、2 つのデータ行をテーブルに挿入するトランザクションが開始されます。
```
begin;
insert into movie_gross values ( 'Raiders of the Lost Ark', 23400000);
insert into movie_gross values ( 'Star Wars', 10000000 );
```
その後、次のコマンドを実行すると、テーブルからデータが選択され、挿入が正常に実行されたことが示されます。
```
select * from movie_gross;
```
コマンド出力は、両方の行が正しく挿入されたことを示します。
```
name | gross
------------------------+----------
Raiders of the Lost Ark | 23400000
Star Wars | 10000000
(2 rows)
```
このコマンドはデータ変更を、トランザクションの開始時点までロールバックします。
```
abort;
```
テーブルからデータを選択すると、空のテーブルが表示されます。
```
select * from movie_gross;
name | gross
------+-------
(0 rows)
```
# ALTER DATABASE
データベースの属性を変更します。
## 必要な権限
ALTER DATABASE を使用するには、次の権限のいずれかが必要です。
+ スーパーユーザー
+ ALTER DATASHARE 権限を持つユーザー
+ データベースの所有者
## 構文
```
ALTER DATABASE database_name
{
RENAME TO new_name
| OWNER TO new_owner
| [ CONNECTION LIMIT { limit | UNLIMITED } ]
[ COLLATE { CASE_SENSITIVE | CS | CASE_INSENSITIVE | CI } ]
[ ISOLATION LEVEL { SNAPSHOT | SERIALIZABLE } ]
| INTEGRATION
{
REFRESH { { ALL | INERROR } TABLES [ IN SCHEMA schema [, ...] ] | TABLE schema.table [, ...] }
| SET
[ QUERY_ALL_STATES [=] { TRUE | FALSE } ]
[ ACCEPTINVCHARS [=] { TRUE | FALSE } ]
[ REFRESH_INTERVAL ]
[ TRUNCATECOLUMNS [=] { TRUE | FALSE } ]
[ HISTORY_MODE [=] {TRUE | FALSE} [ FOR { {ALL} TABLES [IN SCHEMA schema [, ...] ] | TABLE schema.table [, ...] } ] ]
}
}
```
## パラメータ
*database\$1name*
変更するデータベースの名前。通常、現在接続されていないデータベースを変更します。いずれの場合も、変更は後のセッションにのみ反映されます。現在のデータベースの所有者を変更できますが、名前を変更することはできません。
```
alter database tickit rename to newtickit;
ERROR: current database may not be renamed
```
RENAME TO
指定したデータベースの名前を変更します。有効な名前の詳細については、「[名前と識別子](r_names.md)」を参照してください。dev、padb\$1harvest、template0、template1、または sys:internal の各データベースの名前を変更することはできません。また、現在のデータベースの名前も変更できません。データベース所有者または[superuser](r_superusers.md#def_superusers)のみがデータベース名を変更できます。スーパーユーザー以外の所有者には CREATEDB 権限も必要です。
*new\$1name*
新しいデータベース名。
OWNER TO
指定したデータベースの所有者を変更します。現在のデータベースまたは他のデータベースの所有者を変更できます。スーパーユーザーのみが所有者を変更できます。
*new\$1owner*
新しいデータベース所有者。新しい所有者は、書き込み権限を持つ既存のデータベースユーザーであることが必要です。ユーザー権限の詳細については、[GRANT](r_GRANT.md)を参照してください。
CONNECTION LIMIT \$1 *limit* \$1 UNLIMITED \$1
ユーザーが同時に開けるデータベース接続の最大数。この制限はスーパーユーザーには適用されません。同時接続の最大数を許可するには、UNLIMITED キーワードを使用します。ユーザーごとの接続数の制限が適用される場合もあります。詳細については、「[CREATE USER](r_CREATE_USER.md)」を参照してください。デフォルトは UNLIMITED です。現在の接続を確認するには、[STV\$1SESSIONS](r_STV_SESSIONS.md)システムビューに対してクエリを実行します。
ユーザーとデータベースの両方の接続制限が適用される場合は、ユーザーが接続しようとしたときに、両方の制限内に未使用の接続スロットがなければなりません。
COLLATE \$1 CASE\$1SENSITIVE \$1 CS \$1 CASE\$1INSENSITIVE \$1 CI \$1
文字列の検索または比較において、大文字と小文字を区別するか、あるいは区別しないかを指定する句。
現在のデータベース (空の場合でも) の大文字と小文字の区別を変更できます。
現在のデータベースで大文字と小文字の区別を変更するには、ALTER アクセス許可が必要です。CREATE DATABASE アクセス許可を持つスーパーユーザーまたはデータベース所有者も、データベースの大文字と小文字の区別を変更できます。
CASE\$1SENSITIVE と CS は互換性があり、同じ結果が得られます。同様に、CASE\$1INSENSITIVE と CI は互換性があり、同じ結果が得られます。
ISOLATION LEVEL \$1 SNAPSHOT \$1 SERIALIZABLE \$1
データベースに対してクエリを実行するときに使用される分離レベルを指定する句。分離レベルの詳細については、「[Amazon Redshift の分離レベル](c_serial_isolation.md)」を参照してください。
+ スナップショットの分離 – 更新および削除の競合に対する保護機能を備えた分離レベルを提供します。
+ 直列化可能な分離 – 同時トランザクションの完全な直列化機能を提供します。
データベースの分離レベルを変更するときは、以下の点を考慮します。
+ データベースの分離レベルを変更するには、スーパーユーザー権限または CREATE DATABASE 権限が必要です。
+ `dev` データベースの分離レベルは変更できません。
+ トランザクションブロック内の分離レベルは変更できません。
+ 他のユーザーがデータベースに接続している場合、分離レベルの変更コマンドは失敗します。
+ 分離レベルの変更コマンドでは、現在のセッションの分離レベルの設定を変更できます。
INTEGRATION
ゼロ ETL 統合データベースを変更します。
REFRESH \$1\$1 ALL \$1 INERROR \$1 TABLES [IN SCHEMA *schema* [, ...]] \$1 TABLE *schema.table* [, ...]\$1
Amazon Redshift がすべてのテーブルを更新するか、あるいは指定されたスキーマやテーブル内でエラーのあるテーブルを更新するかどうかを指定する句。更新によって、指定されたスキーマやテーブル内のテーブルはソースデータベースから完全に複製されます。
詳細については、「*Amazon Redshift 管理ガイド*」の「[ゼロ ETL 統合](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.html)」を参照してください。統合の状態の詳細については、「[SVV\$1INTEGRATION\$1TABLE\$1STATE](r_SVV_INTEGRATION_TABLE_STATE.md)」と「[SVV\$1INTEGRATION](r_SVV_INTEGRATION.md)」を参照してください。
QUERY\$1ALL\$1STATES [=] \$1 TRUE \$1 FALSE \$1
QUERY\$1ALL\$1STATES 句を使用すると、ゼロ ETL 統合テーブルをすべての状態 (`Synced`、`Failed`、`ResyncRequired`、`ResyncInitiated`) でクエリできるかどうかを設定できます。ゼロ ETL 統合テーブルはデフォルトでは、`Synced` 状態でのみクエリできます。
ACCEPTINVCHARS [=] \$1 TRUE \$1 FALSE \$1
ACCEPTINVCHARS 句を使用すると、VARCHAR データ型で無効な文字が検出された場合、ゼロ ETL 統合テーブルが取り込みを継続するかどうかを設定できます。無効な文字が検出されると、無効な文字はデフォルトの `?` 文字に置き換えられます。
REFRESH\$1INTERVAL
REFRESH\$1INTERVAL 句を使用すると、ゼロ ETL ソースからターゲットデータベースにデータを更新するためのおよその時間間隔を秒単位で設定できます。この `interval` は、ソースタイプが Aurora MySQL、Aurora PostgreSQL、または RDS for MySQL のゼロ ETL 統合では、0～432,000 秒 (5 日) に設定できます。Amazon DynamoDB ゼロ ETL 統合の場合、`interval` は 900～432,000 秒 (15 分～5 日) に設定できます。
ゼロ ETL 統合を使用したデータベースの作成の詳細については、「Amazon Redshift 管理ガイド」の「[Amazon Redshift でのデスティネーションデータベースの作成](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html)」を参照してください。**
TRUNCATECOLUMNS [=] \$1 TRUE \$1 FALSE \$1
TRUNCATECOLUMNS 句を使用すると、VARCHAR 列の値または SUPER 列の属性が制限を超えた場合に、ゼロ ETL 統合テーブルが取り込みを続行するかどうかを設定できます。`TRUE` の場合、値は列に収まるように切り捨てられ、オーバーフローする JSON 属性の値は SUPER 列に収まるように切り捨てられます。
HISTORY\$1MODE [=] \$1TRUE \$1 FALSE\$1 [ FOR \$1 \$1ALL\$1 TABLES [IN SCHEMA schema [, ...]] \$1 TABLE schema.table [, ...]\$1 ]
Amazon Redshift が、ゼロ ETL 統合の対象となるすべてのテーブルまたは指定されたスキーマ内のテーブルに履歴モードを設定するかどうかを指定する句。このオプションは、ゼロ ETL 統合用に作成されたデータベースにのみ適用されます。
HISTORY\$1MODE 句は `TRUE` または `FALSE` に設定できます。デフォルトは `FALSE` です。履歴モードのオンとオフの切り替えが適用されるのは、`Synced` 状態のテーブルのみです。HISTORY\$1MODE の詳細については、「*Amazon Redshift 管理ガイド*」の「[History mode](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-history-mode.html)」(履歴モード) を参照してください。
## 使用に関する注意事項
ALTER DATABASE コマンドは現在のセッションではなく、後のセッションに適用されます。変更の反映を確認するには、変更されたデータベースに再接続する必要があります。
## 例
次の例では、TICKIT\$1SANDBOX という名前のデータベースを TICKIT\$1TEST に変更します。
```
alter database tickit_sandbox rename to tickit_test;
```
次の例では、TICKIT データベース (現在のデータベース) の所有者を DWUSER に変更します。
```
alter database tickit owner to dwuser;
```
次の例では、sampledb データベースで大文字小文字を区別するかどうかの設定を変更しています。
```
ALTER DATABASE sampledb COLLATE CASE_INSENSITIVE;
```
次の例では、スナップショット分離レベルを使用して **sampledb** という名前のデータベースを変更します。
```
ALTER DATABASE sampledb ISOLATION LEVEL SNAPSHOT;
```
次の例では、ゼロ ETL 統合で、データベース **sample\$1integration\$1db** 内のテーブル **schema1.sample\$1table1** と **schema2.sample\$1table2** を更新します。
```
ALTER DATABASE sample_integration_db INTEGRATION REFRESH TABLE schema1.sample_table1, schema2.sample_table2;
```
次の例では、ゼロ ETL 統合で同期されたテーブルと失敗したテーブルをすべて更新します。
```
ALTER DATABASE sample_integration_db INTEGRATION REFRESH ALL tables;
```
次の例では、ゼロ ETL 統合の更新間隔を 600 秒に設定します。
```
ALTER DATABASE sample_integration_db INTEGRATION SET REFRESH_INTERVAL 600;
```
次の例では、スキーマ **sample\$1schema** 内で `ErrorState` となっているテーブルをすべて更新します。
```
ALTER DATABASE sample_integration_db INTEGRATION REFRESH INERROR TABLES in SCHEMA sample_schema;
```
次の例では、`myschema.table1` テーブル の履歴モードをオンに切り替えています。
```
ALTER DATABASE sample_integration_db INTEGRATION SET HISTORY_MODE = true FOR TABLE myschema.table1
```
次の例では、`myschema` のすべてのテーブルの履歴モードをオンに切り替えています。
```
ALTER DATABASE sample_integration_db INTEGRATION SET HISTORY_MODE = true for ALL TABLES IN SCHEMA myschema
```
# ALTER DATASHARE
データ共有の定義を変更します。ALTER DATASHARE を使用して、オブジェクトを追加または削除できます。現在のデータベース内のデータ共有のみを変更できます。関連付けられたデータベースからデータ共有にオブジェクトを追加または削除します。追加または削除するデータ共有オブジェクトに対して必要な許可を持つデータ共有の所有者は、データ共有を変更できます。
## 必要な権限
以下に、ALTER DATASHARE に必要な権限を示します。
+ スーパーユーザー。
+ ALTER DATASHARE の権限を持つユーザー。
+ データ共有に対する ALTER または ALL の権限を持つユーザー
+ 特定のオブジェクトをデータ共有に追加しようとするユーザーには、対象のオブジェクトに対する権限が必要です。この場合、ユーザーはオブジェクトの所有者であるか、オブジェクトに対する SELECT、USAGE、あるいは ALL の権限を持っている必要があります。
## 構文
次の構文は、データ共有に対して、オブジェクトを追加または削除する方法を示しています。
```
ALTER DATASHARE datashare_name { ADD | REMOVE } {
TABLE schema.table [, ...]
| SCHEMA schema [, ...]
| FUNCTION schema.sql_udf (argtype,...) [, ...]
| ALL TABLES IN SCHEMA schema [, ...]
| ALL FUNCTIONS IN SCHEMA schema [, ...] }
```
次の構文は、データ共有のプロパティを設定する方法を示しています。
```
ALTER DATASHARE datashare_name {
[ SET PUBLICACCESSIBLE [=] TRUE | FALSE ]
[ SET INCLUDENEW [=] TRUE | FALSE FOR SCHEMA schema ] }
```
## パラメータ
*datashare\$1name*
変更するデータ共有の名前。
ADD \$1 REMOVE
データ共有にオブジェクトを追加するか、データ共有からオブジェクトを削除するかを指定する句。
TABLE *schema*.*table* [, ...]
データ共有に追加する、指定されたスキーマ内のテーブルまたはビューの名前。
SCHEMA *schema* [, ...]
データ共有に追加するスキーマの名前。
FUNCTION *schema*.*sql\$1udf* (argtype,...) [, ...]
データ共有に追加する引数タイプを伴うユーザー定義の SQL 関数の名前。
ALL TABLES IN SCHEMA *schema* [, ...]
指定されたスキーマ内のすべてのテーブルをデータ共有に追加するかどうかを指定する句。
ALL FUNCTIONS IN SCHEMA *schema* [, ...] \$1
指定されたスキーマ内のすべての関数をデータ共有に追加することを指定する句。
[ SET PUBLICACCESSIBLE [=] TRUE \$1 FALSE ]
公開でアクセス可能なクラスターとデータ共有を共有できるかどうかを指定する句。
[ SET INCLUDENEW [=] TRUE \$1 FALSE FOR SCHEMA *schema* ]
指定したスキーマで作成される将来のテーブル、ビュー、または SQL ユーザー定義関数 (UDF) をデータ共有に追加するかどうかを指定する句。指定したスキーマにある現在のテーブル、ビュー、または SQL UDF は、データ共有に追加されません。データ共有とスキーマの各ペアについて、このプロパティを変更できるのはスーパーユーザーのみです。INCLUDENEW 句はデフォルトで false を返します。
## ALTER DATASHARE の使用に関する注意事項
+ 次のユーザーは、データ共有を変更できます。
+ スーパーユーザー
+ データ共有の所有者
+ データ共有に対する ALTER または ALL 権限を持つユーザー
+ 特定のオブジェクトをデータ共有に追加しようとするユーザーには、そのオブジェクトに対する適切な権限が必要です。ユーザーはオブジェクトの所有者であるか、オブジェクトに対する SELECT、USAGE、ALL 権限を持っている必要があります。
+ スキーマ、テーブル、通常のビュー、遅延バインディングビュー、マテリアライズドビュー、および SQL ユーザー定義関数 (UDF) を共有できます。スキーマにオブジェクトを追加する前に、まず対象のスキーマをデータ共有に追加します。
スキーマを追加する場合、Amazon Redshift はその下にすべてのオブジェクトを追加するわけではありません。それらを明示的に追加する必要があります。
+ AWS Data Exchange データ共有は、パブリックアクセス可能設定を有効にした状態で作成することをお勧めします。
+ 一般的に、パブリックアクセスを無効にするために ALTER DATASHARE ステートメントを使用して AWS Data Exchange データ共有を変更することはお勧めしません。そうすると、AWS アカウントのクラスターがパブリックアクセス可能である場合に、データ共有にアクセスできるアカウントがアクセスできなくなります。このタイプの変更を実行すると、AWS Data Exchangeのデータ製品での使用条件に違反する可能性があります。この推奨事項の例外については、以下を参照してください。
次に、パブリックにアクセス可能な設定を無効にして AWS Data Exchange データ共有を作成した場合に発生する、エラーの例を示します。
```
ALTER DATASHARE salesshare SET PUBLICACCESSIBLE FALSE;
ERROR: Alter of ADX-managed datashare salesshare requires session variable datashare_break_glass_session_var to be set to value 'c670ba4db22f4b'
```
パブリックにアクセス可能な設定を無効にできるよう AWS Data Exchange データ共有を変更するには、次の変数を設定した上で、ALTER DATASHARE ステートメントを再度実行します。
```
SET datashare_break_glass_session_var to 'c670ba4db22f4b';
```
```
ALTER DATASHARE salesshare SET PUBLICACCESSIBLE FALSE;
```
この場合、Amazon Redshift は 1 回限り有効なランダム値を生成し、その値により、AWS Data Exchangeデータ共有の ALTER DATASHARE SET PUBLICACCESSIBLE FALSE を許可するようにセッション変数を設定します。
## 例
次の例では、スキーマ `public` をデータ共有 `salesshare` に追加します。
```
ALTER DATASHARE salesshare ADD SCHEMA public;
```
次の例では、テーブル `public.tickit_sales_redshift` をデータ共有 `salesshare` に追加します。
```
ALTER DATASHARE salesshare ADD TABLE public.tickit_sales_redshift;
```
次の例では、すべてのテーブルをデータ共有 `salesshare` に追加します。
```
ALTER DATASHARE salesshare ADD ALL TABLES IN SCHEMA PUBLIC;
```
次の例では、データ共有 `salesshare` からテーブル `public.tickit_sales_redshift` を削除します。
```
ALTER DATASHARE salesshare REMOVE TABLE public.tickit_sales_redshift;
```
# ALTER DEFAULT PRIVILEGES
指定したユーザーによって今後作成されるオブジェクトに対して、デフォルトで適用するアクセス許可のセットを定義します。デフォルトでは、ユーザーは自分のデフォルトのアクセス許可のみ変更できます。他のユーザーに対しては、スーパーユーザーのみがデフォルトのアクセス許可を指定できます。
デフォルト権限は、ロール、ユーザー、またはユーザーグループに適用できます。デフォルトのアクセス許可は、現在のデータベースに作成されているすべてのオブジェクトにグローバルに設定することも、指定したスキーマに作成されているオブジェクトにのみ設定することもできます。
デフォルトのアクセス許可は、新しいオブジェクトにのみ適用されます。ALTER DEFAULT PRIVILEGES を実行しても、既存のオブジェクトのアクセス許可は変更されません。データベースまたはスキーマ内の任意のユーザーが作成した現在および将来のすべてのオブジェクトに対するアクセス許可を付与するには、「[スコープ設定アクセス許可](https://docs.aws.amazon.com/redshift/latest/dg/t_scoped-permissions.html)」を参照してください。
データベースユーザーのデフォルト権限に関する情報を表示するには、[PG\$1DEFAULT\$1ACL](r_PG_DEFAULT_ACL.md)システムカタログテーブルをクエリします。
権限の詳細については、「[GRANT](r_GRANT.md)」を参照してください。
## 必要な権限
ALTER DEFAULT PRIVILEGES 必要な権限は以下のとおりです。
+ スーパーユーザー
+ ALTER DEFAULT PRIVILEGES の権限を持つユーザー
+ 自身のデフォルトのアクセス権限を変更しているユーザー
+ 自身がアクセス権限を持つスキーマの権限を設定しているユーザー
## 構文
```
ALTER DEFAULT PRIVILEGES
[ FOR USER target_user [, ...] ]
[ IN SCHEMA schema_name [, ...] ]
grant_or_revoke_clause
where grant_or_revoke_clause is one of:
GRANT { { SELECT | INSERT | UPDATE | DELETE | DROP | REFERENCES | TRUNCATE } [,...] | ALL [ PRIVILEGES ] }
ON TABLES
TO { user_name [ WITH GRANT OPTION ] | ROLE role_name | GROUP group_name | PUBLIC } [, ...]
GRANT { EXECUTE | ALL [ PRIVILEGES ] }
ON FUNCTIONS
TO { user_name [ WITH GRANT OPTION ] | ROLE role_name | GROUP group_name | PUBLIC } [, ...]
GRANT { EXECUTE | ALL [ PRIVILEGES ] }
ON PROCEDURES
TO { user_name [ WITH GRANT OPTION ] | ROLE role_name | GROUP group_name | PUBLIC } [, ...]
REVOKE [ GRANT OPTION FOR ] { { SELECT | INSERT | UPDATE | DELETE | REFERENCES | TRUNCATE } [,...] | ALL [ PRIVILEGES ] }
ON TABLES
FROM user_name [, ...] [ RESTRICT ]
REVOKE { { SELECT | INSERT | UPDATE | DELETE | REFERENCES | TRUNCATE } [,...] | ALL [ PRIVILEGES ] }
ON TABLES
FROM { ROLE role_name | GROUP group_name | PUBLIC } [, ...] [ RESTRICT ]
REVOKE [ GRANT OPTION FOR ] { EXECUTE | ALL [ PRIVILEGES ] }
ON FUNCTIONS
FROM user_name [, ...] [ RESTRICT ]
REVOKE { EXECUTE | ALL [ PRIVILEGES ] }
ON FUNCTIONS
FROM { ROLE role_name | GROUP group_name | PUBLIC } [, ...] [ RESTRICT ]
REVOKE [ GRANT OPTION FOR ] { EXECUTE | ALL [ PRIVILEGES ] }
ON PROCEDURES
FROM user_name [, ...] [ RESTRICT ]
REVOKE { EXECUTE | ALL [ PRIVILEGES ] }
ON PROCEDURES
FROM { ROLE role_name | GROUP group_name | PUBLIC } [, ...] [ RESTRICT ]
```
## パラメータ
FOR USER *target\$1user*
省略可能。デフォルト権限が定義されているユーザーの名前。他のユーザーに対しては、スーパーユーザーのみがデフォルト権限を指定できます。デフォルト値は現在のユーザーです。
IN SCHEMA *schema\$1name*
省略可能。IN SCHEMA 句が表示されている場合、指定したデフォルト権限は、指定の *schema\$1name* で作成された新しいオブジェクトに適用されます。この場合、ALTER DEFAULT PRIVILEGES のターゲットであるユーザーまたはユーザーグループは、指定されたスキーマに対する CREATE権限が必要です。スキーマ固有のデフォルト権限は、既存のグローバルなデフォルト権限に追加されます。デフォルトでは、デフォルト権限はデータベース全体にグローバルに適用されます。
GRANT
指定したユーザーが作成するすべての新しいテーブルとビュー、関数、またはストアドプロシージャについて、指定したユーザーやグループに付与する権限のセット。GRANT 句では、[GRANT](r_GRANT.md)コマンドと同じ権限とオプションを設定できます。
WITH GRANT OPTION
権限を付与されるユーザーが、他のユーザーにも同じ権限を付与できることを示します。WITH GRANT OPTION をグループまたは PUBLIC に付与することはできません。
TO *user\$1name* \$1 ROLE *role\$1name* \$1 GROUP *group\$1name*
指定したデフォルト権限が適用されるユーザー、ロール、またはユーザーグループの名前。
REVOKE
指定したユーザーが作成するすべての新しいテーブル、関数、またはストアドプロシージャについて、指定したユーザーやグループから取り消す権限のセット。REVOKE 句では、[REVOKE](r_REVOKE.md)コマンドと同じ権限とオプションを設定できます。
GRANT OPTION FOR
他のユーザーに特定の権限を付与するオプションのみを取り消し、権限自体は取り消しません。グループや PUBLIC の GRANT OPTION を取り消すことはできません。
FROM *user\$1name* \$1 ROLE *role\$1name* \$1 GROUP *group\$1name*
指定した権限をデフォルトで取り消すユーザー、ロール、またはユーザーグループの名前。
RESTRICT
RESTRICT オプションは、ユーザーが直接付与した権限のみを取り消します。これがデフォルトです。
## 例
ユーザーグループ `report_readers` に属する任意のユーザーに対して、ユーザー `report_admin` が作成したすべてのテーブルとビューを表示することを許可するとします。この場合は、スーパーユーザーとして次のコマンドを実行します。
```
alter default privileges for user report_admin grant select on tables to group report_readers;
```
次の例では、最初のコマンドは、作成するすべての新しいテーブルに対する SELECT 権限を付与します。新しいビューを作成するたびに、ビューに対する権限を明示的に付与するか、`alter default privileges` コマンドを再度実行する必要があります。
```
alter default privileges grant select on tables to public;
```
次の例では、`sales_admin`スキーマで作成するすべての新しいテーブルとビューに対して、`sales`ユーザーグループに INSERT 権限が付与されます。
```
alter default privileges in schema sales grant insert on tables to group sales_admin;
```
次の例では、前の例とは逆に ALTER DEFAULT PRIVILEGES コマンドで権限を取り消します。
```
alter default privileges in schema sales revoke insert on tables from group sales_admin;
```
デフォルトでは、PUBLIC ユーザーグループはすべての新しいユーザー定義関数に対する実行許可を付与されます。新しい関数に対する `public` の実行許可を取り消して、`dev_test`ユーザーグループにのみ実行許可を付与するには、次のコマンドを実行します。
```
alter default privileges revoke execute on functions from public;
alter default privileges grant execute on functions to group dev_test;
```
# ALTER EXTERNAL SCHEMA
現在のデータベース内にある既存の外部スキーマを変更します。スキーマを変更できるのは、スキーマ所有者、スーパーユーザー、またはスキーマに対する ALTER 権限を持つユーザーのみです。DATA CATALOG、KAFKA、または MSK から作成された外部スキーマのみを変更できます。
このスキーマの所有者は CREATE EXTERNAL SCHEMA コマンドの発行者です。外部スキーマの所有者を移行するには、「ALTER SCHEMA」を使用して所有者を変更します。他のユーザーやユーザーグループに対してスキーマへのアクセス権を付与するには、GRANT コマンドを使用します。
外部テーブルのアクセス権限に対して、GRANT または REVOKE コマンドを使用することはできません。代わりに、外部スキーマに対するアクセス権限の付与または取り消しを実行します。
詳細については次を参照してください:
+ [ALTER SCHEMA](r_ALTER_SCHEMA.md)
+ [GRANT](r_GRANT.md)
+ [REVOKE](r_REVOKE.md)
+ [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md)
+ [既存の外部スキーマの mTLS 認証を有効にする](materialized-view-streaming-ingestion-mtls.md#materialized-view-streaming-ingestion-mtls-alter)
外部スキーマの詳細を表示するには、SVV\$1EXTERNAL\$1SCHEMAS システムビューにクエリを実行します。詳細については、「[SVV\$1EXTERNAL\$1SCHEMAS](r_SVV_EXTERNAL_SCHEMAS.md)」を参照してください。
## 構文
```
ALTER EXTERNAL SCHEMA schema_name
[ IAM_ROLE [ default | 'SESSION' | 'arn:aws:iam:::role/' ] ]
[ AUTHENTICATION [ none | iam | mtls] ]
[ AUTHENTICATION_ARN 'acm-certificate-arn' | SECRET_ARN 'asm-secret-arn' ]
[ URI 'Kafka bootstrap URL' ]
```
ストリーミングの取り込みに使用する既存の外部スキーマがあり、認証に相互 TLS を実装する場合は、次のようなコマンドを実行できます。このコマンドは、mTLS 認証と ACM の ACM 証明書 ARN を指定します。
```
ALTER EXTERNAL SCHEMA schema_name
AUTHENTICATION mtls
AUTHENTICATION_ARN 'arn:aws:acm:us-east-1:444455556666:certificate/certificate_ID';
```
または、Secrets Manager でシークレット ARN を参照して、mTLS 認証を変更できます。
```
ALTER EXTERNAL SCHEMA schema_name
AUTHENTICATION mtls
SECRET_ARN 'arn:aws:secretsmanager:us-east-1:012345678910:secret:myMTLSSecret';
```
次の例は、ALTER EXTERNAL SCHEMA の URI を変更する方法を示しています。
```
ALTER EXTERNAL SCHEMA schema_name
URI 'lkc-ghidef-67890.centralus.azure.glb.confluent.cloud:9092';
```
次の例は、ALTER EXTERNAL SCHEMA の IAM ロールを変更する方法を示しています。
```
ALTER EXTERNAL SCHEMA schema_name
IAM_ROLE 'arn:aws:iam::012345678901:role/testrole';
```
## パラメータ
IAM\$1ROLE[ default \$1 'SESSION' \$1 'arn:aws:iam:::role/' ]
`default` キーワードを使用して、デフォルトとして設定された IAM ロールを Amazon Redshift で使用します。
フェデレーション ID を使用して Amazon Redshift クラスターに接続し、このコマンドを使用して作成された外部スキーマからテーブルにアクセスする場合は、`'SESSION'` を使用します。
詳細については、「[CREATE EXTERNAL SCHEMA](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_SCHEMA.html)」を参照してください。
AUTHENTICATION
ストリーミング取り込み用に定義された認証タイプ。認証タイプによるストリーミング取り込みは、Apache Kafka、Confluent Cloud、Amazon Managed Streaming for Apache Kafka で機能します。詳細については、「[CREATE EXTERNAL SCHEMA](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_SCHEMA.html)」を参照してください。
AUTHENTICATION\$1ARN
Amazon Redshift が Apache Kafka、Confluent Cloud、または Amazon Managed Streaming for Apache Kafka (Amazon MSK) との mtls 認証に使用する AWS Certificate Manager 証明書の ARN。ARN は、発行された証明書を選択する際に ACM コンソールで利用できます。
SECRET\$1ARN
AWS Secrets Manager を使用して作成した、サポートされているシークレットの Amazon リソースネーム (ARN)。シークレットの ARN を作成および取得する方法については、「*AWS Secrets Manager User Guide*」の「[Manage secrets with AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html)」および「[Amazon Redshift でのシークレットの Amazon リソースネーム (ARN) の取得](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-secrets-manager-integration-retrieving-secret.html)」を参照してください。
[URI]
Apache Kafka、Confluent Cloud、または Amazon Managed Streaming for Apache Kafka (Amazon MSK) クラスターのブートストラップ URL。エンドポイントは、Amazon Redshift クラスターから到達可能 (ルーティング可能) である必要があります。詳細については、「[CREATE EXTERNAL SCHEMA](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_SCHEMA.html)」を参照してください。
# ALTER EXTERNAL VIEW
ALTER EXTERNAL VIEW コマンドを使用して外部ビューを更新します。使用するパラメータによっては、このビューを参照できる Amazon Athena や Amazon EMR Spark などの他の SQL エンジンが影響を受ける可能性があります。Data Catalog ビューの詳細については、「[AWS Glue Data Catalog のビュー](https://docs.aws.amazon.com/redshift/latest/dg/data-catalog-views-overview.html)」を参照してください。
## 構文
```
ALTER EXTERNAL VIEW schema_name.view_name
{catalog_name.schema_name.view_name | awsdatacatalog.dbname.view_name | external_schema_name.view_name}
[FORCE] { AS (query_definition) | REMOVE DEFINITION }
```
## パラメータ
*schema\$1name.view\$1name*
AWS Glue データベースにアタッチされているスキーマ。その後にビューの名前が続きます。
catalog\$1name.schema\$1name.view\$1name \$1 awsdatacatalog.dbname.view\$1name \$1 external\$1schema\$1name.view\$1name
ビューを変更するときに使用するスキーマの表記法。AWS Glue Data Catalog、作成した Glue データベース、または作成した外部スキーマを使用するように指定できます。詳細については、「[CREATE DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATABASE.html)」と「[CREATE EXTERNAL SCHEMA](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_SCHEMA.html)」を参照してください。
FORCE
テーブルで参照されているオブジェクトが他の SQL エンジンと矛盾している場合でも、AWS Lake Formation がビューの定義を更新する必要があるかどうか。Lake Formation がビューを更新すると、他の SQL エンジンも更新されるまで、そのビューはそれらの SQL エンジンに対して古いものと見なされます。
*AS query\$1definition*
Amazon Redshift がビューを変更するために実行する SQL クエリの定義。
REMOVE DEFINITION
ビューを削除して再作成するかどうか。`PROTECTED` としてマークするには、ビューを削除して再作成する必要があります。
## 例
次の例では、sample\$1schema.glue\$1data\$1catalog\$1view という名前のデータカタログビューを変更します。
```
ALTER EXTERNAL VIEW sample_schema.glue_data_catalog_view
FORCE
REMOVE DEFINITION
```
# ALTER FUNCTION
関数の名前変更または所有者の変更を行います。関数名とデータタイプの両方が必要です。所有者またはスーパーユーザーのみが関数名を変更できます。スーパーユーザーのみが関数の所有者を変更できます。
## 構文
```
ALTER FUNCTION function_name ( { [ py_arg_name py_arg_data_type | sql_arg_data_type } [ , ... ] ] )
RENAME TO new_name
```
```
ALTER FUNCTION function_name ( { [ py_arg_name py_arg_data_type | sql_arg_data_type } [ , ... ] ] )
OWNER TO { new_owner | CURRENT_USER | SESSION_USER }
```
## パラメータ
*function\$1name*
変更する関数の名前。関数名を現在の検索パスに指定するか、`schema_name.function_name` 形式で特定のスキーマを使用します。
*py\$1arg\$1name py\$1arg\$1data\$1type \$1 sql\$1arg\$1data\$1type*
オプション。Python ユーザー定義関数の入力引数名とデータ型のリスト、または SQL ユーザー定義関数の入力引数データ型のリスト。
*new\$1name*
ユーザー定義関数の新しい名前。
*new\$1owner* \$1 CURRENT\$1USER \$1 SESSION\$1USER
ユーザー定義関数の新しい所有者。
## 例
次の例では、関数の名前を `first_quarter_revenue` から `quarterly_revenue` に変更します。
```
ALTER FUNCTION first_quarter_revenue(bigint, numeric, int)
RENAME TO quarterly_revenue;
```
次の例は、`quarterly_revenue` 関数の所有者を `etl_user` に変更します。
```
ALTER FUNCTION quarterly_revenue(bigint, numeric) OWNER TO etl_user;
```
# ALTER GROUP
ユーザーグループを変更します。ユーザーをグループに追加するか、グループからユーザーを削除するか、グループ名を変更するには、このコマンドを使用します。
## 構文
```
ALTER GROUP group_name
{
ADD USER username [, ... ] |
DROP USER username [, ... ] |
RENAME TO new_name
}
```
## パラメータ
*group\$1name*
変更するユーザーグループの名前。
ADD
ユーザーをユーザーグループに追加します。
DROP
ユーザーグループからユーザーを削除します。
* ユーザー名*
グループに追加するかグループから削除するユーザーの名前。
RENAME TO
ユーザーグループの名前を変更します。2 個のアンダースコアで始まるグループ名は Amazon Redshift 内部で使用するために予約されています。有効な名前の詳細については、「[名前と識別子](r_names.md)」を参照してください。
*new\$1name*
ユーザーグループの新しい名前。
## 例
次の例では、DWUSER という名前のユーザーを ADMIN\$1GROUP グループに追加します。
```
ALTER GROUP admin_group
ADD USER dwuser;
```
次の例では、グループ名を ADMIN\$1GROUP から ADMINISTRATORS に変更します。
```
ALTER GROUP admin_group
RENAME TO administrators;
```
次の例では、ADMIN\$1GROUP グループに 2 人のユーザーを追加します。
```
ALTER GROUP admin_group
ADD USER u1, u2;
```
次の例では、ADMIN\$1GROUP グループから 2 人のユーザーを削除します。
```
ALTER GROUP admin_group
DROP USER u1, u2;
```
# 他の ID プロバイダー
ID プロバイダーを変更して、新しいパラメータと値を割り当てます。このコマンドを実行すると、新しい値が割り当てられる前に、以前に設定したパラメータ値がすべて削除されます。スーパーユーザーのみが ID プロバイダーを変更できます。
## 構文
```
ALTER IDENTITY PROVIDER identity_provider_name
[PARAMETERS parameter_string]
[NAMESPACE namespace]
[IAM_ROLE iam_role]
[AUTO_CREATE_ROLES
[ TRUE [ { INCLUDE | EXCLUDE } GROUPS LIKE filter_pattern] |
FALSE
]
[DISABLE | ENABLE]
```
## パラメータ
*identity\$1provider\$1name*
ID プロバイダーの名前。有効な名前の詳細については、「[名前と識別子](r_names.md)」を参照してください。
*parameter\$1string*
特定の ID プロバイダーに必要なパラメータと値を含む、適切にフォーマットされた JSON オブジェクトを含む文字列。
* 名前空間*
組織の名前空間。
*iam\$1role*
IAM アイデンティティセンターへの接続に対するアクセス許可を提供する IAM ロール。このパラメータは、ID プロバイダーのタイプが AWSIDC である場合にのみ適用されます。
*auto\$1create\$1roles*
ロールの自動作成機能を有効または無効にします。値が TRUE の場合、Amazon Redshift はロールの自動作成機能を有効にします。値が FALSE の場合、Amazon Redshift はロールの自動作成機能を無効にします。このパラメータの値が指定されていない場合、Amazon Redshift は次のロジックを使用して値を決定します。
+ `AUTO_CREATE_ROLES` が指定されていても値が指定されていない場合、値は TRUE に設定されます。
+ `AUTO_CREATE_ROLES` が指定されておらず、ID プロバイダーが AWSIDC の場合、値は FALSE に設定されます。
+ `AUTO_CREATE_ROLES` が指定されておらず、ID プロバイダーが Azure の場合、値は TRUE に設定されます。
グループを含めるには、`INCLUDE` を指定します。デフォルトは空です。つまり、`AUTO_CREATE_ROLES` がオンの場合、すべてのグループが含まれます。
グループを除外するには、`EXCLUDE` を指定します。デフォルトは空です。つまり、`AUTO_CREATE_ROLES` がオンの場合、グループは除外されません。
*filter\$1pattern*
グループ名とマッチングするパターンが含まれる有効な UTF-8 文字式。LIKE オプションでは、以下のパターンマッチングメタ文字をサポートする、大文字と小文字を区別したマッチングを行います。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_ALTER_IDENTITY_PROVIDER.html)
*filter\$1pattern* にメタ文字が含まれていない場合、パターンは文字列そのものを表すだけです。この場合、LIKE は等号演算子と同じ働きをします。
*filter\$1pattern* は、次の文字をサポートしています。
+ 大文字と小文字のアルファベット文字 (A-Z および a-z)
+ 数値 (0-9)
+ 以下の特殊文字。
```
_ % ^ * + ? { } , $
```
*DISABLE または ENABLE*
ID プロバイダーをオンまたはオフにします。デフォルトは ENABLE です。
## 例
次の例では、*oauth\$1standard* という名前の ID プロバイダーを変更します。Microsoft Azure AD が ID プロバイダーである場合に特に適用されます。
```
ALTER IDENTITY PROVIDER oauth_standard
PARAMETERS '{"issuer":"https://sts.windows.net/2sdfdsf-d475-420d-b5ac-667adad7c702/",
"client_id":"87f4aa26-78b7-410e-bf29-57b39929ef9a",
"client_secret":"BUAH~ewrqewrqwerUUY^%tHe1oNZShoiU7",
"audience":["https://analysis.windows.net/powerbi/connector/AmazonRedshift"]
}'
```
次のサンプルは、ID プロバイダー名前空間を設定する方法を示しています。これは、Microsoft Azure AD (前のサンプルのようなステートメントに従う場合)、または別の ID プロバイダーに適用できます。マネージドアプリケーションを介して接続を設定している場合、既存の Amazon Redshift でプロビジョニングされたクラスターまたは Amazon Redshift Serverless ワークグループを IAM アイデンティティセンターに接続する場合にも適用できます。
```
ALTER IDENTITY PROVIDER "my-redshift-idc-application"
NAMESPACE 'MYCO';
```
次の IAM ロールを設定する例は、Redshift と IAM アイデンティティセンターの統合を設定するユースケースで使用できます。
```
ALTER IDENTITY PROVIDER "my-redshift-idc-application"
IAM_ROLE 'arn:aws:iam::123456789012:role/myadministratorrole';
```
Redshift から IAM アイデンティティセンターへの接続の設定の詳細については、[「Redshift を IAM アイデンティティセンターに接続してユーザーにシングルサインオンエクスペリエンスを提供する](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-idp-connect.html)」を参照してください。
**ID プロバイダーの無効化**
次のサンプルステートメントは、ID プロバイダーを無効にする方法を示しています。無効にした場合、再度有効にするまで、ID プロバイダーのフェデレーションユーザーはクラスターにログインできません。
```
ALTER IDENTITY PROVIDER "redshift-idc-app" DISABLE;
```
# ALTER MASKING POLICY
既存の動的データマスキングポリシーを変更します。動的データマスキングの詳細については、「[動的データマスキング](t_ddm.md)」を参照してください。
スーパーユーザーと sys:secadmin ロールを持つユーザーまたはロールは、マスキングポリシーを変更できます。
## 構文
```
ALTER MASKING POLICY
{ policy_name | database_name.policy_name }
USING (masking_expression);
```
## パラメータ
*policy\$1name*
マスキングポリシーの名前。これは、データベースに既に存在するマスキングポリシーの名前でなければなりません。
database\$1name
ポリシーの作成元のデータベースの名前。データベースは、接続されたデータベースでも、Amazon Redshift フェデレーティッドアクセス許可をサポートするデータベースでもかまいません。
*masking\$1expression*
ターゲット列の変換に使用される SQL 式。文字列操作関数などのデータ操作関数を使用して記述することも、SQL、Python、または AWS Lambda で記述されたユーザー定義関数と組み合わせて記述することもできます。
式は、元の式の入力列およびデータ型に一致する必要があります。例えば、元のマスキングポリシーの入力列が `sample_1 FLOAT` と `sample_2 VARCHAR(10)` である場合、3 番目の列を使用するようにマスキングポリシーを変更したり、ポリシーが FLOAT と BOOLEAN を取るようにしたりすることはできません。マスク式として定数を使用する場合は、入力型と一致する型に明示的にキャストする必要があります。
マスキング式で使用するユーザー定義関数には USAGE アクセス許可が必要です。
Amazon Redshift フェデレーティッドアクセス許可カタログでの ALTER MASKING POLICY の使用については、[Amazon Redshift フェデレーティッドアクセス許可によるアクセスコントロールの管理](https://docs.aws.amazon.com/redshift/latest/dg/federated-permissions-managing-access.html)についての記事を参照してください。
# ALTER MATERIALIZED VIEW
マテリアライズドビューの属性を変更します。
## 構文
```
ALTER MATERIALIZED VIEW mv_name
{
AUTO REFRESH { YES | NO }
| ALTER DISTKEY column_name
| ALTER DISTSTYLE ALL
| ALTER DISTSTYLE EVEN
| ALTER DISTSTYLE KEY DISTKEY column_name
| ALTER DISTSTYLE AUTO
| ALTER [COMPOUND] SORTKEY ( column_name [,...] )
| ALTER SORTKEY AUTO
| ALTER SORTKEY NONE
| ROW LEVEL SECURITY { ON | OFF } [ CONJUNCTION TYPE { AND | OR } ] [FOR DATASHARES]
};
```
## パラメータ
*mv\$1name*
変更するマテリアライズドビューの名前。
AUTO REFRESH \$1 YES \$1 NO \$1
マテリアライズドビューの自動更新をオンまたはオフにする句。マテリアライズドビューの自動更新の詳細については、「[マテリアライズドビューの更新](materialized-view-refresh.md)」を参照してください。
ALTER DISTSTYLE ALL
リレーションの既存の分散スタイルを `ALL` に変更する句。以下の点を考慮してください。
+ ALTER DISTSTYLE、ALTER SORTKEY、および VACUUM を同じリレーションに対して同時に実行することはできません。
+ VACUUM を実行中に、ALTER DISTSTYLE ALL を実行すると、エラーが返されます。
+ ALTER DISTSTYLE ALL が実行されている場合は、リレーションに対するバックグラウンドの VACUUM は開始しません。
+ ALTER DISTSTYLE ALL コマンドは、インターリーブソートキーを持つリレーションおよび一時テーブルではサポートされていません。
+ 分散スタイルが以前に AUTO として定義されていた場合、そのリレーションは自動テーブル最適化の候補ではなくなります。
DISTSTYLE ALL の詳細については、「[CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md)」を参照してください。
ALTER DISTSTYLE EVEN
リレーションの既存の分散スタイルを `EVEN` に変更する句。以下の点を考慮してください。
+ ALTER DISTSYTLE、ALTER SORTKEY、および VACUUM を同じリレーションに対して同時に実行することはできません。
+ VACUUM を実行中である場合、ALTER DISTSTYLE EVEN を実行すると、エラーが返されます。
+ ALTER DISTSTYLE EVEN が実行されている場合は、リレーションに対するバックグラウンドの VACUUM は開始しません。
+ ALTER DISTSTYLE EVEN コマンドは、インターリーブソートキーを持つリレーションおよび一時テーブルではサポートされていません。
+ 分散スタイルが以前に AUTO として定義されていた場合、そのリレーションは自動テーブル最適化の候補ではなくなります。
DISTSTYLE EVEN の詳細については、「[CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md)」を参照してください。
ALTER DISTKEY *column\$1name* または ALTER DISTSTYLE KEY DISTKEY *column\$1name*
リレーションの分散キーとして使用される列を変更する句。以下の点を考慮してください。
+ 同じリレーションに対して、VACUUM と ALTER DISTKEY を同時に実行することはできません。
+ VACUUM がすでに実行されている場合は、ALTER DISTKEY よりエラーが返ります。
+ ALTER DISTKEY が実行されている場合は、リレーションに対するバックグラウンドの VACUUM は開始しません。
+ ALTER DISTKEY が実行されている場合は、フォアグラウンドバキュームよりエラーが返ります。
+ ALTER DISTKEY コマンドは、1 つのリレーションに対して一度に 1 回のみ実行できます。
+ ALTER DISTKEY コマンドは、インターリーブソートキーを持つリレーションではサポートされていません。
+ 分散スタイルが以前に AUTO として定義されていた場合、そのリレーションは自動テーブル最適化の候補ではなくなります。
DISTSTYLE KEY を指定する場合、データは、DISTKEY 列の値で分散されます。DISTSTYLE の詳細については、「[CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md)」を参照してください。
ALTER DISTSTYLE AUTO
リレーションの既存の分散スタイルを AUTO に変更する句。
分散スタイルを AUTO に変更すると、リレーションの分散スタイルは次のように設定されます。
+ DISTSTYLE ALL の小さなリレーションは、AUTO(ALL) に変換されます。
+ DISTSTYLE EVEN の小さなリレーションは、AUTO(ALL) に変換されます。
+ DISTSTYLE KEY の小さなリレーションは、AUTO(ALL) に変換されます。
+ DISTSTYLE ALL の大きなリレーションは、AUTO(EVEN) に変換されます。
+ DISTSTYLE EVEN の大きなリレーションは、AUTO(EVEN) に変換されます。
+ DISTSTYLE KEY の大きなリレーションは AUTO(KEY) に変換され、DISTKEY は保持されます。この場合、Amazon Redshift はリレーションに変更を加えません。
Amazon Redshift は、新しい分散スタイルまたはキーでクエリのパフォーマンスが向上すると判断した場合、リレーションの分散スタイルまたはキーを将来的に変更する可能性があります。例えば、DISTSTYLE が AUTO (KEY) のリレーションを AUTO(EVEN) に、またはその逆に変更する場合があります。分散キーが変更されたときの動作 (データの再分散やロックなど) の詳細については、「[Amazon Redshift Advisor のレコメンデーション](https://docs.aws.amazon.com/redshift/latest/dg/advisor-recommendations.html#alter-diststyle-distkey-recommendation)」を参照してください。
DISTSTYLE AUTO の詳細については、「[CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md)」を参照してください。
リレーションの分散スタイルを表示するには、SVV\$1TABLE\$1INFO システムカタログビューをクエリします。詳細については、「[SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md)」を参照してください。リレーションに対する Amazon Redshift Advisor のレコメンデーションを表示するには、SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS システムカタログビューをクエリします。詳細については、「[SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS](r_SVV_ALTER_TABLE_RECOMMENDATIONS.md)」を参照してください。Amazon Redshift が実行したアクションを表示するには、SVL\$1AUTO\$1WORKER\$1ACTION システムカタログビューにクエリを実行します。詳細については、「[SVL\$1AUTO\$1WORKER\$1ACTION](r_SVL_AUTO_WORKER_ACTION.md)」を参照してください。
ALTER [COMPOUND] SORTKEY ( *column\$1name* [,...] )
リレーションで使用されるソートキーを変更または追加する句。ALTER SORTKEY は一時テーブルではサポートされていません。
ソートキーを変更すると、新しいソートキーまたは元のソートキーの列の圧縮エンコードが変更される場合があります。リレーションに対してエンコードが明示的に定義されていない場合、Amazon Redshift は、次のように圧縮エンコードを自動的に割り当てます。
+ ソートキーとして定義されている列には、RAW 圧縮が割り当てられます。
+ BOOLEAN、REAL、または DOUBLE PRECISION データ型として定義されている列には、RAW 圧縮が割り当てられます。
+ SMALLINT、INTEGER、BIGINT、DECIMAL、DATE、TIME、TIMETZ、TIMESTAMP、または TIMESTAMPTZ として定義された列には AZ64 圧縮が割り当てられます。
+ CHAR または VARCHAR として定義された列には、LZO 圧縮が割り当てられます。
以下の点を考慮してください。
+ ソートキーには、リレーションあたり最大 400 列を定義できます。
+ インターリーブソートキーは、複合ソートキーに変更することが可能です。あるいは、ソートキーなしに変更することもできます。ただし、複合ソートキーをインターリーブソートキーに変更することはできません。
+ ソートキーが以前に AUTO として定義されていた場合、そのリレーションは自動テーブル最適化の候補ではなくなります。
+ Amazon Redshift では、ソートキーとして定義された列に RAW エンコード (圧縮なし) を使用することをお勧めします。列を変更してソートキーとして選択すると、列の圧縮が RAW 圧縮 (圧縮なし) に変更されます。これを受けて、リレーションに必要なストレージ量が増加する可能性があります。リレーションのサイズがどれだけ大きくなるかは、特定のリレーション定義とリレーションのコンテンツによって異なります。圧縮の詳細については、「[圧縮エンコード](c_Compression_encodings.md)」を参照してください。
データがリレーションにロードされる際、ソートキーの順序でロードされます。ソートキーが変更されると、Amazon Redshift によってデータの順序が変更されます。SORTKEY の詳細については、「[CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md)」を参照してください。
ALTER SORTKEY AUTO
ターゲットリレーションのソートキーを AUTO に変更または追加する句。ALTER SORTKEY AUTO は一時テーブルではサポートされていません。
ソートキーを AUTO に変更した場合は、そのリレーションの既存のソートキーが維持されます。
Amazon Redshift は、新しいソートキーでクエリのパフォーマンスが向上すると判断した場合、リレーションのソートキーを将来的に変更する可能性があります。
SORTKEY AUTO の詳細については、「[CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md)」を参照してください。
リレーションのソートキーを表示するには、SVV\$1TABLE\$1INFO システムカタログビューをクエリします。詳細については、「[SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md)」を参照してください。リレーションに対する Amazon Redshift Advisor のレコメンデーションを表示するには、SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS システムカタログビューをクエリします。詳細については、「[SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS](r_SVV_ALTER_TABLE_RECOMMENDATIONS.md)」を参照してください。Amazon Redshift が実行したアクションを表示するには、SVL\$1AUTO\$1WORKER\$1ACTION システムカタログビューにクエリを実行します。詳細については、「[SVL\$1AUTO\$1WORKER\$1ACTION](r_SVL_AUTO_WORKER_ACTION.md)」を参照してください。
ALTER SORTKEY NONE
ターゲットリレーションのソートキーを削除する句。
ソートキーが以前に AUTO として定義されていた場合、そのリレーションは自動テーブル最適化の候補ではなくなります。
ROW LEVEL SECURITY \$1 ON \$1 OFF \$1 [ CONJUNCTION TYPE \$1 AND \$1 OR \$1 ] [ FOR DATASHARES ]
リレーションの行レベルのセキュリティをオンまたはオフにする句。
リレーションで行レベルのセキュリティがオンになっている場合、行レベルのセキュリティポリシーでアクセスが許可されている行のみを読み取ることができます。リレーションへのアクセス権を付与するポリシーがない場合は、リレーションから行を表示できません。ROW LEVEL SECURITY 句を設定できるのは、スーパーユーザーと、`sys:secadmin` ロールを持つユーザーまたはロールのみです。詳細については、「[行レベルのセキュリティ](t_rls.md)」を参照してください。
+ [ CONJUNCTION TYPE \$1 AND \$1 OR \$1 ]
リレーションの行レベルのセキュリティポリシーの結合タイプを選択できる句。1 つのリレーションに複数の行レベルのセキュリティポリシーがアタッチされている場合、それらのポリシーを AND 句や OR 句で組み合わせることができます。デフォルトでは、Amazon Redshift は RLS ポリシーを AND 句で組み合わせます。スーパーユーザーと、`sys:secadmin` ロールを持つユーザーまたはロールは、この句を使用して、リレーションの行レベルのセキュリティポリシーの結合タイプを定義できます。詳細については、「[ユーザーごとに複数ポリシーの組み合わせ](t_rls_combine_policies.md)」を参照してください。
+ FOR DATASHARES
RLS で保護されたリレーションにデータ共有上でアクセスできるかどうかを決定する句。デフォルトでは、RLS で保護されたリレーションにデータ共有経由でアクセスすることはできません。この句を指定して実行される ALTER MATERIALIZED VIEW ROW LEVEL SECURITY コマンドは、リレーションのデータ共有アクセシビリティプロパティにのみ影響します。ROW LEVEL SECURITY のプロパティは変更されません。
RLS で保護されたリレーションにデータ共有上でアクセスできるようにした場合、コンシューマー側のデータ共有データベースにおいて、そのリレーションには行レベルのセキュリティが適用されません。リレーションはプロデューサー側の RLS プロパティを保持します。
## 例
次の例では、`tickets_mv` マテリアライズドビューを自動的に更新できます。
```
ALTER MATERIALIZED VIEW tickets_mv AUTO REFRESH YES
```
# ALTER MATERIALIZED VIEW の DISTSTYLE と SORTKEY の例
このトピックの例では、ALTER MATERIALIZED VIEW を使用して DISTSTYLE および SORTKEY の変更を実行する方法を示します。
次のクエリ例は、サンプルベーステーブルを使用して DISTSTYLE KEY DISTKEY 列を変更する方法を示しています。
```
CREATE TABLE base_inventory(
inv_date_sk int4 NOT NULL,
inv_item_sk int4 NOT NULL,
inv_warehouse_sk int4 NOT NULL,
inv_quantity_on_hand int4
);
INSERT INTO base_inventory VALUES(1,1,1,1);
CREATE materialized VIEW inventory diststyle even AS SELECT * FROM base_inventory;
SELECT "table", diststyle FROM svv_table_info WHERE "table" = 'inventory';
ALTER materialized VIEW inventory ALTER diststyle KEY distkey inv_warehouse_sk;
SELECT "table", diststyle FROM svv_table_info WHERE "table" = 'inventory';
ALTER materialized VIEW inventory ALTER distkey inv_item_sk;
SELECT "table", diststyle FROM svv_table_info WHERE "table" = 'inventory';
DROP TABLE base_inventory CASCADE;
```
マテリアライズドビューを DISTSTYLE ALL に変更します。
```
CREATE TABLE base_inventory(
inv_date_sk int4 NOT NULL,
inv_item_sk int4 NOT NULL,
inv_warehouse_sk int4 NOT NULL,
inv_quantity_on_hand int4
);
INSERT INTO base_inventory VALUES(1,1,1,1);
CREATE materialized VIEW inventory diststyle even AS SELECT * FROM base_inventory;
SELECT "table", diststyle FROM svv_table_info WHERE "table" = 'inventory';
ALTER MATERIALIZED VIEW inventory ALTER diststyle ALL;
SELECT "table", diststyle FROM svv_table_info WHERE "table" = 'inventory';
DROP TABLE base_inventory CASCADE;
```
次のコマンドは、サンプルベーステーブルを使用した ALTER MATERIALIZED VIEW SORTKEY の例を示しています。
```
CREATE TABLE base_inventory (c0 int, c1 int);
INSERT INTO base_inventory VALUES(1,1);
CREATE materialized VIEW inventory interleaved sortkey(c0, c1) AS SELECT * FROM base_inventory;
SELECT "table", sortkey1 FROM svv_table_info WHERE "table" = 'inventory';
ALTER materialized VIEW inventory ALTER sortkey(c0, c1);
SELECT "table", diststyle, sortkey_num FROM svv_table_info WHERE "table" = 'inventory';
ALTER materialized VIEW inventory ALTER sortkey NONE;
SELECT "table", diststyle, sortkey_num FROM svv_table_info WHERE "table" = 'inventory';
ALTER materialized VIEW inventory ALTER sortkey(c0);
SELECT "table", diststyle, sortkey_num FROM svv_table_info WHERE "table" = 'inventory';
DROP TABLE base_inventory CASCADE;
```
# RLS ポリシーの変更
テーブル上の既存の行レベルのセキュリティポリシーを変更します。
スーパーユーザーとユーザー、または `sys:secadmin` ロールを持つロールは、ポリシーを変更できます。
## 構文
```
ALTER RLS POLICY
{ policy_name | database_name.policy_name }
USING ( using_predicate_exp );
```
## パラメータ
*policy\$1name*
ポリシーの名前。
database\$1name
ポリシーの作成元のデータベースの名前。データベースは、接続されたデータベースでも、Amazon Redshift フェデレーティッドアクセス許可をサポートするデータベースでもかまいません。
USING (*using\$1predicate\$1exp*)
クエリの WHERE 句に適用されるフィルターを指定します。Amazon Redshift は、クエリレベルのユーザー述語より先にポリシー述語を適用します。例えば、**current\$1user = ‘joe’ and price > 10** は Joe に対して価格が 10 USD を超えるレコードのみを表示するように制限します。
この式は、policy\$1name という名前のポリシーの作成に使用された CREATE RLS POLICY ステートメントの WITH 句で宣言された変数にアクセスできます。
Amazon Redshift フェデレーティッドアクセス許可カタログでの ALTER RLS ポリシーの使用については、[Amazon Redshift フェデレーティッドアクセス許可によるアクセスコントロールの管理](https://docs.aws.amazon.com/redshift/latest/dg/federated-permissions-managing-access.html)についての記事を参照してください。
## 例
次の例では、RLS ポリシーを変更します。
```
-- First create an RLS policy that limits access to rows where catgroup is 'concerts'.
CREATE RLS POLICY policy_concerts
WITH (catgroup VARCHAR(10))
USING (catgroup = 'concerts');
-- Then, alter the RLS policy to only show rows where catgroup is 'piano concerts'.
ALTER RLS POLICY policy_concerts
USING (catgroup = 'piano concerts');
```
# ALTER ROLE
ロールの名前変更または所有者の変更を行います。Amazon Redshift でのシステム定義のロールのリストについては、「[Amazon Redshift でのシステム定義のロール](r_roles-default.md)」を参照してください。
## 必要なアクセス許可
ALTER ROLE に必要なアクセス許可を以下に示します。
+ スーパーユーザー
+ ALTER ROLE アクセス許可を持つユーザー
## 構文
```
ALTER ROLE role [ WITH ]
{ { RENAME TO role } | { OWNER TO user_name } }[, ...]
[ EXTERNALID TO external_id ]
```
## パラメータ
*ロール*
変更するロールの名前。
RENAME TO
ロールの新しい名前。
OWNER TO *user\$1name*
ロールの新しい所有者。
EXTERNALID TO *external\$1id*
ID プロバイダーに関連付けられた、ロールの新しい外部 ID。詳細については、「[Amazon Redshift のネイティブ ID プロバイダー (IdP) フェデレーション](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-native-idp.html)」を参照してください。
## 例
次の例では、ロールの名前を `sample_role1` から `sample_role2` に変更します。
```
ALTER ROLE sample_role1 RENAME TO sample_role2;
```
次の例では、ロールの所有者を変更します。
```
ALTER ROLE sample_role1 WITH OWNER TO user1
```
ALTER ROLE の構文は、次の ALTER PROCEDURE の構文に類似しています。
```
ALTER PROCEDURE first_quarter_revenue(bigint, numeric) RENAME TO quarterly_revenue;
```
次の例では、プロシージャの所有者を `etl_user` に変更します。
```
ALTER PROCEDURE quarterly_revenue(bigint, numeric) OWNER TO etl_user;
```
次の例では、ID プロバイダーに関連付けられている新しい外部 ID を使用してロール `sample_role1` を更新します。
```
ALTER ROLE sample_role1 EXTERNALID TO "XYZ456";
```
# ALTER PROCEDURE
プロシージャ名または所有者を変更します。プロシージャとデータタイプ (署名) の両方が必要です。所有者またはスーパーユーザーのみがプロシージャ名を変更できます。スーパーユーザーのみがプロシージャの所有者を変更できます。
## 構文
```
ALTER PROCEDURE sp_name [ ( [ [ argname ] [ argmode ] argtype [, ...] ] ) ]
RENAME TO new_name
```
```
ALTER PROCEDURE sp_name [ ( [ [ argname ] [ argmode ] argtype [, ...] ] ) ]
OWNER TO { new_owner | CURRENT_USER | SESSION_USER }
```
## パラメータ
*sp\$1name*
変更するプロシージャ名。プロシージャ名のみを現在の検索パスに指定するか、`schema_name.sp_procedure_name`形式で特定のスキーマを使用します。
*[argname] [argmode] argtype*
引数の名前、モード、およびデータタイプのリスト。入力データタイプのみが必須です。これは、ストアドプロシージャの識別に使用されます。または、入力パラメータと出力パラメータをモードと共に含めて、プロシージャを作成するために使用する完全な署名を指定することもできます。
*new\$1name*
ストアドプロシージャの新しい名前。
*new\$1owner* \$1 CURRENT\$1USER \$1 SESSION\$1USER
ストアドプロシージャの新しい所有者。
## 例
次の例では、プロシージャ名を `first_quarter_revenue` から `quarterly_revenue` に変更します。
```
ALTER PROCEDURE first_quarter_revenue(volume INOUT bigint, at_price IN numeric,
result OUT int) RENAME TO quarterly_revenue;
```
この例は以下と同等です。
```
ALTER PROCEDURE first_quarter_revenue(bigint, numeric) RENAME TO quarterly_revenue;
```
次の例では、プロシージャの所有者を `etl_user` に変更します。
```
ALTER PROCEDURE quarterly_revenue(bigint, numeric) OWNER TO etl_user;
```
# ALTER SCHEMA
既存のスキーマの定義を変更します。スキーマ名を変更するかスキーマの所有者を変更するには、このコマンドを使用します。例えば、既存のスキーマの新しいバージョンを作成する予定がある場合、そのスキーマの名前を変更して、そのスキーマのバックアップコピーを保存します。スキーマの詳細については、「[CREATE SCHEMA](r_CREATE_SCHEMA.md)」を参照してください。
構成済みのスキーマクォータを表示するには、「[SVV\$1SCHEMA\$1QUOTA\$1STATE](r_SVV_SCHEMA_QUOTA_STATE.md)」を参照してください。
スキーマクォータを超過したレコードを表示するには、「[STL\$1SCHEMA\$1QUOTA\$1VIOLATIONS](r_STL_SCHEMA_QUOTA_VIOLATIONS.md)」を参照してください。
## 必要な権限
ALTER SCHEMA に必要な権限を以下に示します。
+ スーパーユーザー
+ ALTER SCHEMA 権限を持つユーザー
+ スキーマの所有者
スキーマ名を変更する場合、ストアドプロシージャやマテリアライズドビューなど、古い名前を使用しているオブジェクトは、新しい名前を使用するように更新する必要があることに注意してください。
## 構文
```
ALTER SCHEMA schema_name
{
RENAME TO new_name |
OWNER TO new_owner |
QUOTA { quota [MB | GB | TB] | UNLIMITED }
}
```
## パラメータ
*schema\$1name*
変更するデータベーススキーマの名前。
RENAME TO
スキーマの名前を変更する句。
*new\$1name*
スキーマの新しい名前。有効な名前の詳細については、「[名前と識別子](r_names.md)」を参照してください。
OWNER TO
スキーマの所有者を変更する句。
*new\$1owner*
スキーマの新しい所有者。
QUOTA
指定したスキーマが使用できる最大ディスク容量。この容量は指定したスキーマのすべてのテーブルを合わせたサイズです。Amazon Redshift は選択した値をメガバイトに変換します。値を指定しない場合、デフォルトの測定単位はギガバイトです。
スキーマクォータ設定の詳細については、「[CREATE SCHEMA](r_CREATE_SCHEMA.md)」を参照してください。
## 例
次の例では、スキーマの名前を SALES から US\$1SALES に変更します。
```
alter schema sales
rename to us_sales;
```
次の例では、US\$1SALES スキーマの所有権をユーザー DWUSER に与えます。
```
alter schema us_sales
owner to dwuser;
```
以下の例では、クォータを 300 GB に変更し、クォータを削除します。
```
alter schema us_sales QUOTA 300 GB;
alter schema us_sales QUOTA UNLIMITED;
```
# ALTER SYSTEM
Amazon Redshift クラスターまたは Redshift Serverless ワークグループのシステムレベルの設定オプションを変更します。
## 必要な権限
次のいずれかのユーザータイプで ALTER SYSTEM コマンドを実行できます。
+ スーパーユーザー
+ 管理者ユーザー
## 構文
```
ALTER SYSTEM SET system-level-configuration = {true| t | on | false | f | off}
```
## パラメータ
*system-level-configuration*
システムレベルの設定。有効な値: `data_catalog_auto_mount` および `metadata_security`。
\$1true\$1 t \$1 on \$1 false \$1 f \$1 off\$1
システムレベルの設定を有効または無効にする値。`true`、`t`、または `on` は、設定を有効にすることを示します。`false`、`f`、または `off` は、設定を無効にすることを示します。
## 使用に関する注意事項
プロビジョニングされたクラスターの場合、`data_catalog_auto_mount` への変更はクラスターの次回の再起動時に有効になります。詳細については、「Amazon Redshift 管理ガイド」の「[クラスターの再起動](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-clusters-console.html#reboot-cluster)」を参照してください。**
サーバーレスワークグループでは、`data_catalog_auto_mount` への変更はすぐには有効になりません。
## 例
次の例では、AWS Glue Data Catalog の自動マウントを有効にします。
```
ALTER SYSTEM SET data_catalog_auto_mount = true;
```
次の例では、メタデータのセキュリティを有効にします。
```
ALTER SYSTEM SET metadata_security = true;
```
### デフォルトの ID 名前空間の設定
この例は ID プロバイダー専用です。Redshift を IAM アイデンティティセンターおよび ID プロバイダーと統合して、Redshift および AWS の他のサービスの ID 管理を一元化できます。
次のサンプルは、システムのデフォルトの ID 名前空間を設定する方法を示しています。これにより、各 ID のプレフィックスとして名前空間を含める必要がなくなるため、GRANT ステートメントと CREATE ステートメントの実行がより簡単になります。
```
ALTER SYSTEM SET default_identity_namespace = 'MYCO';
```
コマンドを実行したら、次のようなステートメントを実行できます。
```
GRANT SELECT ON TABLE mytable TO alice;
GRANT UPDATE ON TABLE mytable TO salesrole;
CREATE USER bob password 'md50c983d1a624280812631c5389e60d48c';
```
デフォルトの ID 名前空間を設定すると、ID ごとに名前空間をプレフィックスとして指定する必要がなくなります。この例では、`alice` が `MYCO:alice` に置き換えられます。これは、含まれているすべての ID で発生します。Redshift での ID プロバイダーの使用の詳細については、「[Redshift を IAM アイデンティティセンターに接続してユーザーにシングルサインオンエクスペリエンスを提供する](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-idp-connect.html)」を参照してください。
IAM アイデンティティセンターでの Redshift 構成に関連する設定の詳細については、「[SET](r_SET.md)」および「[他の ID プロバイダー](r_ALTER_IDENTITY_PROVIDER.md)」を参照してください。
# ALTER TABLE
このコマンドは、Amazon Redshift テーブルまたは Amazon Redshift Spectrum 外部テーブルの定義を変更します。このコマンドは、[CREATE TABLE](r_CREATE_TABLE_NEW.md) または [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md) によって設定された値とプロパティを更新します。ALTER TABLE は、行レベルセキュリティ (RLS) のビューで使用できます。
トランザクションブロック (BEGIN ... END) 内の外部テーブルに対して ALTER TABLE を実行することはできません。トランザクションの詳細については、「[Amazon Redshift の分離レベル](c_serial_isolation.md)」を参照してください。
ALTER TABLE は、ALTER TABLE オペレーションを囲むトランザクションが完了するまで、テーブルの読み取りと書き込みのオペレーションをロックします。ただし、データに対するクエリの実行や、変更中のテーブルに対して他の処理の実行が可能であるとドキュメントに明記されている場合を除きます。
## 必要な権限
テーブルを変更するユーザーがコマンドを正常に実行するには、適切な権限が必要です。ALTER TABLE コマンドによっては、次のいずれかの権限が必要です。
+ スーパーユーザー
+ ALTER TABLE の権限を持つユーザー
+ スキーマに対する USAGE 権限を持つテーブル所有者
## 構文
```
ALTER TABLE table_name
{
ADD table_constraint
| DROP CONSTRAINT constraint_name [ RESTRICT | CASCADE ]
| OWNER TO new_owner
| RENAME TO new_name
| RENAME COLUMN column_name TO new_name
| ALTER COLUMN column_name TYPE updated_varchar_data_type_size
| ALTER COLUMN column_name ENCODE new_encode_type
| ALTER COLUMN column_name ENCODE encode_type,
| ALTER COLUMN column_name ENCODE encode_type, .....;
| ALTER DISTKEY column_name
| ALTER DISTSTYLE ALL
| ALTER DISTSTYLE EVEN
| ALTER DISTSTYLE KEY DISTKEY column_name
| ALTER DISTSTYLE AUTO
| ALTER [COMPOUND] SORTKEY ( column_name [,...] )
| ALTER SORTKEY AUTO
| ALTER SORTKEY NONE
| ALTER ENCODE AUTO
| ADD [ COLUMN ] column_name column_type
[ DEFAULT default_expr ]
[ ENCODE encoding ]
[ NOT NULL | NULL ]
[ COLLATE { CASE_SENSITIVE | CS | CASE_INSENSITIVE | CI } ] |
| DROP [ COLUMN ] column_name [ RESTRICT | CASCADE ]
| ROW LEVEL SECURITY { ON | OFF } [ CONJUNCTION TYPE { AND | OR } ] [ FOR DATASHARES ]
| MASKING { ON | OFF } FOR DATASHARES }
where table_constraint is:
[ CONSTRAINT constraint_name ]
{ UNIQUE ( column_name [, ... ] )
| PRIMARY KEY ( column_name [, ... ] )
| FOREIGN KEY (column_name [, ... ] )
REFERENCES reftable [ ( refcolumn ) ]}
The following options apply only to external tables:
SET LOCATION { 's3://bucket/folder/' | 's3://bucket/manifest_file' }
| SET FILE FORMAT format |
| SET TABLE PROPERTIES ('property_name'='property_value')
| PARTITION ( partition_column=partition_value [, ...] )
SET LOCATION { 's3://bucket/folder' |'s3://bucket/manifest_file' }
| ADD [IF NOT EXISTS]
PARTITION ( partition_column=partition_value [, ...] ) LOCATION { 's3://bucket/folder' |'s3://bucket/manifest_file' }
[, ... ]
| DROP PARTITION ( partition_column=partition_value [, ...] )
```
ALTER TABLE コマンドの実行時間を短縮するために、ALTER TABLE コマンドの一部の句を組み合わせることができます。
Amazon Redshift では、ALTER TABLE の句の次の組み合わせがサポートされています。
```
ALTER TABLE tablename ALTER SORTKEY (column_list), ALTER DISTKEY column_Id;
ALTER TABLE tablename ALTER DISTKEY column_Id, ALTER SORTKEY (column_list);
ALTER TABLE tablename ALTER SORTKEY (column_list), ALTER DISTSTYLE ALL;
ALTER TABLE tablename ALTER DISTSTYLE ALL, ALTER SORTKEY (column_list);
```
## パラメータ
*table\$1name*
変更するテーブルの名前 テーブル名のみを指定するか、*schema\$1name.table\$1name* 形式で特定のスキーマを使用します。外部テーブルは、外部スキーマの名前によって修飾される必要があります。また、ALTER TABLE ステートメントを使用してビュー名かビューの所有者を変更する場合、ビュー名を指定することもできます。テーブル名の最大長は 127 バイトです。それより長い名前は 127 バイトまで切り詰められます。最大 4 バイトまで UTF-8 マルチバイト文字を使用できます。有効な名前の詳細については、「[名前と識別子](r_names.md)」を参照してください。
ADD *table\$1constraint*
指定した制約をテーブルに追加する句。有効な *table\$1constraint* 値については、「[CREATE TABLE](r_CREATE_TABLE_NEW.md)」を参照してください。
プライマリキー制約を null が許容された列に追加することはできません。列が元々 NOT NULL 制約で作成された場合、プライマリキー制約を追加できます。
DROP CONSTRAINT *constraint\$1name*
テーブルから指名された制約を削除する句。制約を削除するには、制約タイプではなく制約の名前を指定します。テーブルの制約名を表示するには、次のクエリを実行します。
```
select constraint_name, constraint_type
from information_schema.table_constraints;
```
RESTRICT
指定の制約のみを削除する句。RESTRICT は DROP CONSTRAINT のオプションです。RESTRICT を CASCADE と併用することはできません。
CASCADE
指定の制約と同制約に依存するすべてを削除する句。CASCADE は DROP CONSTRAINT のオプションです。CASCADE を RESTRICT と併用することはできません。
OWNER TO *new\$1owner*
テーブル (またはビュー) の所有者を *new\$1owner* 値に変更する句。
RENAME TO *new\$1name*
テーブル (またはビュー) の名前を *new\$1name* で指定された値に変更する句。テーブル名の最大長は 127 バイトです。それより長い名前は 127 文字まで切り詰められます。
永続テーブルの名前を「\$1」で始まる名前に変更することはできません。「\$1」で始まるテーブル名は、一時テーブルを示します。
外部テーブル名を変更することはできません。
ALTER COLUMN *column\$1name* TYPE *updated\$1varchar\$1data\$1type\$1size*
VARCHAR データ型と定義されている列のサイズを変更する句。この句は VARCHAR データ型のサイズの変更のみをサポートします。次の制限事項を考慮してください。
+ 圧縮エンコード (BYTEDICT、RUNLENGTH、TEXT255、TEXT32K) で列を変更することはできません。
+ 既存データの最大サイズよりサイズを小さくすることはできません。
+ デフォルト値を含む列は変更できません。
+ UNIQUE、PRIMARY KEY、または FOREIGN KEY を含む列は変更できません。
+ トランザクションブロック (BEGIN ... END) 内の列を変更することはできません。トランザクションの詳細については、「[Amazon Redshift の分離レベル](c_serial_isolation.md)」を参照してください。
ALTER COLUMN *column\$1name* ENCODE *new\$1encode\$1type*
列の圧縮エンコードを変更する句。列に圧縮エンコードを指定すると、テーブルは ENCODE AUTO に設定されなくなります。圧縮エンコードに関する詳細は、「[保存データのサイズを削減するための列圧縮](t_Compressing_data_on_disk.md)」を参照してください。
列のための圧縮エンコードを変更した後も、テーブルに対しクエリを実行することが可能です。
次の制限事項を考慮してください。
+ 列を現在その列に定義されているものと同じエンコードに変更することはできません。
+ インターリーブされたソートキーを使用して、テーブルの列のエンコードを変更することはできません。
ALTER COLUMN *column\$1name* ENCODE *encode\$1type*, ALTER COLUMN *column\$1name* ENCODE *encode\$1type*, .....;
複数の列で、圧縮エンコードを単一のコマンドにより変更するための句。圧縮エンコードに関する詳細は、「[保存データのサイズを削減するための列圧縮](t_Compressing_data_on_disk.md)」を参照してください。
列のための圧縮エンコードを変更した後も、テーブルに対しクエリを実行することが可能です。
次の制限事項を検討してください。
+ 1 つのコマンドで、列のエンコーディングを複数回にわたり、同じまたは異なるタイプに変更することはできません。
+ 列を現在その列に定義されているものと同じエンコードに変更することはできません。
+ インターリーブされたソートキーを使用して、テーブルの列のエンコードを変更することはできません。
ALTER DISTSTYLE ALL
テーブルの既存のディストリビューションスタイルを `ALL` に変更する句。以下の点を考慮します。
+ ALTER DISTSTYLE、ALTER SORTKEY、およびVACUUM は、同じテーブルで同時に実行することはできません。
+ VACUUM を実行中に、ALTER DISTSTYLE ALL を実行すると、エラーが返されます。
+ ALTER DISTKEY が実行されている場合は、テーブルでバックグラウンドバキュームは開始されません。
+ ALTER DISTSTYLE ALL コマンドは、インターリーブソートキーおよび一時テーブルを持つテーブルではサポートされません。
+ ディストリビューションスタイルが以前に AUTO として定義されていた場合、テーブルは自動テーブル最適化の候補ではなくなります。
DISTSTYLE ALL の詳細については、「[CREATE TABLE](r_CREATE_TABLE_NEW.md)」を参照してください。
ALTER DISTSTYLE EVEN
テーブルの既存のディストリビューションスタイルを `EVEN` に変更する句。以下の点を考慮します。
+ ALTER DISTSYTLE、ALTER SORTKEY、およびVACUUM は、同じテーブルで同時に実行することはできません。
+ VACUUM を実行中である場合、ALTER DISTSTYLE EVEN を実行すると、エラーが返されます。
+ ALTER DISTKEY EVEN が実行中である場合、テーブルでバックグラウンドバキュームは開始されません。
+ ALTER DISTSTYLE EVEN コマンドは、インターリーブされたソートキーを持つテーブルや一時テーブルではサポートされません。
+ ディストリビューションスタイルが以前に AUTO として定義されていた場合、テーブルは自動テーブル最適化の候補ではなくなります。
DISTSTYLE EVEN の詳細については、「[CREATE TABLE](r_CREATE_TABLE_NEW.md)」を参照してください。
ALTER DISTKEY *column\$1name* または ALTER DISTSTYLE KEY DISTKEY *column\$1name*
テーブルの分散キーとして使用される列を変更する句。以下の点を考慮します。
+ 同じテーブルで、VACUUM と ALTER DISTKEY を同時に実行することはできません。
+ VACUUM がすでに実行されている場合は、ALTER DISTKEY よりエラーが返ります。
+ ALTER DISTKEY が実行されている場合は、テーブルでバックグラウンドバキュームは開始されません。
+ ALTER DISTKEY が実行されている場合は、フォアグラウンドバキュームよりエラーが返ります。
+ ALTER DISTKEY コマンドは、1 つのテーブルに対して一度に 1 回のみ実行することができます。
+ インターリーブソートキーを使用するテーブルについては、ALTER DISTKEY コマンドはサポートされていません。
+ ディストリビューションスタイルが以前に AUTO として定義されていた場合、テーブルは自動テーブル最適化の候補ではなくなります。
DISTSTYLE KEY を指定する場合、データは、DISTKEY 列の値で分散されます。DISTSTYLE の詳細については、「[CREATE TABLE](r_CREATE_TABLE_NEW.md)」を参照してください。
ALTER DISTSTYLE AUTO
テーブルの既存のディストリビューションスタイルを AUTO に変更する句。
ディストリビューションスタイルを AUTO に変更すると、テーブルのディストリビューションスタイルは次のように設定されます。
+ DISTSTYLE ALL を持つ小さなテーブルは、AUTO(ALL) に変換されます。
+ DISTSTYLE EVEN を持つ小さなテーブルは、AUTO(ALL) に変換されます。
+ DISTSTYLE KEY を持つ小さなテーブルは、AUTO(ALL) に変換されます。
+ DISTSTYLE ALL を持つ大きなテーブルは、AUTO(EVEN) に変換されます。
+ DISTSTYLE EVEN を持つ大きなテーブルは、AUTO(EVEN) に変換されます。
+ DISTSTYLE KEY を持つ大きなテーブルは、AUTO(KEY) に変換され、DISTKEY は保持されます。この場合、Amazon Redshift はテーブルに変更を加えません。
Amazon Redshift が、新しいディストリビューションスタイルまたはキーによってクエリのパフォーマンスが向上すると判断した場合、Amazon Redshift は、将来、テーブルのディストリビューションスタイルまたはキーを変更する可能性があります。例えば、Amazon Redshift は、DISTSTYLE が AUTO (KEY) のテーブルを AUTO(EVEN) に、またはその逆に変更する場合があります。データの再配布やロックなど、配布キーが変更されたときの動作の詳細については、「[Amazon Redshift Advisor の推奨事項](https://docs.aws.amazon.com/redshift/latest/dg/advisor-recommendations.html#alter-diststyle-distkey-recommendation)」を参照してください。
DISTSTYLE AUTO の詳細については、「[CREATE TABLE](r_CREATE_TABLE_NEW.md)」を参照してください。
テーブルのディストリビューションスタイルを表示するには、SVV\$1TABLE\$1INFO システムカタログビューに対してクエリを実行します。詳細については、「[SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md)」を参照してください。テーブルの Amazon Redshift Advisor のレコメンデーションを表示するには、SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS システムカタログビューをクエリします。詳細については、「[SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS](r_SVV_ALTER_TABLE_RECOMMENDATIONS.md)」を参照してください。Amazon Redshift が実行したアクションを表示するには、SVL\$1AUTO\$1WORKER\$1ACTION システムカタログビューにクエリを実行します。詳細については、「[SVL\$1AUTO\$1WORKER\$1ACTION](r_SVL_AUTO_WORKER_ACTION.md)」を参照してください。
ALTER [COMPOUND] SORTKEY ( *column\$1name* [,...] )
テーブルで使用されるソートキーを変更または追加する句。ALTER SORTKEY は一時テーブルではサポートされていません。
ソートキーを変更すると、新しいソートキーまたは元のソートキーの列の圧縮エンコードが変更される場合があります。テーブルにエンコードが明示的に定義されていない場合、Amazon Redshift は、次のように圧縮エンコードを自動的に割り当てます。
+ ソートキーとして定義されている列には、RAW 圧縮が割り当てられます。
+ BOOLEAN、REAL、または DOUBLE PRECISION データ型として定義されている列には、RAW 圧縮が割り当てられます。
+ SMALLINT、INTEGER、BIGINT、DECIMAL、DATE、TIME、TIMETZ、TIMESTAMP、または TIMESTAMPTZ として定義された列には AZ64 圧縮が割り当てられます。
+ CHAR または VARCHAR として定義された列には、LZO 圧縮が割り当てられます。
以下の点を考慮します。
+ テーブルあたりのソートキーには最大 400 列を定義できます。
+ インターリーブソートキーは、複合ソートキーに変更することが可能です。あるいは、ソートキーなしに変更することもできます。ただし、複合ソートキーをインターリーブソートキーに変更することはできません。
+ ソートキーが以前に AUTO として定義されていた場合、テーブルは自動テーブル最適化の候補ではなくなります。
+ Amazon Redshift では、ソートキーとして定義された列に RAW エンコード (圧縮なし) を使用することをお勧めします。列を変更してソートキーとして選択すると、列の圧縮が RAW 圧縮 (圧縮なし) に変更されます。これにより、テーブルに必要なストレージ量が増加する可能性があります。テーブルのサイズがどれだけ増加するかは、特定のテーブル定義とテーブルの内容によって異なります。圧縮の詳細については、「[圧縮エンコード](c_Compression_encodings.md)」を参照してください。
データがテーブルに読み込まれる際、データはソートキーの順序で読み込まれます。ソートキーが変更されると、Amazon Redshift によってデータの順序が変更されます。SORTKEY の詳細については、「[CREATE TABLE](r_CREATE_TABLE_NEW.md)」を参照してください。
ALTER SORTKEY AUTO
ターゲットテーブルのソートキーを AUTO に変更または追加する句。ALTER SORTKEY AUTO は一時テーブルではサポートされていません。
ソートキーを AUTO に変更すると、Amazon Redshift はテーブルの既存のソートキーを保持します。
Amazon Redshift が新しいソートキーによってクエリのパフォーマンスが向上すると判断した場合、Amazon Redshift は今後、テーブルのソートキーを変更する可能性があります。
SORTKEY AUTO の詳細については、「[CREATE TABLE](r_CREATE_TABLE_NEW.md)」を参照してください。
テーブルのソートキーを表示するには、SVV\$1TABLE\$1INFO システムカタログビューに対してクエリを実行します。詳細については、「[SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md)」を参照してください。テーブルの Amazon Redshift Advisor のレコメンデーションを表示するには、SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS システムカタログビューをクエリします。詳細については、「[SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS](r_SVV_ALTER_TABLE_RECOMMENDATIONS.md)」を参照してください。Amazon Redshift が実行したアクションを表示するには、SVL\$1AUTO\$1WORKER\$1ACTION システムカタログビューにクエリを実行します。詳細については、「[SVL\$1AUTO\$1WORKER\$1ACTION](r_SVL_AUTO_WORKER_ACTION.md)」を参照してください。
ALTER SORTKEY NONE
ターゲットテーブルのソートキーを削除する句。
ソートキーが以前に AUTO として定義されていた場合、テーブルは自動テーブル最適化の候補ではなくなります。
ALTER ENCODE AUTO
ターゲットテーブルの列のエンコードタイプを AUTO に変更する句。エンコードを AUTO に変更すると、Amazon Redshift はテーブル内の列の既存のエンコードタイプを保持します。その後、Amazon Redshift が新しいエンコードタイプによってクエリのパフォーマンスが向上すると判断した場合、Amazon Redshift はテーブル列のエンコードタイプを変更できます。
1 つ以上の列を変更してエンコードを指定した場合、Amazon Redshift はテーブル内のすべての列のエンコードを自動的に調整しなくなりました。列は現在のエンコード設定を保持します。
次のアクションは、テーブルの ENCODE AUTO 設定には影響しません。
+ テーブルの名前を変更します。
+ テーブルの DISTSTYLE または SORTKEY 設定を変更します。
+ ENCODE 設定で列を追加または削除します。
+ COPY コマンドの COMPUPDATE オプションを使用します。詳細については、「[データのロード操作](copy-parameters-data-load.md)」を参照してください。
テーブルのエンコードを表示するには、SVV\$1TABLE\$1INFO システムカタログビューにクエリを実行します。詳細については、「[SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md)」を参照してください。
RENAME COLUMN *column\$1name* TO *new\$1name*
列の名前を *new\$1name* で指定された値に変更する句。列名の最大長は 127 バイトです。それより長い名前は 127 文字まで切り詰められます。有効な名前の詳細については、「[名前と識別子](r_names.md)」を参照してください。
ADD [ COLUMN ] *column\$1name*
指定した名前を持つ列をテーブルに追加する句。各 ALTER TABLE ステートメントでは 1 列しか追加できません。
テーブルの分散キー (DISTKEY) またはソートキー (SORTKEY) である列は追加できません。
ALTER TABLE ADD COLUMN コマンドを使用して次のテーブルと列の属性を変更することはできません。
+ UNIQUE
+ PRIMARY KEY
+ REFERENCES (外部キー)
+ IDENTITY または GENERATED BY DEFAULT AS IDENTITY
列名の最大長は 127 バイトです。それより長い名前は 127 文字まで切り詰められます。1 つのテーブルで定義できる列の最大数は 1,600 です。
外部テーブルに列を追加する場合、次の制限が適用されます。
+ DEFAULT、ENCODE、NOT NULL または NULL を制約する列がある外部テーブルに列を追加することはできません。
+ AVRO ファイル形式を使用して定義した外部テーブルに列を追加することはできません。
+ 擬似列が有効になっている場合、1 つの外部テーブルで定義できる列の最大数は 1,598 です。擬似列が有効でない場合、1 つのテーブルで定義できる列の最大数は 1,600 です。
詳細については、「[CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md)」を参照してください。
*column\$1type*
追加する列のデータ型。CHAR および VARCHAR の列の場合、最大長を宣言する代わりに MAX キーワードを使用できます。MAX は、最大長を CHAR では 4096 バイト、VARCHAR では 65535 バイトに設定します。GEOMETRY オブジェクトの最大サイズは 1,048,447 バイトです。
Amazon Redshift でサポートされているデータ型の詳細については、「[データ型](c_Supported_data_types.md)」を参照してください。
DEFAULT *default\$1expr*
列のデフォルトのデータ値を割り当てる句。*default\$1expr* のデータ型は列のデータ型に一致する必要があります。DEFAULT 値は、変数を使用しない式にする必要があります。サブクエリ、現在のテーブルに含まれる他の列の相互参照、およびユーザー定義の関数は使用できません。
*default\$1expr* は、列の値を指定しないすべての INSERT 操作で使用されます。デフォルト値を指定しなかった場合、列のデフォルト値は null です。
COPY 操作により、DEFAULT 値と NOT NULL 制約が設定された列で null フィールドが見つかった場合、COPY コマンドは *default\$1expr* の値を挿入します。
DEFAULT は外部テーブルでサポートされていません。
ENCODE *encoding*
列の圧縮エンコード。デフォルトでは、テーブル内のどの列にも圧縮エンコードを指定しない場合、またはテーブルに ENCODE AUTO オプションを指定した場合、Amazon Redshift はテーブル内のすべての列の圧縮エンコードを自動的に管理します。
テーブルで任意の列に圧縮エンコードを指定する場合、またはテーブルに ENCODE AUTO オプションを指定しない場合、Amazon Redshift は次のように圧縮エンコードを指定しない列に圧縮エンコードを自動的に割り当てます。
+ 一時テーブルのすべての列には RAW 圧縮がデフォルトで割り当てられます。
+ ソートキーとして定義されている列には、RAW 圧縮が割り当てられます。
+ BOOLEAN、REAL、DOUBLE PRECISION、GEOMETRY、もしくは GEOGRAPHY の各データ型で定義されている列には、RAW 圧縮が割り当てられます。
+ SMALLINT、INTEGER、BIGINT、DECIMAL、DATE、TIME、TIMETZ、TIMESTAMP、または TIMESTAMPTZ として定義された列には AZ64 圧縮が割り当てられます。
+ CHAR、VARCHAR、または VARBYTE として定義されている列には、LZO 圧縮が割り当てられます。
列を圧縮しない場合は、明示的に RAW エンコードを指定します。
次の [compression encodings](c_Compression_encodings.md#compression-encoding-list) がサポートされています。
+ AZ64
+ BYTEDICT
+ DELTA
+ DELTA32K
+ LZO
+ MOSTLY8
+ MOSTLY16
+ MOSTLY32
+ RAW (非圧縮)
+ RUNLENGTH
+ TEXT255
+ TEXT32K
+ ZSTD
ENCODE は外部テーブルでサポートされていません。
NOT NULL \$1 NULL
NOT NULL は、列に null 値を使用できないことを指定します。NULL はデフォルトであり、列で null 値を使用できることを指定します。
NOT NULL と NULL は外部テーブルでサポートされていません。
COLLATE \$1 CASE\$1SENSITIVE \$1 CS \$1 CASE\$1INSENSITIVE \$1 CI \$1
列での文字列の検索または比較において、大文字と小文字を区別するか、区別しないかを指定する句。デフォルト値は、大文字と小文字を区別する、現行のデータベースの設定と同じです。
データベース照合に関する情報を検索するには、次のコマンドを使用します。
```
SELECT db_collation();
db_collation
----------------
case_sensitive
(1 row)
```
CASE\$1SENSITIVE と CS は互換性があり、同じ結果が得られます。同様に、CASE\$1INSENSITIVE と CI は互換性があり、同じ結果が得られます。
DROP [ COLUMN ] *column\$1name*
テーブルから削除する列の名前。
テーブルの末尾列は削除できません。テーブルには少なくとも 1 つの列が必要です。
テーブルの分散キー (DISTKEY) またはソートキー (SORTKEY) である列は削除できません。ビュー、プライマリキー、外部キー、UNIQUE 制約などの依存オブジェクトが列にある場合、DROP COLUMN のデフォルト動作は RESTRICT です。
外部テーブルから列を削除する場合は、次の制限が適用されます。
+ 列をパーティションとして使用している場合、外部テーブルから列を削除することはできません。
+ AVRO ファイル形式を使用して定義した外部テーブルから列を削除することはできません。
+ RESTRICT と CASCADE は外部テーブルに無視されます。
+ ポリシーを削除するかデタッチしない限り、ポリシー定義内で参照されるポリシーテーブルの列を削除することはできません。これは、CASCADE オプションが指定されている場合にも当てはまります。ポリシーテーブル内の他の列を削除できます。
詳細については、「[CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md)」を参照してください。
RESTRICT
RESTRICT を DROP COLUMN とともに使用すると、以下の場合に、ドロップされる列がドロップされません。
+ 定義されたビューがドロップされる列を参照している場合
+ 外部キーが列を参照している場合
+ 列がマルチパートキーに属している場合
RESTRICT を CASCADE と併用することはできません。
RESTRICT と CASCADE は外部テーブルに無視されます。
CASCADE
DROP COLUMN と共に使用すると、指定した列およびその列に依存するすべてのものを削除します。CASCADE を RESTRICT と併用することはできません。
RESTRICT と CASCADE は外部テーブルに無視されます。
以下のオプションは、外部テーブルにのみ適用されます。
SET LOCATION \$1 's3://*bucket/folder*/' \$1 's3://*bucket/manifest\$1file*' \$1
データファイルを含む Amazon S3 フォルダ、または Amazon S3 オブジェクトパスのリストを含むマニフェストファイルへのパス。バケットは、Amazon Redshift クラスターと同じ AWS リージョン内に置かれている必要があります。サポートされている AWS リージョンの一覧は、「[Amazon Redshift Spectrum の制限事項](c-spectrum-considerations.md)」でご確認ください。マニフェストファイルの使用に関する詳細は、CREATE EXTERNAL TABLE [パラメータ](r_CREATE_EXTERNAL_TABLE.md#r_CREATE_EXTERNAL_TABLE-parameters) リファレンスの LOCATION を参照してください。
SET FILE FORMAT *format*
外部データファイルのファイル形式。
有効な形式は次のとおりです。
+ AVRO
+ PARQUET
+ RCFILE
+ SEQUENCEFILE
+ TEXTFILE
SET TABLE PROPERTIES ( '*property\$1name*'='*property\$1value*')
外部テーブルのテーブルプロパティのテーブル定義を設定する句。
テーブルのプロパティでは、大文字と小文字が区別されます。
'numRows'='*row\$1count*'
テーブル定義の numRows 値を設定するプロパティ。外部テーブルの統計を明示的に更新するには、テーブルのサイズを示す numRows プロパティを設定します。Amazon Redshift は、外部テーブルを分析して、クエリオプティマイザがクエリプランを生成するために使用するテーブル統計を生成することはありません。外部テーブルに対してテーブル統計が設定されていない場合、Amazon Redshift はクエリ実行プランを生成します。このプランは、外部テーブルの方が大きくローカルテーブルの方が小さいという前提に基づきます。
'skip.header.line.count'='*line\$1count*'
各ソースファイルの最初に省略する行数を設定するプロパティ。
PARTITION ( *partition\$1column*=*partition\$1value* [, ...] SET LOCATION \$1 's3://*bucket*/*folder*' \$1 's3://*bucket*/*manifest\$1file*' \$1
1 つ以上のパーティション列の新しい場所を設定する句。
ADD [ IF NOT EXISTS ] PARTITION ( *partition\$1column*=*partition\$1value* [, ...] ) LOCATION \$1 's3://*bucket*/*folder*' \$1 's3://*bucket*/*manifest\$1file*' \$1 [, ... ]
1 つ以上のパーティションを追加する句。複数の PARTITION 句を指定するには、単一の ALTER TABLE … ADD ステートメントを使用します。
AWS Glue を使用する場合、単一の ALTER TABLE ステートメントを使用して、最大 100 パーティションまで追加できます。
IF NOT EXISTS 句は、指定されたパーティションが既に存在する場合はコマンドが変更を加えないことを示します。また、コマンドが、エラーで終了するのではなく、パーティションが存在することを示すメッセージを返すことも示します。この句は、ALTER TABLE で既存のパーティションを追加しようとしてもスクリプトが失敗しないため、スクリプトを作成する際に便利です。
DROP PARTITION (*partition\$1column*=*partition\$1value* [, ...] )
指定のパーティションを削除する句。パーティションを削除すると、外部テーブルのメタデータのみが変化します。Amazon S3 のデータは影響を受けません。
ROW LEVEL SECURITY \$1 ON \$1 OFF \$1 [ CONJUNCTION TYPE \$1 AND \$1 OR \$1 ] [ FOR DATASHARES ]
リレーションの行レベルのセキュリティをオンまたはオフにする句。
リレーションで行レベルのセキュリティがオンになっている場合、行レベルのセキュリティポリシーでアクセスが許可されている行のみを読み取ることができます。リレーションへのアクセス権を付与するポリシーがない場合は、リレーションから行を表示できません。ROW LEVEL SECURITY 句を設定できるのは、スーパーユーザーと、`sys:secadmin` ロールを持つユーザーまたはロールのみです。詳細については、「[行レベルのセキュリティ](t_rls.md)」を参照してください。このステートメントは、接続されたデータベース、または Amazon Redshift フェデレーティッドアクセス許可を持つデータベースでサポートされています。FOR DATASHARES 句は、Amazon Redshift フェデレーティッドアクセス許可を持つデータベースではサポートされていません。
+ [ CONJUNCTION TYPE \$1 AND \$1 OR \$1 ]
リレーションの行レベルのセキュリティポリシーの結合タイプを選択できる句。1 つのリレーションに複数の行レベルのセキュリティポリシーがアタッチされている場合、それらのポリシーを AND 句や OR 句で組み合わせることができます。デフォルトでは、Amazon Redshift は RLS ポリシーを AND 句で組み合わせます。スーパーユーザーと、`sys:secadmin` ロールを持つユーザーまたはロールは、この句を使用して、リレーションの行レベルのセキュリティポリシーの結合タイプを定義できます。詳細については、「[ユーザーごとに複数ポリシーの組み合わせ](t_rls_combine_policies.md)」を参照してください。
+ FOR DATASHARES
RLS で保護されたリレーションにデータ共有上でアクセスできるかどうかを決定する句。デフォルトでは、RLS で保護されたリレーションにデータ共有経由でアクセスすることはできません。この句を指定して実行される ALTER TABLE ROW LEVEL SECURITY コマンドは、リレーションのデータ共有アクセシビリティプロパティにのみ影響します。ROW LEVEL SECURITY のプロパティは変更されません。
RLS で保護されたリレーションにデータ共有上でアクセスできるようにした場合、コンシューマー側のデータ共有データベースにおいて、そのリレーションには行レベルのセキュリティが適用されません。リレーションはプロデューサー側の RLS プロパティを保持します。
MASKING \$1 ON \$1 OFF \$1 FOR DATASHARES
DDM で保護されたリレーションにデータ共有を介してアクセスできるかどうかを決定する句。デフォルトでは、DDM で保護されたリレーションにデータ共有を介してアクセスすることはできません。DDM で保護されたリレーションにデータ共有を介してアクセスできるようにした場合、コンシューマー側のデータ共有データベースでそのリレーションにマスキング保護が適用されません。リレーションは、プロデューサー側でマスキングプロパティを保持します。MASKING FOR DATASHARES 句を設定できるのは、スーパーユーザーと、`sys:secadmin` ロールを持つユーザーまたはロールのみです。詳細については、「[動的データマスキング](t_ddm.md)」を参照してください。
## 例
ALTER TABLE コマンドの使用方法を示す例については、以下を参照してください。
+ [ALTER TABLE の例](r_ALTER_TABLE_examples_basic.md)
+ [ALTER EXTERNAL TABLE 例](r_ALTER_TABLE_external-table.md)
+ [ALTER TABLE ADD および DROP COLUMN の例](r_ALTER_TABLE_COL_ex-add-drop.md)
# ALTER TABLE の例
次の例は、ALTER TABLE コマンドの基本用法を示しています。
## テーブルまたはビューの名前の変更
次のコマンドは、USERS テーブルを USERS\$1BKUP に名前変更します。
```
alter table users
rename to users_bkup;
```
このタイプのコマンドを使用して、ビューの名前を変更することもできます。
## テーブルまたはビューの所有者の変更
次のコマンドは VENUE テーブルの所有者をユーザー DWUSER に変更します。
```
alter table venue
owner to dwuser;
```
次のコマンドは、ビューを作成した後、その所有者を変更します。
```
create view vdate as select * from date;
alter table vdate owner to vuser;
```
## 列名の変更
次のコマンドは VENUE テーブルの列名を VENUESEATS から VENUESIZE に変更します。
```
alter table venue
rename column venueseats to venuesize;
```
## テーブルの制約を削除する
プライマリキー、外部キーまたは一意の制約のようなテーブルの制約を削除するには、まず内部の制約名を見つけます。その後、ALTER TABLE コマンドで制約名を指定します。次の例では、CATEGORY テーブルの制約を見つけてから、`category_pkey`という名前のプライマリキーを削除します。
```
select constraint_name, constraint_type
from information_schema.table_constraints
where constraint_schema ='public'
and table_name = 'category';
constraint_name | constraint_type
----------------+----------------
category_pkey | PRIMARY KEY
alter table category
drop constraint category_pkey;
```
## VARCHAR 列の変更
ストレージを節約するため、最初に現在のデータ要件に必要な最小サイズの VARCHAR 列を使用してテーブルを定義することができます。後でより長い文字列を収容するには、テーブルを変更して列のサイズを大きくすることができます。
次の例では、EVENTNAME 列のサイズを VARCHAR(300) に増やします。
```
alter table event alter column eventname type varchar(300);
```
## VARBYTE 列を変更する
ストレージを節約するために、最初に現在のデータ要件に必要な最小サイズの VARBYTE 列を使用してテーブルを定義できます。後でより長い文字列を収容するには、テーブルを変更して列のサイズを大きくすることができます。
次の例では、EVENTNAME 列のサイズを VARBYTE(300) に増やします。
```
alter table event alter column eventname type varbyte(300);
```
## 列の圧縮エンコードを変更する
列の圧縮エンコードは変更できます。以下に、このアプローチを示す一連の例を示します。これらの例のテーブルは次のように定義されています。
```
create table t1(c0 int encode lzo, c1 bigint encode zstd, c2 varchar(16) encode lzo, c3 varchar(32) encode zstd);
```
次のステートメントは、列 c0 の圧縮エンコードを LZO エンコードから AZ64 エンコードに変更します。
```
alter table t1 alter column c0 encode az64;
```
次のステートメントは、列 c1 の圧縮エンコードを Zstandard エンコードから AZ64 エンコードに変更します。
```
alter table t1 alter column c1 encode az64;
```
次のステートメントは、列 c2 の圧縮エンコードを LZO エンコードからバイトディクショナリエンコードに変更します。
```
alter table t1 alter column c2 encode bytedict;
```
次のステートメントは、列 c3 の圧縮エンコードを Zstandard エンコードから Runlength エンコードに変更します。
```
alter table t1 alter column c3 encode runlength;
```
## DISTSTYLE KEY DISTKEY 列の変更
次の例は、テーブルの DISTSTYLE および DISTKEY を変更する方法を示しています。
EVEN 分散スタイルを指定してテーブルを作成します。SVV\$1TABLE\$1INFO ビューは、DISTSTYLE が EVEN であることを示しています。
```
create table inventory(
inv_date_sk int4 not null ,
inv_item_sk int4 not null ,
inv_warehouse_sk int4 not null ,
inv_quantity_on_hand int4
) diststyle even;
Insert into inventory values(1,1,1,1);
select "table", "diststyle" from svv_table_info;
table | diststyle
-----------+----------------
inventory | EVEN
```
DISTKEY テーブルを `inv_warehouse_sk` に変更してください。SVV\$1TABLE\$1INFO ビューは、`inv_warehouse_sk`列を結果の分散キーとして示しています。
```
alter table inventory alter diststyle key distkey inv_warehouse_sk;
select "table", "diststyle" from svv_table_info;
table | diststyle
-----------+-----------------------
inventory | KEY(inv_warehouse_sk)
```
DISTKEY テーブルを `inv_item_sk` に変更してください。SVV\$1TABLE\$1INFO ビューは、`inv_item_sk`列を結果の分散キーとして示しています。
```
alter table inventory alter distkey inv_item_sk;
select "table", "diststyle" from svv_table_info;
table | diststyle
-----------+-----------------------
inventory | KEY(inv_item_sk)
```
## テーブルを DISTSTYLE ALL に変更する
次の例では、テーブルを DISTSTYLE ALL に変更する方法を説明します。
EVEN 分散スタイルを指定してテーブルを作成します。SVV\$1TABLE\$1INFO ビューは、DISTSTYLE が EVEN であることを示しています。
```
create table inventory(
inv_date_sk int4 not null ,
inv_item_sk int4 not null ,
inv_warehouse_sk int4 not null ,
inv_quantity_on_hand int4
) diststyle even;
Insert into inventory values(1,1,1,1);
select "table", "diststyle" from svv_table_info;
table | diststyle
-----------+----------------
inventory | EVEN
```
DISTSTYLE テーブルを ALL に変更します。SVV\$1TABLE\$1INFO ビューには、変更された DISTSYTLE が表示されます。
```
alter table inventory alter diststyle all;
select "table", "diststyle" from svv_table_info;
table | diststyle
-----------+----------------
inventory | ALL
```
## テーブルの SORTKEY を変更する
複合ソートキーを使用する、あるいはソートキーを使用しないようにテーブルを変更できます。
次のテーブル定義では、テーブル `t1` は、インターリーブソートキーを使用するように定義されます。
```
create table t1 (c0 int, c1 int) interleaved sortkey(c0, c1);
```
次のコマンドは、インターリーブされたソートキーの使用から複合ソートキーの使用に、テーブルを変更します。
```
alter table t1 alter sortkey(c0, c1);
```
次のコマンドは、インターリーブソートキーを削除するためにテーブルを変更します。
```
alter table t1 alter sortkey none;
```
次のテーブル定義では、テーブル `t1` のソートキーとして `c0` 列を定義しています。
```
create table t1 (c0 int, c1 int) sortkey(c0);
```
次のコマンドは、テーブル `t1` を複合ソートキーの使用に変更します。
```
alter table t1 alter sortkey(c0, c1);
```
## テーブルを ENCODE AUTO に変更する
次の例は、テーブルを ENCODE AUTO に変更する方法を示しています。
例えば、テーブルは次のように定義されています。列 `c0` はエンコードタイプ AZ64 で定義され、列 `c1` はエンコードタイプ LZO で定義されます。
```
create table t1(c0 int encode AZ64, c1 varchar encode LZO);
```
このテーブルの場合、次のステートメントはエンコードを AUTO に変更します。
```
alter table t1 alter encode auto;
```
次の例は、テーブルを変更して ENCODE AUTO 設定を削除する方法を示しています。
例えば、テーブルは次のように定義されています。テーブルの列は、エンコードなしで定義されます。この場合、エンコードはデフォルトで ENCODE AUTO になります。
```
create table t2(c0 int, c1 varchar);
```
このテーブルの場合、次のステートメントは列 c0 のエンコードを LZO に変更します。テーブルのエンコードが ENCODE AUTO に設定されなくなりました。
```
alter table t2 alter column c0 encode lzo;;
```
## 行レベルのセキュリティコントロールの変更
次のコマンドは、テーブルの RLS をオフにします。
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY OFF;
```
次のコマンドは、テーブルの RLS をオンにします。
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY ON;
```
次のコマンドは、テーブルの RLS をオンにし、データ共有上でテーブルにアクセスできるようにします。
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY ON;
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY FOR DATASHARES OFF;
```
次のコマンドは、テーブルの RLS をオンにして、データ共有上でテーブルにアクセスできなくします。
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY ON;
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY FOR DATASHARES ON;
```
次のコマンドは、RLS をオンにし、テーブルの RLS 結合タイプを OR に設定します。
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY ON CONJUNCTION TYPE OR;
```
次のコマンドは、RLS をオンにし、テーブルの RLS 結合タイプを AND に設定します。
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY ON CONJUNCTION TYPE AND;
```
# ALTER EXTERNAL TABLE 例
次の例では、米国東部 (バージニア北部) リージョン (`us-east-1`) AWS リージョン にある Amazon S3 バケットおよび CREATE TABLE の [例](r_CREATE_EXTERNAL_TABLE_examples.md) で作成されたテーブル例を使用します。外部テーブルでパーティションを使用する方法の詳細については、「[Redshift Spectrum 外部テーブルのパーティション化](c-spectrum-external-tables.md#c-spectrum-external-tables-partitioning)」を参照してください。
次の例では、SPECTRUM.SALES 外部テーブルの numRows テーブルプロパティを 170,000 行に設定します。
```
alter table spectrum.sales
set table properties ('numRows'='170000');
```
次の例では、SPECTRUM.SALES 外部テーブルの場所を変更します。
```
alter table spectrum.sales
set location 's3://redshift-downloads/tickit/spectrum/sales/';
```
次の例では、SPECTRUM.SALES 外部テーブルの型式を Parquet に変更します。
```
alter table spectrum.sales
set file format parquet;
```
次の例では、SPECTRUM.SALES\$1PART テーブルに対して 1 つのパーティションを追加します。
```
alter table spectrum.sales_part
add if not exists partition(saledate='2008-01-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01/';
```
次の例では、SPECTRUM.SALES\$1PART テーブルに対して 3 つのパーティションを追加します。
```
alter table spectrum.sales_part add if not exists
partition(saledate='2008-01-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01/'
partition(saledate='2008-02-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-02/'
partition(saledate='2008-03-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-03/';
```
次の例では、SPECTRUM.SALES\$1PART を変更して `saledate='2008-01-01''` のパーティションを削除します。
```
alter table spectrum.sales_part
drop partition(saledate='2008-01-01');
```
次の例では、`saledate='2008-01-01'` のパーティションに新しい Amazon S3 パスを設定します。
```
alter table spectrum.sales_part
partition(saledate='2008-01-01')
set location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01-01/';
```
次の例では、`sales_date`の名前を `transaction_date` に変更します。
```
alter table spectrum.sales rename column sales_date to transaction_date;
```
次の例では、最適化された行列 (ORC) 形式を使用する外部テーブルのために、列マッピングを位置マッピングに設定します。
```
alter table spectrum.orc_example
set table properties('orc.schema.resolution'='position');
```
次の例では、最適化された ORC 形式を使用する外部テーブルのために、列マッピングを名前マッピングに設定します。
```
alter table spectrum.orc_example
set table properties('orc.schema.resolution'='name');
```
# ALTER TABLE ADD および DROP COLUMN の例
次の例は、ALTER TABLE を使用して基本テーブル列を追加した後に削除する方法、および依存オブジェクトがある列を削除する方法を示しています。
## 基本列の追加と削除
次の例では、スタンドアロンの FEEDBACK\$1SCORE 列を USERS テーブルに追加します。この列には 1 つの整数が含まれます。この列のデフォルト値は NULL です (フィードバックスコアなし)。
まず、PG\$1TABLE\$1DEF カタログテーブルにクエリして、USERS テーブルのスキーマを表示します。
```
column | type | encoding | distkey | sortkey
--------------+------------------------+----------+---------+--------
userid | integer | delta | true | 1
username | character(8) | lzo | false | 0
firstname | character varying(30) | text32k | false | 0
lastname | character varying(30) | text32k | false | 0
city | character varying(30) | text32k | false | 0
state | character(2) | bytedict | false | 0
email | character varying(100) | lzo | false | 0
phone | character(14) | lzo | false | 0
likesports | boolean | none | false | 0
liketheatre | boolean | none | false | 0
likeconcerts | boolean | none | false | 0
likejazz | boolean | none | false | 0
likeclassical | boolean | none | false | 0
likeopera | boolean | none | false | 0
likerock | boolean | none | false | 0
likevegas | boolean | none | false | 0
likebroadway | boolean | none | false | 0
likemusicals | boolean | none | false | 0
```
次に、feedback\$1score 列を追加します。
```
alter table users
add column feedback_score int
default NULL;
```
USERS から FEEDBACK\$1SCORE 列を選択し、追加されたことを確認します。
```
select feedback_score from users limit 5;
feedback_score
----------------
NULL
NULL
NULL
NULL
NULL
```
列を削除して元の DDL に戻します。
```
alter table users drop column feedback_score;
```
## 依存オブジェクトがある列の削除
以下の例では、依存オブジェクトがある列を削除します。その結果、依存オブジェクトも削除されます。
初めに、もう一度 FEEDBACK\$1SCORE 列を USERS テーブルに追加します。
```
alter table users
add column feedback_score int
default NULL;
```
次に、USERS テーブルから USERS\$1VIEW というビューを作成します。
```
create view users_view as select * from users;
```
次に、USERS テーブルから FEEDBACK\$1SCORE 列の削除を試みます。この DROP ステートメントではデフォルト動作 (RESTRICT) を使用します。
```
alter table users drop column feedback_score;
```
Amazon Redshift は列に別のオブジェクトが依存しているため、列を削除できないことを示すエラーメッセージが表示されます。
今度はすべての依存オブジェクトを削除するため CASCADE を指定して、FEEDBACK\$1SCORE 列の削除を再度試みます。
```
alter table users
drop column feedback_score cascade;
```
# ALTER TABLE APPEND
既存のソーステーブルのデータを移動して、ターゲットテーブルに行を追加します。ソーステーブル内のデータはターゲットテーブルの一致する列に移動されます。列の順序は関係ありません。データがターゲットテーブルに正常に追加されると、ソーステーブルは空になります。通常、ALTER TABLE APPEND は、データを複製するのではなく移動するため、同様の [CREATE TABLE AS](r_CREATE_TABLE_AS.md) または [INSERT](r_INSERT_30.md) の INTO オペレーションよりもはるかに高速です。
**注記**
ALTER TABLE APPEND は、ソーステーブルとターゲットテーブル間でデータブロックを移動します。パフォーマンスを向上させるため、ALTER TABLE APPEND は追加操作の一部としてストレージを圧縮しません。その結果、ストレージ使用量は一時的に増加します。スペースを回復するには、[VACUUM](r_VACUUM_command.md)操作を実行します。
同じ名前の列には、同じ列属性も必要です。ソーステーブルまたはターゲットテーブルに、他のテーブルに含まれる列が含まれない場合は、IGNOREEXTRA または FILLTARGET パラメータを使用して、追加の列を管理する方法を指定します。
IDENTITY 列を追加することはできません。テーブルの両方に IDENTITY 列が含まれる場合、コマンドは失敗します。1 つのテーブルのみに IDENTITY 列がある場合は、FILLTARGET パラメータまたは IGNOREEXTRA パラメータを含めます。詳細については、「[ALTER TABLE APPEND の使用に関する注意事項](#r_ALTER_TABLE_APPEND_usage)」を参照してください。
GENERATED BY DEFAULT AS IDENTITY 列を追加できます。GENERATED BY DEFAULT AS IDENTITY として定義された列を、指定した値で更新できます。詳細については、「[ALTER TABLE APPEND の使用に関する注意事項](#r_ALTER_TABLE_APPEND_usage)」を参照してください。
ターゲットテーブルは永続テーブルである必要があります。ただし、ソースはパーマネントテーブルでも、ストリーミング取り込み用に設定されたマテリアライズドビューでもかまいません。両方のオブジェクトは同じ分散スタイルと分散キーを使用する必要があります (定義されている場合)。オブジェクトがソートされている場合、両方のオブジェクトは同じソート形式を使用し、ソートキーとして同じ列を定義する必要があります。
ALTER TABLE APPEND コマンドは、オペレーションが完了するとすぐに自動的にコミットします。ロールバックすることはできません。トランザクションブロック (BEGIN ... END) 内で ALTER TABLE APPEND を実行することはできません。トランザクションの詳細については、「[Amazon Redshift の分離レベル](c_serial_isolation.md)」を参照してください。
## 必要な権限
ALTER TABLE APPEND コマンドによっては、次のいずれかの権限が必要です。
+ スーパーユーザー
+ ALTER TABLE システム権限を持つユーザー
+ ソーステーブルに対する DELETE 権限と SELECT 権限、およびターゲットテーブルに対する INSERT 権限を持つユーザー
## 構文
```
ALTER TABLE target_table_name APPEND FROM [ source_table_name | source_materialized_view_name ]
[ IGNOREEXTRA | FILLTARGET ]
```
マテリアライズドビューからの追加は、マテリアライズドビューが [マテリアライズドビューへのストリーミング取り込み](materialized-view-streaming-ingestion.md) に設定されている場合にのみ機能します。
## パラメータ
*target\$1table\$1name*
列が追加されるテーブルの名前。テーブル名のみを指定するか、*schema\$1name.table\$1name* 形式で特定のスキーマを使用します。ターゲットテーブルは既存の永続テーブルである必要があります。
FROM *source\$1table\$1name*
追加する行を提供するテーブルの名前。テーブル名のみを指定するか、*schema\$1name.table\$1name* 形式で特定のスキーマを使用します。ソーステーブルは既存の永続テーブルである必要があります。
*source\$1materialized\$1view\$1name* から
追加する行を提供するマテリアライズドビューの名前。マテリアライズドビューからの追加は、マテリアライズドビューが [マテリアライズドビューへのストリーミング取り込み](materialized-view-streaming-ingestion.md) に設定されている場合にのみ機能します。ソースマテリアライズドビューは既に存在している必要があります。
IGNOREEXTRA
ターゲットテーブルにない列がソーステーブルに含まれている場合に、追加の列のデータを破棄することを指定するキーワード。IGNOREEXTRA を FILLTARGET と使用することはできません。
FILLTARGET
ソーステーブルにない列がターゲットテーブルに含まれている場合に、列に [DEFAULT](r_CREATE_TABLE_NEW.md#create-table-default) 列値を入れるか (定義されている場合)、NULL にすることを指定するキーワード。IGNOREEXTRA を FILLTARGET と使用することはできません。
## ALTER TABLE APPEND の使用に関する注意事項
+ ALTER TABLE APPEND はソーステーブルからターゲットテーブルに同一の列のみを移動します。列の順序は関係ありません。
+ ソーステーブルまたはターゲットテーブルに追加の列が含まれている場合、以下のルールに従って FILLTARGET または IGNOREEXTRA を使用します。
+ ターゲットテーブルに存在しない列がソーステーブルに含まれている場合は、IGNOREEXTRA を含めます。コマンドは、ソーステーブルの追加の列を無視します。
+ ソーステーブルに存在しない列がターゲットテーブルに含まれている場合は、FILLTARGET を含めます。コマンドは、デフォルトの列値または IDENTITY 値 (定義されている場合)、あるいは NULL をターゲットテーブルの追加の列に入れます。
+ ソーステーブルとターゲットテーブルの両方に追加の列が含まれる場合、コマンドは失敗します。FILLTARGET と IGNOREEXTRA の両方を使用することはできません。
+ 同じ名前で別の属性を持つ列が両方のテーブルに存在する場合、コマンドは失敗します。同様の名前の列には、共通して次の属性が必要です。
+ データ型
+ 列のサイズ
+ 圧縮エンコード
+ null でない
+ ソート形式
+ ソートキーの列
+ 分散スタイル
+ 分散キー列
+ IDENTITY 列を追加することはできません。ソーステーブルとターゲットテーブルの両方に IDENTITY 列がある場合、コマンドは失敗します。ソーステーブルのみに IDENTITY 列がある場合、IDENTITY 列が無視されるように IGNOREEXTRA パラメータを含めます。ターゲットテーブルのみに IDENTITY 列がある場合は、テーブルに対して定義されている IDENTITY 句に従って IDENTITY 列が入力されるように FILLTARGET パラメータを含めます。詳細については、「[DEFAULT](r_CREATE_TABLE_NEW.md#create-table-default)」を参照してください。
+ ALTER TABLE APPEND ステートメントを使用して、デフォルトの IDENTITY 列を追加できます。詳細については、「[CREATE TABLE](r_CREATE_TABLE_NEW.md)」を参照してください。
+ ALTER TABLE APPEND オペレーションは、次のいずれかに接続された Amazon Redshift ストリーミングマテリアライズドビューで実行されると、排他的ロックを保持します。
+ 1 つの Amazon Kinesis Data Streams
+ 1 つの Amazon Managed Streaming for Apache Kafka トピック
+ Confluent Cloud Kafka トピックなど、サポートされている外部ストリーム
詳細については、「[マテリアライズドビューへのストリーミング取り込み](materialized-view-streaming-ingestion.md)」を参照してください。
## ALTER TABLE APPEND の例
最新の売上を把握するために、組織で SALES\$1MONTHLY テーブルを維持しているとします。毎月、トランザクションテーブルから SALES テーブルにデータを移動するとします。
次の INSERT INTO または TRUNCATE コマンドを使用して、このタスクを完了できます。
```
insert into sales (select * from sales_monthly);
truncate sales_monthly;
```
ただし、ALTER TABLE APPEND コマンドを使用すると、同じオペレーションをはるかに効率的に実行できます。
最初に、[PG\$1TABLE\$1DEF](r_PG_TABLE_DEF.md)システムカタログテーブルにクエリを実行し、両方のテーブルに、同じ列属性を持つ同じ列があることを確認します。
```
select trim(tablename) as table, "column", trim(type) as type,
encoding, distkey, sortkey, "notnull"
from pg_table_def where tablename like 'sales%';
table | column | type | encoding | distkey | sortkey | notnull
-----------+------------+-----------------------------+----------+---------+---------+--------
sales | salesid | integer | lzo | false | 0 | true
sales | listid | integer | none | true | 1 | true
sales | sellerid | integer | none | false | 2 | true
sales | buyerid | integer | lzo | false | 0 | true
sales | eventid | integer | mostly16 | false | 0 | true
sales | dateid | smallint | lzo | false | 0 | true
sales | qtysold | smallint | mostly8 | false | 0 | true
sales | pricepaid | numeric(8,2) | delta32k | false | 0 | false
sales | commission | numeric(8,2) | delta32k | false | 0 | false
sales | saletime | timestamp without time zone | lzo | false | 0 | false
salesmonth | salesid | integer | lzo | false | 0 | true
salesmonth | listid | integer | none | true | 1 | true
salesmonth | sellerid | integer | none | false | 2 | true
salesmonth | buyerid | integer | lzo | false | 0 | true
salesmonth | eventid | integer | mostly16 | false | 0 | true
salesmonth | dateid | smallint | lzo | false | 0 | true
salesmonth | qtysold | smallint | mostly8 | false | 0 | true
salesmonth | pricepaid | numeric(8,2) | delta32k | false | 0 | false
salesmonth | commission | numeric(8,2) | delta32k | false | 0 | false
salesmonth | saletime | timestamp without time zone | lzo | false | 0 | false
```
次に、各テーブルのサイズを確認します。
```
select count(*) from sales_monthly;
count
-------
2000
(1 row)
select count(*) from sales;
count
-------
412,214
(1 row)
```
ここで、次の ALTER TABLE APPEND コマンドを実行します。
```
alter table sales append from sales_monthly;
```
もう一度、各テーブルのサイズを確認します。SALES\$1MONTHLY テーブルは 0 行になり、SALES テーブルは 2000 行増えています。
```
select count(*) from sales_monthly;
count
-------
0
(1 row)
select count(*) from sales;
count
-------
414214
(1 row)
```
ソーステーブルにターゲットテーブルより多くの列がある場合は、IGNOREEXTRA パラメータを指定します。次の例では、IGNOREEXTRA パラメータを使用して、SALES テーブルに追加するときに SALES\$1LISTING テーブル列の追加の列を無視します。
```
alter table sales append from sales_listing ignoreextra;
```
ターゲットテーブルにソーステーブルより多くの列がある場合は、FILLTARGET パラメータを指定します。次の例では、FILLTARGET パラメータを使用して、SALES\$1MONTH テーブルに存在しない列を SALES\$1REPORT テーブルに入力します。
```
alter table sales_report append from sales_month filltarget;
```
次の例は、マテリアライズドビューをソースとして ALTER TABLE APPEND を使用する方法の例を示しています。
```
ALTER TABLE target_tbl APPEND FROM my_streaming_materialized_view;
```
この例のテーブル名とマテリアライズドビュー名はサンプルです。マテリアライズドビューからの追加は、マテリアライズドビューが [マテリアライズドビューへのストリーミング取り込み](materialized-view-streaming-ingestion.md) に設定されている場合にのみ機能します。ソースマテリアライズドビューのすべてのレコードを、マテリアライズドビューと同じスキーマのターゲットテーブルに移動し、マテリアライズドビューはそのまま残します。これは、データのソースがテーブルである場合と同じ動作です。
# ALTER TEMPLATE
既存のテンプレートの定義を変更します。このコマンドを使用して、テンプレートの名前を変更したり、テンプレートの所有者を変更したり、テンプレート定義にパラメータを追加または削除したり、パラメータ値を設定したりします。
## 必要な権限
テンプレートを変更するには、次のいずれかが必要です。
+ スーパーユーザー権限
+ テンプレートを含むスキーマに対する ALTER TEMPLATE 権限と USAGE 権限
## 構文
```
ALTER TEMPLATE [database_name.][schema_name.]template_name
{
RENAME TO new_name
| OWNER TO new_owner
| ADD parameter [AS] [value]
| DROP parameter
| SET parameter TO value1 [, parameter2 TO value2 , ...]
};
```
## パラメータ
*database\$1name*
(オプション) テンプレートが作成されるデータベースの名前。指定しない場合は、現在のデータベースが使用されます。
*schema\$1name*
(オプション) テンプレートが作成されるスキーマの名前。指定しない場合は、現在の検索パスでテンプレートが検索されます。
*template\$1name*
変更するテンプレートの名前。
RENAME TO
テンプレートの名前を変更する句。
*new\$1name*
テンプレートの新しい名前。有効な名前の詳細については、「[名前と識別子](r_names.md)」を参照してください。
OWNER TO
テンプレートの所有者を変更する句。
*new\$1owner*
テンプレートの新しい所有者。
ADD *パラメータ* [AS] [*値*]
テンプレートに新しいパラメータを追加します。
+ キーワードのみのパラメータ (CSV や GZIP など) の場合は、パラメータ名のみを指定します。
+ 値を必要とするパラメータの場合は、パラメータ名に続けて値を指定します。オプションで、パラメータと値の間に AS を含めることができます。
DROP *パラメータ*
指定されたパラメータをテンプレートから削除します。1 つの DROP コマンドで複数のパラメータを削除することはできません。
SET *パラメータ* TO *value1* [, *parameter2* TO *value2* , ...]
既存のテンプレートパラメータの値を更新します。値が既にあるパラメータにのみ使用します。1 つのコマンドで複数のパラメータを更新できます。
## 例
次の例では、test\$1template テンプレートの名前を demo\$1template に変更します。
```
ALTER TEMPLATE test_template
RENAME TO demo_template;
```
次の例では、demo\$1template スキーマの所有権をユーザー bob に与えます。
```
ALTER TEMPLATE demo_template
OWNER TO bob;
```
次の例では、テンプレート demo\$1template にパラメータ `CSV` を追加します。
```
ALTER TEMPLATE demo_template
ADD CSV;
```
次の例では、テンプレート demo\$1template にパラメータ `TIMEFORMAT 'auto'` を追加します。
```
ALTER TEMPLATE demo_template
ADD TIMEFORMAT 'auto';
```
次の例では、テンプレート demo\$1template からパラメータ `ENCRYPTED` を削除します。
```
ALTER TEMPLATE demo_template
DROP ENCRYPTED;
```
次の例では、`DELIMITER` パラメータを `'|'` に設定し、`TIMEFORMAT` パラメータを `'epochsecs'` に設定します。
```
ALTER TEMPLATE demo_template
SET DELIMITER TO '|', TIMEFORMAT TO 'epochsecs';
```
# ALTER USER
データベースユーザーを変更します。
## 必要な権限
以下に、ALTER USER に必要な権限を示します。
+ スーパーユーザー
+ ALTER USER の権限を持つユーザー
+ 自身のパスワードを変更しようとする現在のユーザー
## 構文
```
ALTER USER username [ WITH ] option [, ... ]
where option is
CREATEDB | NOCREATEDB
| CREATEUSER | NOCREATEUSER
| SYSLOG ACCESS { RESTRICTED | UNRESTRICTED }
| PASSWORD { 'password' | 'md5hash' | 'sha256hash' | DISABLE }
[ VALID UNTIL 'expiration_date' ]
| RENAME TO new_name |
| CONNECTION LIMIT { limit | UNLIMITED }
| SESSION TIMEOUT limit | RESET SESSION TIMEOUT
| SET parameter { TO | = } { value | DEFAULT }
| RESET parameter
| EXTERNALID external_id
```
## パラメータ
* ユーザー名*
ユーザーの名前。
WiTH
オプションキーワード
CREATEDB \$1 NOCREATEDB
CREATEDB オプションを使用すると、ユーザーは新しいデータベースを作成できます。NOCREATEDB がデフォルトです。
CREATEUSER \$1 NOCREATEUSER
CREATEUSER オプションを使用すると、CREATE USER を含め、データベースに関するすべての権限を持つスーパーユーザーが作成されます。デフォルトは NOCREATEUSER です。詳細については、「[スーパーユーザー](r_superusers.md)」を参照してください。
SYSLOG ACCESS \$1 RESTRICTED \$1 UNRESTRICTED \$1
Amazon Redshift のシステムテーブルとビューに対するユーザーのアクセスレベルを指定する句です。
SYSLOG ACCESS RESTRICTED アクセス許可を持つ通常のユーザーは、ユーザーが表示できるシステムテーブルとビューで自分が生成した行のみを表示できます。デフォルトは RESTRICTED です。
SYSLOG ACCESS UNRESTRICTED アクセス許可を持つ通常のユーザーは、ユーザーが表示できるシステムテーブルとビューのすべての行 (別のユーザーが生成した行を含む) を表示できます。UNRESTRICTED を指定しても、スーパーユーザーが表示可能なテーブルへのアクセス権が、通常のユーザーに付与されるわけではありません。スーパーユーザーが表示可能なテーブルを表示できるのはスーパーユーザーだけです。
システムテーブルに対する無制限のアクセス権限を付与されたユーザーは、別のユーザーが生成したデータへの可視性が提供されます。例えば、STL\$1QUERY と STL\$1QUERYTEXT には INSERT、UPDATE、および DELETE ステートメントのフルテキストが含まれており、ユーザーが生成した機密データがこれらに含まれている可能性があります。
SVV\$1TRANSACTIONS のすべての行は、すべてのユーザーが表示可能です。
詳細については、「[システムテーブルとビューのデータの可視性](cm_chap_system-tables.md#c_visibility-of-data)」を参照してください。
PASSWORD \$1 '*password*' \$1 '*md5hash*' \$1 '*sha256hash*' \$1 DISABLE \$1
ユーザーのパスワードを設定します。
デフォルトでは、ユーザーはパスワードが無効になっていない限り、自分のパスワードを変更できます。ユーザーのパスワードを無効にするには、DISABLE を指定します。ユーザーのパスワードが無効になると、パスワードはシステムから削除され、ユーザーは AWS Identity and Access Management (IAM) ユーザーの一時的認証情報を使用してのみログオンできます。詳細については、「[IAM 認証を使用したデータベースユーザー認証情報の生成](https://docs.aws.amazon.com/redshift/latest/mgmt/generating-user-credentials.html)」を参照してください。スーパーユーザーのみが、パスワードを有効または無効にできます。スーパーユーザーのパスワードを無効にすることはできません。パスワードを有効にするには、ALTER USER を実行し、パスワードを指定します。
PASSWORD パラメータの使用の詳細については、「[CREATE USER](r_CREATE_USER.md)」を参照してください。
VALID UNTIL '*expiration\$1date*'
パスワードに失効日があることを指定します。値 `'infinity'` を使用すると、失効日を設定しないようにすることができます。このパラメータの有効なデータ型はタイムスタンプです。
このパラメータを使用できるのはスーパーユーザーだけです。
RENAME TO
ユーザーの名前を変更します。
*new\$1name*
ユーザーの新しい名前。有効な名前の詳細については、「[名前と識別子](r_names.md)」を参照してください。
ユーザーの名前を変更すると、ユーザーのパスワードもリセットする必要があります。リセット後のパスワードは、以前のパスワードと異ならなくても構いません。ユーザー名はパスワード暗号化の一部として使用されるため、ユーザーの名前を変更すると、パスワードは消去されます。パスワードをリセットするまで、ユーザーはログオンできません。次に例を示します。
```
alter user newuser password 'EXAMPLENewPassword11';
```
CONNECTION LIMIT \$1 *limit* \$1 UNLIMITED \$1
ユーザーが同時に開けるデータベース接続の最大数。この制限はスーパーユーザーには適用されません。同時接続の最大数を許可するには、UNLIMITED キーワードを使用します。データベースごとの接続数の制限が適用される場合もあります。詳細については、「[CREATE DATABASE](r_CREATE_DATABASE.md)」を参照してください。デフォルトは UNLIMITED です。現在の接続を確認するには、[STV\$1SESSIONS](r_STV_SESSIONS.md)システムビューに対してクエリを実行します。
ユーザーとデータベースの両方の接続制限が適用される場合は、ユーザーが接続しようとしたときに、両方の制限内に未使用の接続スロットがなければなりません。
SESSION TIMEOUT *limit* \$1 RESET SESSION TIMEOUT
セッションが非アクティブまたはアイドル状態を維持する最大時間 (秒) です。指定できる範囲は 60 秒 (1 分) から 1,728,000 秒 (20 日) です。ユーザーに対しセッションタイムアウトが設定されていない場合は、クラスターの設定値が適用されます。詳細については、「*Amazon Redshift 管理ガイド*」の「[Amazon Redshift のクォータと制限](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html)」を参照してください。
設定されたセッションタイムアウトは、新しいセッションにのみ適用されます。
開始時刻、ユーザー名、セッションタイムアウトなど、アクティブなユーザーセッションに関する情報を表示するには、[STV\$1SESSIONS](r_STV_SESSIONS.md)システムビューを参照します。ユーザーセッションの履歴に関する情報を表示するには、[STL\$1SESSIONS](r_STL_SESSIONS.md)ビューを参照します。セッションタイムアウト値など、データベースユーザーに関する情報を取得するには、[SVL\$1USER\$1INFO](r_SVL_USER_INFO.md)ビューを参照します。
SET
指定したユーザーによって実行されるすべてのセッションに対して、設定パラメータを新しいデフォルト値に設定します。
RESET
指定したユーザーに対して、設定パラメータを元のデフォルト値にリセットします。
* パラメータ*
設定またはリセットするパラメータの名前。
*value*
パラメータの新しい値。
DEFAULT
指定したユーザーによって実行されるすべてのセッションに対して、設定パラメータをデフォルト値に設定します。
EXTERNALID *external\$1id*
ID プロバイダーに関連付けられているユーザーの識別子。ユーザーはパスワードを無効にする必要があります。詳細については、「[Amazon Redshift 用のネイティブ ID プロバイダー (IdP) フェデレーション](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-native-idp.html)」を参照してください。
## 使用に関する注意事項
+ **rdsdb を変更する試行** — `rdsdb` という名前のユーザーは変更できません。
+ **不明なパスワードの作成** – AWS Identity and Access Management (IAM) 認証情報を使用してデータベースのユーザー認証情報を作成する場合、一時的認証情報を使用してのみログオンできるスーパーユーザーを作成することをお勧めします。スーパーユーザーのパスワードを無効にすることはできませんが、ランダムに生成された MD5 ハッシュ文字列を使って不明なパスワードを作成することはできます。
```
alter user iam_superuser password 'md51234567890123456780123456789012';
```
+ **search\$1path の設定** – ALTER USER コマンドに [search\$1path](r_search_path.md) パラメータを設定した場合、指定したユーザーの次のログイン時に変更が反映されます。現在のユーザーとセッションの search\$1path 値を変更する場合は、SET コマンドを使用します。
+ **タイムゾーンの設定** – ALTER USER コマンドに SET TIMEZONE を使用する場合、指定したユーザーの次のログイン時に変更が反映されます。
+ **動的データマスキングと行レベルのセキュリティポリシーとの連携** – プロビジョニングされたクラスターまたはサーバーレス名前空間に動的データマスキングまたは行レベルのセキュリティポリシーが適用されている場合、次のコマンドは標準ユーザーに対してブロックされます。
```
ALTER SET enable_case_sensitive_super_attribute/enable_case_sensitive_identifier/downcase_delimited_identifier
```
これらの設定オプションを設定できるのは、スーパーユーザーと、ALTER USER 権限を持つユーザーのみです。行レベルのセキュリティの詳細については、「[行レベルのセキュリティ](t_rls.md)」を参照してください。動的データマスキングの詳細については、「[動的データマスキング](t_ddm.md)」を参照してください。
## 例
次の例では、ユーザー ADMIN にデータベースを作成する権限を与えます。
```
alter user admin createdb;
```
次の例では、ユーザー ADMIN のパスワードを `adminPass9` に設定し、パスワードの有効期限切れの日時を設定します。
```
alter user admin password 'adminPass9'
valid until '2017-12-31 23:59';
```
次の例では、ユーザー名を ADMIN から SYSADMIN に変更します。
```
alter user admin rename to sysadmin;
```
次の例では、ユーザーのアイドルセッションタイムアウトを 300 秒に変更しています。
```
ALTER USER dbuser SESSION TIMEOUT 300;
```
ユーザーのアイドルセッションタイムアウトをリセットします。これをリセットすると、クラスターの設定内容が適用されます。このコマンドを実行するには、データベースのスーパーユーザー権限を持つ必要があります。詳細については、「*Amazon Redshift 管理ガイド*」の「[Amazon Redshift のクォータと制限](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html)」を参照してください。
```
ALTER USER dbuser RESET SESSION TIMEOUT;
```
次の例では、`bob` という名前のユーザーの外部 ID を更新します。名前空間は `myco_aad` です。名前空間が登録された ID プロバイダーに関連付けられていない場合、エラーが発生します。
```
ALTER USER myco_aad:bob EXTERNALID "ABC123" PASSWORD DISABLE;
```
次の例では、特定のデータベースユーザーが実行するすべてのセッションのタイムゾーンを設定します。現在のセッションではなく、後のセッションのタイムゾーンを変更します。
```
ALTER USER odie SET TIMEZONE TO 'Europe/Zurich';
```
次の例では、ユーザー `bob` が開くことができるデータベース接続の最大数を設定します。
```
ALTER USER bob CONNECTION LIMIT 10;
```
# ANALYZE
クエリプランナーで使用するテーブル統計を更新します。
## 必要な権限
ANALYZE に必要な権限を以下に示します。
+ スーパーユーザー
+ ANALYZE の権限を持つユーザー
+ 関連付けの所有者
+ テーブルの共有先であるデータベース所有者
## 構文
```
ANALYZE [ VERBOSE ]
[ [ table_name [ ( column_name [, ...] ) ] ]
[ PREDICATE COLUMNS | ALL COLUMNS ]
```
## パラメータ
VERBOSE
ANALYZE オペレーションに関する進捗情報メッセージを返す句。このオプションは、テーブルを指定しないときに役立ちます。
*table\$1name*
一時テーブルを含む、特定のテーブルを分析できます。テーブルをそのスキーマ名で修飾することができます。また、table\$1name を指定して単一のテーブルを分析することもできます。1 つの ANALYZE *table\$1name* ステートメントで複数の *table\$1name* を指定することはできません。*table\$1name* 値を指定しなかった場合、システムカタログの永続テーブルを含め、現在接続されているデータベースのすべてのテーブルが分析されます。最後の ANALYZE 以降に変更された行の割合が分析のしきい値よりも低い場合、Amazon Redshift はテーブルの分析をスキップします。詳細については、「[分析のしきい値](#r_ANALYZE-threshold)」を参照してください。
Amazon Redshift のシステムテーブル (STL テーブルと STV テーブル) を分析する必要はありません。
*column\$1name*
*table\$1name* を指定する場合、テーブルの 1 つ以上の列を指定することもできます (括弧内に列をカンマ区切りリストとして指定します)。列リストが指定された場合、リストされている列のみが分析されます。
PREDICATE COLUMNS \$1 ALL COLUMNS
ANALYZE に述語列のみを含めるかどうかを示す句。PREDICATE COLUMNS を指定すると、前のクエリで述語として使用されている列、または述語として使用される可能性が高い列のみが分析されます。すべての行を分析するには、ALL COLUMNS を指定します。デフォルトは ALL COLUMNS です。
次のいずれかが当てはまる場合、列は述語列のセットに含まれます。
+ この列は、フィルタ、結合条件、または GROUP BY 句の一部としてクエリで使用されています。
+ 列が分散キーです。
+ 列はソートキーの一部です。
例えば、テーブルがまだ照会されていないなどの理由で列が述語列としてマークされていない場合は、PREDICATE COLUMNS が指定されていてもすべての列が分析されます。この場合、Amazon Redshift は「*table-name* の述語列が見つかりません」 「すべての列を分析しています」などのメッセージで応答することがあります。述語の列の詳細については、[テーブルを分析する](t_Analyzing_tables.md)を参照してください。
## 使用に関する注意事項
Amazon Redshift では、以下のコマンドを使用して作成したテーブルで自動的に ANALYZE を実行します。
+ CREATE TABLE AS
+ CREATE TEMP TABLE AS
+ SELECT INTO
外部テーブルを分析することはできません。
最初に作成したとき、これらのテーブルに ANALYZE コマンドを実行する必要はありません。変更する場合は、他のテーブルと同じように分析する必要があります。
### 分析のしきい値
処理時間を短縮し、システム全体のパフォーマンスを向上させるために、最後の ANALYZE コマンドの実行以降に変更された行の割合が、[analyze\$1threshold\$1percent](r_analyze_threshold_percent.md) パラメータで指定された分析のしきい値よりも低い場合、Amazon Redshift はテーブルの分析をスキップします。デフォルトでは、`analyze_threshold_percent`は 10 です。現在のセッションの `analyze_threshold_percent` を変更するには、[SET](r_SET.md)コマンドを実行します。次の例では、`analyze_threshold_percent`を 20 パーセントに変更します。
```
set analyze_threshold_percent to 20;
```
数行のみを変更した場合にテーブルを分析するには、`analyze_threshold_percent`に任意の小さい数字を設定します。たとえば、`analyze_threshold_percent`を 0.01 に設定すると、少なくとも 10,000 行が変更された場合は 100,000,000 行のテーブルをスキップしません。
```
set analyze_threshold_percent to 0.01;
```
ANALYZE でテーブルがスキップされるのは、分析のしきい値を満たしていないためです。Amazon Redshift は次のメッセージを返します。
```
ANALYZE SKIP
```
行が変更されていない場合でもすべてのテーブルを分析するには、`analyze_threshold_percent`を 0 に設定します。
ANALYZE オペレーションの結果を表示するには、[STL\$1ANALYZE](r_STL_ANALYZE.md)システムテーブルに対してクエリを実行します。
テーブル分析の詳細については、「[テーブルを分析する](t_Analyzing_tables.md)」を参照してください。
## 例
TICKIT データベースのすべてのテーブルを分析し、進捗情報を返します。
```
analyze verbose;
```
LISTING テーブルのみを分析します。
```
analyze listing;
```
VENUE テーブルの VENUEID 列と VENUENAME 列を分析します。
```
analyze venue(venueid, venuename);
```
VENUE テーブルの述語の列のみを分析します。
```
analyze venue predicate columns;
```
# ANALYZE COMPRESSION
圧縮分析を行い、分析されたテーブルの推奨列エンコードスキームのレポートを生成します。レポートには、列ごとに RAW エンコードと比較したディスク容量の圧縮可能率の推定値が含まれます。
## 構文
```
ANALYZE COMPRESSION
[ [ table_name ]
[ ( column_name [, ...] ) ] ]
[COMPROWS numrows]
```
## パラメータ
*table\$1name*
一時テーブルを含む、特定のテーブルの圧縮を分析できます。テーブルをそのスキーマ名で修飾することができます。また、*table\$1name* を指定して単一のテーブルを分析することもできます。*table\$1name* を指定しなかった場合、現在接続されているデータベースがすべて分析されます。1 つの ANALYZE COMPRESSION ステートメントで複数の *table\$1name* を指定することはできません。
*column\$1name*
*table\$1name* を指定する場合、テーブルの 1 つ以上の列を指定することもできます (括弧内に列をカンマ区切りリストとして指定します)。
COMPROWS
圧縮分析のサンプルサイズとして使用される行数。分析は各データスライスの行に対して実行されます。例えば、COMPROWS 1000000 (1,000,000) を指定し、システムに合計 4 つのスライスが含まれている場合、スライスごとに 250,000 行のみが読み取られ、分析されます。COMPROWS を指定しない場合、サンプルサイズはデフォルトでスライスごとに 100,000 になります。COMPROWS の値がスライスごとに 100,000 行のデフォルト値より小さい場合、自動的にデフォルト値にアップグレードされます。ただし、テーブルのデータが不十分であるため有意のサンプルを作成できない場合、圧縮分析では推奨を作成しません。COMPROWS 数がテーブルの行数より大きい場合でも、ANALYZE COMPRESSION コマンドは続行し、利用可能なすべての行に対して圧縮分析を実行します。テーブルが指定されていない場合、COMPROWS を使用するとエラーが発生します。
*numrows*
圧縮分析のサンプルサイズとして使用される行数。*numrows* の許容範囲は 1000～1000000000 (1,000,000,000) の数値です。
## 使用に関する注意事項
ANALYZE COMPRESSION は排他的テーブルロックを取得し、テーブルに対する同時読み取り書き込みが防止されます。ANALYZE COMPRESSION コマンドは、テーブルがアイドル状態になっている場合にのみ実行してください。
テーブルの内容サンプルに基づいて推奨列エンコードスキームを取得するには、ANALYZE COMPRESSION を実行します。ANALYZE COMPRESSION はアドバイスツールであり、テーブルの列エンコードは変更しません。推奨エンコードは、テーブルを再作成するか、同じスキーマを持つ新しいテーブルを作成することにより適用できます。適切なエンコードスキームを使用して未圧縮テーブルを再作成すると、オンディスクフットプリントを大幅に減らすことができます。このアプローチにより、ディスクスペースを節約でき、I/O 関連ワークロードのクエリパフォーマンスが向上します。
ANALYZE COMPRESSION は、実際の分析フェーズをスキップし、SORTKEY として指定されている任意の列で元のエンコードタイプを直接返します。これは、SORTKEY 列が他の列よりも大幅に圧縮されている場合に、範囲制限されたスキャンのパフォーマンスが低下する可能性があるためです。
## 例
次の例は、LISTING テーブルのみの列に対するエンコードおよび推定減少パーセントを示しています。
```
analyze compression listing;
Table | Column | Encoding | Est_reduction_pct
---------+----------------+----------+-------------------
listing | listid | az64 | 40.96
listing | sellerid | az64 | 46.92
listing | eventid | az64 | 53.37
listing | dateid | raw | 0.00
listing | numtickets | az64 | 65.66
listing | priceperticket | az64 | 72.94
listing | totalprice | az64 | 68.05
listing | listtime | az64 | 49.74
```
次の例は､SALES テーブルの QTYSOLD、COMMISSION、SALETIME の各列を分析します。
```
analyze compression sales(qtysold, commission, saletime);
Table | Column | Encoding | Est_reduction_pct
-------+------------+----------+-------------------
sales | salesid | N/A | 0.00
sales | listid | N/A | 0.00
sales | sellerid | N/A | 0.00
sales | buyerid | N/A | 0.00
sales | eventid | N/A | 0.00
sales | dateid | N/A | 0.00
sales | qtysold | az64 | 83.06
sales | pricepaid | N/A | 0.00
sales | commission | az64 | 71.85
sales | saletime | az64 | 49.63
```
# ATTACH MASKING POLICY
既存の動的データマスキングポリシーを列にアタッチします。動的データマスキングの詳細については、「[動的データマスキング](t_ddm.md)」を参照してください。
スーパーユーザーと sys:secadmin ロールを持つユーザーまたはロールは、マスキングポリシーをアタッチできます。
## 構文
```
ATTACH MASKING POLICY
{
policy_name ON relation_name
| database_name.policy_name ON database_name.schema_name.relation_name
}
( { output_column_names | output_path } )
[ USING ( { input_column_names | input_path } ) ]
TO { user_name | ROLE role_name | PUBLIC }
[ PRIORITY priority ];
```
## パラメータ
*policy\$1name*
アタッチするマスキングポリシーの名前。
database\$1name
ポリシーとリレーションが作成されるデータベースの名前。ポリシーとリレーションは同じデータベースに存在する必要があります。データベースは、接続されたデータベースでも、Amazon Redshift フェデレーティッドアクセス許可をサポートするデータベースでもかまいません。
schema\$1name
リレーションが属するスキーマの名前。
*relation\$1name*
マスキングポリシーをアタッチするリレーションの名前。
*output\$1column\$1names*
マスキングポリシーが適用される列の名前。
*output\$1paths*
マスキングポリシーが適用される SUPER オブジェクトのフルパス (列名を含む)。例えば、`person` という SUPER 型の列を使用したリレーションの場合、*output\$1path* は `person.name.first_name` になります。
*input\$1column\$1names*
マスキングポリシーが入力として受け取る列の名前。このパラメータはオプションです。指定しない場合、マスキングポリシーは *output\$1column\$1names* を入力として使用します。
*input\$1paths*
マスキングポリシーが入力として受け取る SUPER オブジェクトのフルパス。このパラメータはオプションです。指定しない場合、マスキングポリシーは *output\$1path* を入力に使用します。
*user\$1name*
マスキングポリシーをアタッチするユーザーの名前。ユーザーと列、またはロールと列の同じ組み合わせに 2 つのポリシーをアタッチすることはできません。ポリシーをユーザーに、別のポリシーをユーザーのロールにアタッチできます。この場合、優先度の高いポリシーが適用されます。
1 回の ATTACH MASKING POLICY コマンドで設定できるのは、user\$1name、role\$1name、PUBLIC のいずれか 1 つのみです。
*role\$1name*
マスキングポリシーがアタッチされるロールの名前。同じ列/ロールのペアに 2 つのポリシーをアタッチすることはできません。ポリシーをユーザーに、別のポリシーをユーザーのロールにアタッチできます。この場合、優先度の高いポリシーが適用されます。
1 回の ATTACH MASKING POLICY コマンドで設定できるのは、user\$1name、role\$1name、PUBLIC のいずれか 1 つのみです。
*PUBLIC*
テーブルにアクセスするすべてのユーザーにマスキングポリシーをアタッチします。特定の列/ユーザーまたは列/ロールのペアにアタッチされている他のマスキングポリシーを適用するには、PUBLIC ポリシーよりも高い優先度を設定する必要があります。
1 回の ATTACH MASKING POLICY コマンドで設定できるのは、user\$1name、role\$1name、PUBLIC のいずれか 1 つのみです。
*priority*
マスキングポリシーの優先度。特定のユーザーのクエリに複数のマスキングポリシーが適用される場合、最も優先度の高いポリシーが適用されます。
2 つの異なるポリシーを同じ優先順位で同じ列にアタッチすることはできません。2 つの異なるポリシーが別々のユーザーまたはロールにアタッチされている場合でも同様です。ポリシーをアタッチするユーザーまたはロールが毎回異なる場合に限り、同じポリシーを同じテーブル、出力列、入力列、優先度のパラメータのセットに複数回アタッチできます。
ロールが異なっていても、その列にアタッチされている別のポリシーと同じ優先度の列にポリシーを適用することはできません。このフィールドはオプションです。優先度を指定しない場合、マスキングポリシーのアタッチの優先度はデフォルトで 0 に設定されます。
Amazon Redshift フェデレーティッドアクセス許可カタログでの ATTACH MASKING POLICY の使用については、[Amazon Redshift フェデレーティッドアクセス許可によるアクセスコントロールの管理](https://docs.aws.amazon.com/redshift/latest/dg/federated-permissions-managing-access.html)についての記事を参照してください。
# ATTACH RLS POLICY
行レベルのセキュリティポリシーをテーブルで 1 人以上のユーザーまたはロールにアタッチします。
スーパーユーザーとユーザー、または `sys:secadmin` ロールを持つロールは、ポリシーをアタッチできます。
## 構文
```
ATTACH RLS POLICY
{
policy_name ON [TABLE] table_name [, ...]
| database_name.policy_name ON [TABLE] database_name.schema_name.table_name [, ...]
}
TO { user_name | ROLE role_name | PUBLIC } [, ...]
```
## パラメータ
*policy\$1name*
ポリシーの名前。
database\$1name
ポリシーとリレーションが作成されるデータベースの名前。ポリシーとリレーションは同じデータベースに存在する必要があります。データベースは、接続されたデータベースでも、Amazon Redshift フェデレーティッドアクセス許可をサポートするデータベースでもかまいません。
schema\$1name
リレーションが属するスキーマの名前。
table\$1name
行レベルのセキュリティポリシーがアタッチされているリレーション。
TO \$1 *user\$1name* \$1 ROLE *role\$1name* \$1 PUBLIC\$1 [, ...]
ポリシーが指定した 1 つ以上のユーザーまたはロールにアタッチするかどうか指定します。
Amazon Redshift フェデレーティッドアクセス許可カタログでの ATTACH RLS ポリシーの使用については、[Amazon Redshift フェデレーティッドアクセス許可によるアクセスコントロールの管理](https://docs.aws.amazon.com/redshift/latest/dg/federated-permissions-managing-access.html)についての記事を参照してください。
## 使用に関する注意事項
ATTACH RLS POLICY ステートメントを使用する際、次の点に注意してください。
+ アタッチされるテーブルには、ポリシー作成ステートメントの WITH 句に一覧表示されているすべての列が含まれている必要があります。
+ Amazon Redshift RLS では、以下のオブジェクトに RLS ポリシーをアタッチできます。
+ テーブル
+ ビュー
+ 遅延バインドビュー
+ 具体化されたビュー
+ Amazon Redshift RLS は、以下のオブジェクトへの RLS ポリシーのアタッチをサポートしていません。
+ カタログテーブル
+ データベース間のリレーション
+ 外部テーブル
+ 一時テーブル
+ ポリシールックアップテーブル
+ マテリアライズドビューのベーステーブル
+ スーパーユーザーまたは `sys:secadmin` アクセス許可を持つユーザーにアタッチした RLS ポリシーは、無視されます。
## 例
次の例では、指定したテーブルとロールの組み合わせに RLS ポリシーをアタッチします。RLS ポリシーは、`analyst` または `dbadmin` のロールを持つユーザーが tickit\$1category\$1redshift テーブルにアクセスする場合に適用されます。
```
ATTACH RLS POLICY policy_concerts ON tickit_category_redshift TO ROLE analyst, ROLE dbadmin;
```
# BEGIN
トランザクションを開始します。START TRANSACTION と同義です。
トランザクションは、1 つのコマンドまたは複数のコマンドから構成される、1 つの論理的作業単位です。通常、1 つのトランザクションのすべてのコマンドはデータベースの 1 つのスナップショットに対して実行されます。その開始時刻は、システム設定パラメータ `transaction_snapshot_begin` に設定されている値によって決定されます。
デフォルトでは、個々の Amazon Redshift オペレーション (クエリ、DDL ステートメント、ロード) はデータベースに自動的にコミットされます。後続の作業が完了するまでオペレーションのコミットを停止する場合、BEGIN ステートメントでトランザクションを開き、必要なコマンドを実行し、[COMMIT](r_COMMIT.md)または [END](r_END.md) ステートメントでトランザクションを閉じます。必要に応じて、[ROLLBACK](r_ROLLBACK.md)ステートメントを使用して、進行中のトランザクションを停止できます。この動作の例外は [TRUNCATE](r_TRUNCATE.md) コマンドです。このコマンドは実行されているトランザクションをコミットします。ロールバックすることはできません。
## 構文
```
BEGIN [ WORK | TRANSACTION ] [ ISOLATION LEVEL option ] [ READ WRITE | READ ONLY ]
START TRANSACTION [ ISOLATION LEVEL option ] [ READ WRITE | READ ONLY ]
Where option is
SERIALIZABLE
| READ UNCOMMITTED
| READ COMMITTED
| REPEATABLE READ
Note: READ UNCOMMITTED, READ COMMITTED, and REPEATABLE READ have no
operational impact and map to SERIALIZABLE in Amazon Redshift. You can see database isolation levels on your cluster
by querying the stv_db_isolation_level table.
```
## パラメータ
WORK
オプションキーワード
TRANSACTION
オプションキーワード。WORK と TRANSACTION は同義語です。
ISOLATION LEVEL SERIALIZABLE
デフォルトで直列化可能な分離がサポートされているため、この構文がステートメントに含まれているかどうかに関係なく、トランザクションの動作は同じです。詳細については、「[同時書き込み操作を管理する](c_Concurrent_writes.md)」を参照してください。他の分離レベルはサポートされていません。
SQL 標準では、以下の状態を避けるため、4 つのレベルのトランザクション分離を定義しています: *ダーティリード* (トランザクションが未コミットの同時トランザクションによって書き込まれたデータを読み取ります)、*非再現リード* (トランザクションが以前に読み取ったデータを再読み取りし、初回読み取り後にコミットされた別のトランザクションによってデータが変更されたことを検出します)、および*ファントムリード* (トランザクションがクエリを再実行し、検索条件を満たす行セットを返した後、最近コミットされた別のトランザクションのために行セットが変更されていることを検出します)。
+ 未コミット読み取り: ダーティリード、非再現リード、およびファントムリードの可能性があります。
+ コミット済み読み取り: 非再現リードおよびファントムリードの可能性があります。
+ 再現可能読み取り: ファントムリードの可能性があります。
+ 直列化可能: ダーティリード、非再現リード、およびファントムリードを防止します。
4 つのトランザクション分離レベルのいずれも使用できますが、Amazon Redshift ではすべての分離レベルを直列化可能として処理します。
READ WRITE
トランザクションに読み取り書き込み権限を与えます。
READ ONLY
トランザクションに読み取り専用権限を与えます。
## 例
次の例では、直列化可能なトランザクションブロックを開始します。
```
begin;
```
次の例では、直列化可能分離レベルと読み取り書き込み権限を持つトランザクションブロックを開始します。
```
begin read write;
```
# CALL
ストアドプロシージャを実行します。CALL コマンドには、プロシージャ名と入力引数の値を含める必要があります。CALL ステートメントを使用してストアドプロシージャを呼び出す必要があります。
**注記**
CALL を通常のクエリの一部にすることはできません。
## 構文
```
CALL sp_name ( [ argument ] [, ...] )
```
## パラメータ
*sp\$1name*
実行するプロシージャの名前。
*argument*
入力引数の値。このパラメータは、関数名 (`pg_last_query_id()`) とすることもできます。クエリは CALL の引数として使用できません。
## 使用に関する注意事項
Amazon Redshift のストアドプロシージャは、以下に説明するように、ネストされた呼び出しと再帰呼び出しをサポートしています。さらに、以下に説明するように、ドライバーのサポートが最新であることを確認します。
**Topics**
+ [ネストされた呼び出し](#r_CALL_procedure-nested-calls)
+ [ドライバーのサポート](#r_CALL_procedure-driver-support)
### ネストされた呼び出し
Amazon Redshift のストアドプロシージャは、ネストされた呼び出しと再帰呼び出しをサポートしています。ネストレベルの最大許容数は 16 です。ネストされた呼び出しは、ビジネスロジックをより小さいプロシージャにカプセル化できます。これらのプロシージャを複数の発信者が共有できます。
ネストされたプロシージャに出力パラメータが含まれていると、このプロシージャを呼び出す場合、内部プロシージャは INOUT 引数を定義する必要があります。この場合、内部プロシージャを非定数変数で渡す必要があります。OUT 引数は許可されません。この動作が発生するのは、内部呼び出しの出力を保持するために変数が必要であるためです。
内部プロシージャと外部プロシージャの関係は、[SVL\$1STORED\$1PROC\$1CALL](r_SVL_STORED_PROC_CALL.md)の `from_sp_call` 列に記録されます。
次の例は、INOUT 引数を通じて、ネストされたプロシージャ呼び出しに渡される変数を示しています。
```
CREATE OR REPLACE PROCEDURE inner_proc(INOUT a int, b int, INOUT c int) LANGUAGE plpgsql
AS $$
BEGIN
a := b * a;
c := b * c;
END;
$$;
CREATE OR REPLACE PROCEDURE outer_proc(multiplier int) LANGUAGE plpgsql
AS $$
DECLARE
x int := 3;
y int := 4;
BEGIN
DROP TABLE IF EXISTS test_tbl;
CREATE TEMP TABLE test_tbl(a int, b varchar(256));
CALL inner_proc(x, multiplier, y);
insert into test_tbl values (x, y::varchar);
END;
$$;
CALL outer_proc(5);
SELECT * from test_tbl;
a | b
----+----
15 | 20
(1 row)
```
### ドライバーのサポート
Java Database Connectivity (JDBC) ドライバーと Open Database Connectivity (ODBC) ドライバーを、Amazon Redshift のストアドプロシージャをサポートする最新バージョンにアップグレードすることをお勧めします。
クライアントツールで使用しているドライバーの API オペレーションが CALL ステートメントをサーバーにパススルーする場合は、既存のドライバーを使用できることがあります。出力パラメータ (ある場合) は、1 行の結果セットとして返されます。
最新バージョンの Amazon Redshift JDBC ドライバーと ODBC ドライバーには、ストアドプロシージャを検出するためのメタデータサポートが含まれています。カスタム Java アプリケーション用の `CallableStatement` サポートも含まれています。ドライバーの詳細については、「*Amazon Redshift 管理ガイド*」の「[SQL クライアントツールを使用して Amazon Redshift クラスターに接続する](https://docs.aws.amazon.com/redshift/latest/mgmt/connecting-to-cluster.html)」を参照してください。
以下の例は、ストアドプロシージャ呼び出しで JDBC ドライバーの複数の異なる API オペレーションを使用する方法を示しています。
```
void statement_example(Connection conn) throws SQLException {
statement.execute("CALL sp_statement_example(1)");
}
void prepared_statement_example(Connection conn) throws SQLException {
String sql = "CALL sp_prepared_statement_example(42, 84)";
PreparedStatement pstmt = conn.prepareStatement(sql);
pstmt.execute();
}
void callable_statement_example(Connection conn) throws SQLException {
CallableStatement cstmt = conn.prepareCall("CALL sp_create_out_in(?,?)");
cstmt.registerOutParameter(1, java.sql.Types.INTEGER);
cstmt.setInt(2, 42);
cstmt.executeQuery();
Integer out_value = cstmt.getInt(1);
}
```
## 例
次の例では、プロシージャ名 `test_spl` を呼び出します。
```
call test_sp1(3,'book');
INFO: Table "tmp_tbl" does not exist and will be skipped
INFO: min_val = 3, f2 = book
```
次の例では、プロシージャ名 `test_spl2` を呼び出します。
```
call test_sp2(2,'2019');
f2 | column2
---------------------+---------
2019+2019+2019+2019 | 2
(1 row)
```
# CANCEL
現在実行中のデータベースクエリをキャンセルします。
CANCEL コマンドは実行中のクエリのプロセス ID またはセッション ID を必要とし、クエリがキャンセルされたことを確認する確認メッセージを表示します。
## 必要な権限
CANCEL に必要な権限を以下に示します。
+ 自身のクエリをキャンセルしているスーパーユーザー
+ ユーザーのクエリをキャンセルしているスーパーユーザー
+ CANCEL の権限を持ち、ユーザーのクエリをキャンセルしているユーザー
+ 自身のクエリをキャンセルしているユーザー
## 構文
```
CANCEL process_id [ 'message' ]
```
## パラメータ
*process\$1id*
Amazon Redshift クラスターで実行されているクエリをキャンセルするには、キャンセルするクエリに対応する [STV\$1RECENTS](r_STV_RECENTS.md) の `pid` (プロセス ID) を使用します。
Amazon Redshift Serverless ワークグループで実行されているクエリをキャンセルするには、キャンセルするクエリに対応する [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) の `session_id` を使用します。
'*message*'
オプションの確認メッセージ。クエリのキャンセルが完了したときに表示されます。メッセージを指定しなかった場合、Amazon Redshift は確認としてデフォルトメッセージを表示します。メッセージは一重引用符で囲む必要があります。
## 使用に関する注意事項
クエリ ID **を指定してクエリをキャンセルすることはできません。クエリの**プロセス ID (PID) またはセッション ID **を指定する必要があります。ユーザーによって現在実行されているクエリのみキャンセルできます。スーパーユーザーはすべてのクエリをキャンセルできます。
複数のセッション内のクエリが同じテーブルでロックを保持する場合は、[PG\$1TERMINATE\$1BACKEND](PG_TERMINATE_BACKEND.md) 関数を使用してセッションの 1 つを終了できます。これを行うと、終了したセッションで現在実行されているトランザクションがすべてのロックを解除し、トランザクションがロールバックされます。[STV\$1LOCKS](r_STV_LOCKS.md) システムテーブルに対してクエリを実行して、現在保持しているロックを表示します。
Amazon Redshift は特定の内部イベントに続いてアクティブなセッションを再起動し、新しい PID を割り当てる場合があります。PID が変更されている場合は、次のようなエラーメッセージが表示されることがあります。
```
Session does not exist. The session PID might have changed. Check the stl_restarted_sessions system table for details.
```
新しい PID を見つけるには、[STL\$1RESTARTED\$1SESSIONS](r_STL_RESTARTED_SESSIONS.md)システムテーブルに対してクエリを実行し、`oldpid`列でフィルタリングします。
```
select oldpid, newpid from stl_restarted_sessions where oldpid = 1234;
```
## 例
Amazon Redshift クラスターで現在実行されているクエリをキャンセルするには、キャンセルするクエリのプロセス ID を最初に取得します。現在実行されているすべてのクエリのプロセス ID を確認するには、次のコマンドを入力します。
```
select pid, starttime, duration,
trim(user_name) as user,
trim (query) as querytxt
from stv_recents
where status = 'Running';
pid | starttime | duration | user | querytxt
-----+----------------------------+----------+----------+-----------------
802 | 2008-10-14 09:19:03.550885 | 132 | dwuser | select
venuename from venue where venuestate='FL', where venuecity not in
('Miami' , 'Orlando');
834 | 2008-10-14 08:33:49.473585 | 1250414 | dwuser | select *
from listing;
964 | 2008-10-14 08:30:43.290527 | 326179 | dwuser | select
sellerid from sales where qtysold in (8, 10);
```
クエリテキストをチェックし、キャンセルするクエリに対応するプロセス ID (PID) を確認します。
次のコマンドを入力して、PID 802 を使用してクエリをキャンセルします。
```
cancel 802;
```
クエリが実行されていたセッションは、次のメッセージを表示します。
```
ERROR: Query (168) cancelled on user's request
```
ここでは、`168`はクエリ ID です (クエリをキャンセルするために使用されるプロセス ID ではありません)。
また、デフォルトメッセージの代わりに表示するカスタム確認メッセージを指定することもできます。カスタムメッセージを指定するには、CANCEL コマンドの最後に一重引用符で囲んだメッセージを付けます。
```
cancel 802 'Long-running query';
```
クエリが実行されていたセッションは、次のメッセージを表示します。
```
ERROR: Long-running query
```
# CLOSE
(オプション) 開いているカーソルと関連付けられたすべての空きリソースを閉じます。[COMMIT](r_COMMIT.md)、[END](r_END.md)、および [ROLLBACK](r_ROLLBACK.md) は自動的にカーソルを閉じるため、CLOSE コマンドを使用して明示的にカーソルを閉じる必要はありません。
詳細については、「[DECLARE](declare.md)」、「[FETCH](fetch.md)」を参照してください。
## 構文
```
CLOSE cursor
```
## パラメータ
*cursor*
閉じるカーソルの名前。
## CLOSE の例
次のコマンドはカーソルを閉じ、コミットを実行してトランザクションを終了します。
```
close movie_cursor;
commit;
```
# COMMENT
データベースオブジェクトに関するコメントを作成するか変更します。
## 構文
```
COMMENT ON
{
TABLE object_name |
COLUMN object_name.column_name |
CONSTRAINT constraint_name ON table_name |
DATABASE object_name |
VIEW object_name
}
IS 'text' | NULL
```
## パラメータ
*object\$1name*
コメント対象のデータベースオブジェクトの名前。コメントは次のオブジェクトに追加できます。
+ TABLE
+ COLUMN (*column\$1name* も取ります)
+ CONSTRAINT (*constraint\$1name* と *table\$1name* も取ります)
+ DATABASE
+ VIEW
+ SCHEMA
IS '*text*' \$1 NULL
指定したオブジェクトに追加または置換するコメントテキスト。*テキスト*文字列のデータ型は TEXT です。コメントは一重引用符で囲みます。コメントテキストを削除するには、値を NULL に設定します。
*column\$1name*
コメント対象の列の名前。COLUMN のパラメータ。`object_name` で指定するテーブルの後に指定します。
*constraint\$1name*
コメント対象の制約の名前。CONSTRAINT のパラメータ。
*table\$1name*
制約を含むテーブルの名前。CONSTRAINT のパラメータ。
## 使用に関する注意事項
コメントを追加または更新するには、スーパーユーザーまたはデータベースオブジェクトの所有者である必要があります。
データベースに関するコメントは現在のデータベースにのみ適用できます。異なるデータベースにコメントしようとすると、警告メッセージが表示されます。存在しないデータベースに関するコメントに対しても、同じ警告が表示されます。
外部テーブル、外部列、遅延バインドビューの列に関するコメントはサポートされていません。
## 例
次の使用例は、SALES テーブルにコメントを追加します。
```
COMMENT ON TABLE sales IS 'This table stores tickets sales data';
```
次の使用例は、SALES テーブルにコメントを追加します。
```
select obj_description('public.sales'::regclass);
obj_description
-------------------------------------
This table stores tickets sales data
```
次の使用例は、SALES テーブルからコメントを削除します。
```
COMMENT ON TABLE sales IS NULL;
```
次の使用例は、SALES テーブルの EVENTID 列にコメントを追加します。
```
COMMENT ON COLUMN sales.eventid IS 'Foreign-key reference to the EVENT table.';
```
次の使用例は、SALES テーブルの EVENTID 列 (列番号 5) にコメントを表示します。
```
select col_description( 'public.sales'::regclass, 5::integer );
col_description
-----------------------------------------
Foreign-key reference to the EVENT table.
```
次の例では、説明的なコメントを EVENT テーブルに追加します。
```
comment on table event is 'Contains listings of individual events.';
```
コメントを表示するには、PG\$1DESCRIPTION システムカタログをクエリします。次の例は、EVENT テーブルの説明を返します。
```
select * from pg_catalog.pg_description
where objoid =
(select oid from pg_class where relname = 'event'
and relnamespace =
(select oid from pg_catalog.pg_namespace where nspname = 'public') );
objoid | classoid | objsubid | description
-------+----------+----------+----------------------------------------
116658 | 1259 | 0 | Contains listings of individual events.
```
# COMMIT
現在のトランザクションをデータベースにコミットします。このコマンドはトランザクションからのデータベース更新を永続的なものにします。
## 構文
```
COMMIT [ WORK | TRANSACTION ]
```
## パラメータ
WORK
オプションキーワード このキーワードは、ストアドプロシージャ内ではサポートされていません。
TRANSACTION
オプションキーワード WORK と TRANSACTION は同義語です。ストアドプロシージャ内ではいずれもサポートされていません。
ストアドプロシージャ内での COMMIT の使用方法については、[トランザクションの管理](stored-procedure-transaction-management.md)を参照してください。
## 例
次の各例では、現在のトランザクションをデータベースにコミットします。
```
commit;
```
```
commit work;
```
```
commit transaction;
```
# COPY
| |
| --- |
| COPY コマンドと UNLOAD コマンドのクライアント側の暗号化は、2025 年 4 月 30 日以降、新規のお客様は利用できなくなります。2025 年 4 月 30 日より前の 12 か月間に COPY コマンドと UNLOAD コマンドでクライアント側の暗号化を使用していた場合、2026 年 4 月 30 日までは COPY コマンドまたは UNLOAD コマンドでクライアント側の暗号化を引き続き使用できます。2026 年 4 月 30 日を過ぎると、COPY と UNLOAD でクライアント側の暗号化を使用できなくなります。できるだけ早く COPY と UNLOAD でサーバー側の暗号化を使用するよう切り替えることをお勧めします。COPY と UNLOAD でサーバー側の暗号化を既に使用している場合、変更はなく、クエリを変更せずに引き続き使用できます。COPY と UNLOAD の暗号化の詳細については、以下の ENCRYPTED パラメータを参照してください。 |
データファイルまたは Amazon DynamoDB テーブルから、テーブルにデータをロードします。ファイルは Amazon Simple Storage Service (Amazon S3) バケット、Amazon EMR クラスターまたは Secure Shell (SSH) 接続を使用したリモートホストに配置できます。
**注記**
Amazon Redshift Spectrum の外部テーブルは読み込み専用です。外部テーブルには COPY できません。
COPY コマンドは、入力データを追加の行としてテーブルに付加します。
どのソースからであっても、単一の入力行の最大サイズは 4 MB です。
**Topics**
+ [必要なアクセス許可](#r_COPY-permissions)
+ [COPY 構文](#r_COPY-syntax)
+ [必須パラメータ](#r_COPY-syntax-required-parameters)
+ [任意指定のパラメータ](#r_COPY-syntax-overview-optional-parameters)
+ [COPY コマンドの使用上の注意とその他のリソース](#r_COPY-using-the-copy-command)
+ [COPY コマンドの例](#r_COPY-using-the-copy-command-examples)
+ [COPY JOB](r_COPY-JOB.md)
+ [テンプレートを使用したコピー](r_COPY-WITH-TEMPLATE.md)
+ [COPY パラメータリファレンス](r_COPY-parameters.md)
+ [使用に関する注意事項](r_COPY_usage_notes.md)
+ [COPY の例](r_COPY_command_examples.md)
## 必要なアクセス許可
COPY コマンドを使用するには、Amazon Redshift テーブルに対する [INSERT](r_GRANT.md#grant-insert) 権限が必要です。
## COPY 構文
```
COPY table-name
[ column-list ]
FROM data_source
authorization
[ [ FORMAT ] [ AS ] data_format ]
[ parameter [ argument ] [, ... ] ]
```
テーブル名、データソース、データにアクセスするための許可のわずか 3 つのパラメータで COPY オペレーションを実行できます。
Amazon Redshift は COPY コマンドの機能を拡張し、マルチデータソースから複数のサービスデータ形式でのデータのロード、ロードデータへのアクセス制御、データ変換の管理、ロードオペレーションの管理を可能にします。
以下のセクションでは、COPY コマンドの必須パラメータと、機能別に分類したオプションのパラメータを示します。また、各パラメータについて説明し、さまざまなオプションがどのように連携するかについても説明します。アルファベット順のパラメータリストを使用すると、パラメータの説明に直接移動できます。
## 必須パラメータ
COPY コマンドには 3 つの要素が必要です。
+ [Table Name](#r_COPY-syntax-overview-table-name)
+ [Data Source](#r_COPY-syntax-overview-data-source)
+ [Authorization](#r_COPY-syntax-overview-credentials)
最も単純な COPY コマンドは次の形式を使用します。
```
COPY table-name
FROM data-source
authorization;
```
次の例では、CATDEMO というテーブルを作成し、Amazon S3 の `category_pipe.txt` というデータファイルからサンプルデータを含むテーブルをロードします。
```
create table catdemo(catid smallint, catgroup varchar(10), catname varchar(10), catdesc varchar(50));
```
以下の例では、COPY コマンドのデータソースは、`redshift-downloads`という名前の Amazon S3 バケットの `tickit` フォルダ内の `category_pipe.txt` というデータファイルです。COPY コマンドには、AWS Identity and Access Management(IAM) ロールを通して、Amazon S3 バケットにアクセスすることが許可されています。クラスターに Amazon S3 にアクセスする権限を持つ既存の IAM ロールがある場合、次の COPY コマンドに ロールの Amazon Resource Name (ARN) を置換して実行できます。
```
copy catdemo
from 's3://redshift-downloads/tickit/category_pipe.txt'
iam_role 'arn:aws:iam:::role/'
region 'us-east-1';
```
他の AWS リージョンからデータをロードする手順など、COPY コマンドを使用してサンプルデータをロードする方法の詳細については、「Amazon Redshift 入門ガイド」の「[Amazon S3 からサンプルデータをロードする](https://docs.aws.amazon.com/redshift/latest/gsg/rs-gsg-create-sample-db.html)」を参照してください。
*table-name*
COPY コマンドのターゲットテーブル名です。テーブルはすでにデータベースに存在する必要があります。テーブルは一時テーブルまたは永続的テーブルです。COPY コマンドは、新しい入力データをテーブルの既存の行に追加します。
FROM *data\$1source*
ターゲットテーブルにロードするソースデータの場所です。マニフェストファイルは、いくつかのデータソースで指定できます。
最もよく使われるデータリポジトリは Amazon S3 バケットです。Amazon EMR クラスター、Amazon EC2 インスタンス、またはクラスターが SSH 接続を使用してアクセスできるリモートホストにあるデータファイルからロードすることもできます。または、DynamoDB テーブルから直接ロードすることもできます。
+ [Amazon S3 からの COPY](copy-parameters-data-source-s3.md)
+ [Amazon EMR からの COPY](copy-parameters-data-source-emr.md)
+ [リモートホスト (SSH) からの COPY](copy-parameters-data-source-ssh.md)
+ [Amazon DynamoDB からの COPY](copy-parameters-data-source-dynamodb.md)
承認
他の AWS リソースにアクセスするための承認と許可のために、クラスターが使用する方法を示す句。COPY コマンドが、他の AWS リソース (Amazon S3、Amazon EMR、Amazon DynamoDB、Amazon EC2 など) のデータにアクセスするにためには承認が必要です。クラスターにアタッチされた IAM ロールを参照して、または IAM ユーザーのアクセスキー ID とシークレットアクセスキーを提供して、そのアクセス権限を提供できます。
+ [認可パラメータ](copy-parameters-authorization.md)
+ [ロールベースアクセスコントロール](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based)
+ [キーベースのアクセスコントロール](copy-usage_notes-access-permissions.md#copy-usage_notes-access-key-based)
## 任意指定のパラメータ
オプションで、COPY でターゲットテーブルの列にフィールドデータをマッピングする方法の指定、COPY コマンドで正しく読み込み解析できるソースデータ属性の定義、ロード処理中に COPY コマンドが実行する操作の管理ができます。
+ [列のマッピングオプション](copy-parameters-column-mapping.md)
+ [データ形式パラメータ](#r_COPY-syntax-overview-data-format)
+ [データ変換パラメータ](#r_COPY-syntax-overview-data-conversion)
+ [データのロード操作](#r_COPY-syntax-overview-data-load)
### 列のマッピング
デフォルトでは、COPY はデータファイルで発生したフィールドと同じ順序でターゲットテーブルの列にフィールド値を挿入します。デフォルトの列順序が機能しない場合は、列リストを指定するか、JSONPath 式を使用してソースデータフィールドをターゲット列にマッピングできます。
+ [Column List](copy-parameters-column-mapping.md#copy-column-list)
+ [JSONPaths File](copy-parameters-column-mapping.md#copy-column-mapping-jsonpaths)
### データ形式パラメータ
固定幅、文字区切り形式、カンマ区切り値 (CSV) のテキストファイル、JSON 形式、または Avro ファイルからデータをロードできます。
デフォルトでは、COPY コマンドはソースデータを文字区切り形式 UTF-8 のテキストファイルと見なします。デフォルトの区切り文字はパイプ文字です。ソースデータが別の形式である場合は、以下のパラメータを使用してデータ形式を指定します。
+ [FORMAT](copy-parameters-data-format.md#copy-format)
+ [CSV](copy-parameters-data-format.md#copy-csv)
+ [DELIMITER](copy-parameters-data-format.md#copy-delimiter)
+ [FIXEDWIDTH](copy-parameters-data-format.md#copy-fixedwidth)
+ [SHAPEFILE](copy-parameters-data-format.md#copy-shapefile)
+ [AVRO](copy-parameters-data-format.md#copy-avro)
+ [JSON format for COPY](copy-parameters-data-format.md#copy-json)
+ [ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted)
+ [BZIP2](copy-parameters-file-compression.md#copy-bzip2)
+ [GZIP](copy-parameters-file-compression.md#copy-gzip)
+ [LZOP](copy-parameters-file-compression.md#copy-lzop)
+ [PARQUET](copy-parameters-data-format.md#copy-parquet)
+ [ORC](copy-parameters-data-format.md#copy-orc)
+ [ZSTD](copy-parameters-file-compression.md#copy-zstd)
### データ変換パラメータ
テーブルをロードする際に、COPY は暗黙的にソースデータの文字列をターゲット列のデータ型に変換しようとします。デフォルトの動作とは異なる変換を指定する必要がある場合、またはデフォルトの変換がエラーになった場合、次のパラメータを指定してデータ変換を管理できます。
+ [ACCEPTANYDATE](copy-parameters-data-conversion.md#copy-acceptanydate)
+ [ACCEPTINVCHARS](copy-parameters-data-conversion.md#copy-acceptinvchars)
+ [BLANKSASNULL](copy-parameters-data-conversion.md#copy-blanksasnull)
+ [DATEFORMAT](copy-parameters-data-conversion.md#copy-dateformat)
+ [EMPTYASNULL](copy-parameters-data-conversion.md#copy-emptyasnull)
+ [ENCODING](copy-parameters-data-conversion.md#copy-encoding)
+ [ESCAPE](copy-parameters-data-conversion.md#copy-escape)
+ [EXPLICIT_IDS](copy-parameters-data-conversion.md#copy-explicit-ids)
+ [FILLRECORD](copy-parameters-data-conversion.md#copy-fillrecord)
+ [IGNOREBLANKLINES](copy-parameters-data-conversion.md#copy-ignoreblanklines)
+ [IGNOREHEADER](copy-parameters-data-conversion.md#copy-ignoreheader)
+ [NULL AS](copy-parameters-data-conversion.md#copy-null-as)
+ [REMOVEQUOTES](copy-parameters-data-conversion.md#copy-removequotes)
+ [ROUNDEC](copy-parameters-data-conversion.md#copy-roundec)
+ [TIMEFORMAT](copy-parameters-data-conversion.md#copy-timeformat)
+ [TRIMBLANKS](copy-parameters-data-conversion.md#copy-trimblanks)
+ [TRUNCATECOLUMNS](copy-parameters-data-conversion.md#copy-truncatecolumns)
### データのロード操作
次のパラメータを指定して、トラブルシューティングの際のロード操作のデフォルトの動作を管理したり、ロード時間を短縮します。
+ [COMPROWS](copy-parameters-data-load.md#copy-comprows)
+ [COMPUPDATE](copy-parameters-data-load.md#copy-compupdate)
+ [IGNOREALLERRORS](copy-parameters-data-load.md#copy-ignoreallerrors)
+ [MAXERROR](copy-parameters-data-load.md#copy-maxerror)
+ [NOLOAD](copy-parameters-data-load.md#copy-noload)
+ [STATUPDATE](copy-parameters-data-load.md#copy-statupdate)
## COPY コマンドの使用上の注意とその他のリソース
COPY コマンドの使用方法の詳細については、次のトピックを参照してください。
+ [使用に関する注意事項](r_COPY_usage_notes.md)
+ [チュートリアル: Amazon S3 からデータをロードする](tutorial-loading-data.md)
+ [データをロードするための Amazon Redshift のベストプラクティス](c_loading-data-best-practices.md)
+ [COPY コマンドを使ってテーブルをロードする](t_Loading_tables_with_the_COPY_command.md)
+ [Amazon S3 からデータをロードする](t_Loading-data-from-S3.md)
+ [Amazon EMR からのデータのロード](loading-data-from-emr.md)
+ [リモートホストからデータをロードする](loading-data-from-remote-hosts.md)
+ [Amazon DynamoDB テーブルからのデータのロード](t_Loading-data-from-dynamodb.md)
+ [データロードのトラブルシューティング](t_Troubleshooting_load_errors.md)
## COPY コマンドの例
さまざまなソースから、異なる形式で、さまざまな COPY オプションを使用して COPY を実行する方法を示すその他の例については、「[COPY の例](r_COPY_command_examples.md)」を参照してください。
# COPY JOB
このコマンドの使用の詳細については、「[S3 イベント統合を作成して Amazon S3 バケットからファイルを自動的にコピーする](loading-data-copy-job.md)」を参照してください。
データをテーブルにロードする COPY コマンドを管理します。COPY JOB コマンドは COPY コマンドの拡張であり、Amazon S3 バケットからのデータロードを自動化します。COPY ジョブを作成すると、Amazon Redshift は、指定されたパスに新しい Amazon S3 ファイルが作成されたことを検出し、ユーザーの操作なしで自動的にロードします。データをロードするときには、元の COPY コマンドで使用されているのと同じパラメータが使用されます。Amazon Redshift は、ロードされたファイルを (ファイル名に基づいて) 追跡し、ロードされたのが 1 回だけであることを確認します。
**注記**
使用方法、パラメータ、権限など、COPY コマンドの詳細については、「[COPY](r_COPY.md)」を参照してください。
## 必要なアクセス許可
COPY JOB コマンドを使用するには、COPY を使用するために必要なすべてのアクセス許可に加えて、以下のいずれかのアクセス許可が必要です。
+ スーパーユーザー
+ 以下のすべて:
+ COPY 先のデータベース内の COPY JOBS に関連する CREATE、ALTER、または DROP の範囲指定されたアクセス許可。
+ COPY 先のスキーマの USAGE アクセス許可、または COPY 先のデータベース内のスキーマに対する USAGE の範囲指定されたアクセス許可。
+ COPY 先のテーブルの INSERT アクセス許可、または COPY 先のスキーマまたはデータベース内のテーブルに対する INSERT の範囲指定されたアクセス許可。
COPY コマンドで指定した IAM ロールにはロードするデータへのアクセス権限が必要です。詳細については、「[COPY、UNLOAD、CREATE LIBRARY のための IAM のアクセス許可](copy-usage_notes-access-permissions.md#copy-usage_notes-iam-permissions)」を参照してください。
## 構文
コピージョブを作成します。COPY コマンドのパラメータは、コピージョブと共に保存されます。
トランザクションブロックの範囲内で COPY JOB CREATE を実行することはできません。
```
COPY copy-command JOB CREATE job-name
[AUTO ON | OFF]
```
コピージョブの設定を変更します。
```
COPY JOB ALTER job-name
[AUTO ON | OFF]
```
コピージョブを実行します。保存されている COPY コマンドパラメータが使用されます。
```
COPY JOB RUN job-name
```
すべてのコピージョブを一覧表示します。
```
COPY JOB LIST
```
コピージョブの詳細を表示します。
```
COPY JOB SHOW job-name
```
コピージョブを削除します。
トランザクションブロックの範囲内で COPY JOB DROP を実行することはできません。
```
COPY JOB DROP job-name
```
## パラメータ
*copy-command*
Amazon S3 から Amazon Redshift にデータをロードする COPY コマンドです。この句には、Amazon S3 バケット、ターゲットテーブル、IAM ロール、およびデータをロードするときに使用されるその他のパラメータを定義する COPY パラメータが含まれています。Amazon S3 データロードの COPY コマンドパラメータは、以下を除いてすべてサポートされています。
+ COPY JOB は、COPY コマンドで指定されたフォルダー内の既存のファイルを取り込みません。COPY JOB 作成タイムスタンプ以降に作成されたファイルのみが取り込まれます。
+ COPY コマンドに対しては、MAXERROR オプションまたは IGNOREALLERRORS オプションを指定することはできません。
+ マニフェストファイルは指定できません。COPY JOB では、新しく作成されたファイルをモニタリングするために、指定された Amazon S3 ロケーションが必要です。
+ アクセスキーやシークレットキーなどの認可タイプで COPY コマンドを指定することはできません。この `IAM_ROLE` パラメータを認可に使用する COPY コマンドのみがサポートされます。詳細については、「[認可パラメータ](copy-parameters-authorization.md)」を参照してください。
+ COPY JOB は、クラスターに関連付けられたデフォルトの IAM ロールをサポートしていません。COPY コマンド内で `IAM_ROLE` を指定する必要があります。
詳細については、「[Amazon S3 からの COPY](copy-parameters-data-source-s3.md)」を参照してください。
*job-name*
COPY ジョブを参照するために使用されるジョブの名前です。[*job-name*] にハイフン (‐) を含めることはできません。
[AUTO ON \$1 OFF]
Amazon S3 データが Amazon Redshift テーブルに自動的にロードされるかどうかを示す句です。
+ `ON` の場合、Amazon Redshift はソースの Amazon S3 パスで新しく作成されたファイルをモニタリングし、見つかった場合は、ジョブ定義の COPY パラメータを使用して COPY コマンドが実行されます。これがデフォルトです。
+ `OFF` の場合、Amazon Redshift は COPY JOB を自動的に実行しません。
## 使用に関する注意事項
COPY コマンドのオプションは実行時まで検証されません。たとえば、無効な `IAM_ROLE` や Amazon S3 データソースがあると、COPY JOB の開始時にランタイムエラーが発生します。
クラスターが一時停止している場合、COPY JOB は実行されません。
ロードされた COPY コマンドファイルとロードエラーをクエリするには「[STL\$1LOAD\$1COMMITS](r_STL_LOAD_COMMITS.md)、[STL\$1LOAD\$1ERRORS](r_STL_LOAD_ERRORS.md)、[STL\$1LOADERROR\$1DETAIL](r_STL_LOADERROR_DETAIL.md)」を参照してください。詳細については、「[データが正しくロードされたことを確認する](verifying-that-data-loaded-correctly.md)」を参照してください。
COPY JOBS は読み取り専用モードで動作するため、ゼロ ETL データベースではサポートされていません。
## 例
次の例では、Amazon S3 バケットからデータをロードするための COPY JOB を作成しています。
```
COPY public.target_table
FROM 's3://amzn-s3-demo-bucket/staging-folder'
IAM_ROLE 'arn:aws:iam::123456789012:role/MyLoadRoleName'
JOB CREATE my_copy_job_name
AUTO ON;
```
# テンプレートを使用したコピー
Redshift テンプレートを COPY コマンドとともに使用して、コマンド構文を簡素化し、データロードオペレーション全体の一貫性を確保できます。同じ形式パラメータを繰り返し指定する代わりに、テンプレートで 1 回定義し、COPY コマンドでそのテンプレートを参照します。テンプレートを使用する場合、COPY コマンドはテンプレートのパラメータとコマンドで直接指定されたパラメータを結合します。テンプレートとコマンドの両方に同じパラメータが出現した場合、コマンドパラメータが優先されます。詳細については、「[CREATE TEMPLATE](r_CREATE_TEMPLATE.md)」を参照してください。
COPY コマンドのテンプレートは、以下を使用して作成できます。
+ [データ形式パラメータ](copy-parameters-data-format.md)
+ [ファイル圧縮パラメータ](copy-parameters-file-compression.md)
+ [データ変換パラメータ](copy-parameters-data-conversion.md)
+ [データのロード操作](copy-parameters-data-load.md)
サポートされているパラメータの完全なリストについては、「[COPY](r_COPY.md)」コマンドを参照してください。
## 必要なアクセス許可
COPY コマンドでテンプレートを使用するには、次のものが必要です。
+ COPY コマンドを実行するために必要なすべてのアクセス許可 (「[必要なアクセス許可](r_COPY.md#r_COPY-permissions)」を参照)
+ 次のいずれかのテンプレートアクセス許可。
+ スーパーユーザー権限
+ テンプレートに対する USAGE 権限と、テンプレートを含むスキーマに対する USAGE 権限
## 構文
```
COPY target_table FROM 's3://...'
authorization
[ option, ...]
USING TEMPLATE [database_name.][schema_name.]template_name;
```
## パラメータ
*database\$1name*
(オプション) テンプレートが存在するデータベースの名前。指定しない場合は、現在のデータベースが使用されます。
*schema\$1name*
(オプション) テンプレートが存在するスキーマの名前。指定しない場合は、現在の検索パスでテンプレートが検索されます。
*template\$1name*
COPY で使用するテンプレートの名前。
## 使用に関する注意事項
+ コマンド固有のパラメータ (送信元、送信先、認証) は COPY コマンドで指定する必要があります。
+ テンプレートに COPY コマンドのマニフェストファイルの仕様を含めることはできません。
## 例
次の例は、テンプレートを作成し、COPY コマンドで使用する方法を示しています。
```
CREATE TEMPLATE public.test_template FOR COPY AS
CSV DELIMITER '|' IGNOREHEADER 1 MAXERROR 100;
COPY public.target_table
FROM 's3://amzn-s3-demo-bucket/staging-folder'
IAM_ROLE 'arn:aws:iam::123456789012:role/MyLoadRoleName'
USING TEMPLATE public.test_template;
```
テンプレートとコマンドの両方にパラメータが存在する場合、コマンドパラメータが優先されます。この例では、テンプレート `public.test_template` に `DELIMITER '|'` が含まれているが、COPY コマンドで `DELIMITER ','` が指定されている場合、テンプレートのパイプ区切り文字 (`|`) の代わりに、コマンドのカンマ区切り文字 (`,`) が使用されます。
```
COPY public.target_table
FROM 's3://amzn-s3-demo-bucket/staging-folder'
IAM_ROLE 'arn:aws:iam::123456789012:role/MyLoadRoleName'
DELIMITER ','
USING TEMPLATE public.test_template;
```
# COPY パラメータリファレンス
COPY には、さまざまな状況で使用できるパラメータが多数あります。ただし、すべてのパラメータがそれぞれの状況でサポートされているわけではありません。例えば、ORC ファイルや PARQUET ファイルからロードする場合、サポートされるパラメーターの数は限られています。詳細については、「[列データ形式の COPY](copy-usage_notes-copy-from-columnar.md)」を参照してください。
**Topics**
+ [データソース](copy-parameters-data-source.md)
+ [認可パラメータ](copy-parameters-authorization.md)
+ [列のマッピングオプション](copy-parameters-column-mapping.md)
+ [データ形式パラメータ](copy-parameters-data-format.md)
+ [ファイル圧縮パラメータ](copy-parameters-file-compression.md)
+ [データ変換パラメータ](copy-parameters-data-conversion.md)
+ [データのロード操作](copy-parameters-data-load.md)
+ [パラメータリスト (アルファベット順)](r_COPY-alphabetical-parm-list.md)
# データソース
Amazon S3 バケット、Amazon EMR クラスター、またはクラスターが SSH 接続を使用してアクセスできるリモートホストのテキストファイルからデータをロードできます。また、DynamoDB テーブルから直接データをロードすることもできます。
どのソースからであっても、単一の入力行の最大サイズは 4 MB です。
テーブルから Amazon S3 の一連のファイルにデータをエクスポートするには、[UNLOAD](r_UNLOAD.md) コマンドを使用します。
**Topics**
+ [Amazon S3 からの COPY](copy-parameters-data-source-s3.md)
+ [Amazon EMR からの COPY](copy-parameters-data-source-emr.md)
+ [リモートホスト (SSH) からの COPY](copy-parameters-data-source-ssh.md)
+ [Amazon DynamoDB からの COPY](copy-parameters-data-source-dynamodb.md)
# Amazon S3 からの COPY
S3 バケットに配置したファイルからデータをロードするには、FROM 句を使用して COPY が Amazon S3 にあるファイルを見つける方法を指定します。FROM 句の一部としてデータファイルのオブジェクトパスを指定できます。または、Amazon S3 オブジェクトパスのリストを含むマニフェストファイルの場所を指定できます。Amazon S3 からの COPY では、HTTPS 接続が使用されます。S3 IP 範囲が許可リストに追加されていることを確認します。必要な S3 IP 範囲の詳細については、「[ネットワークの隔離](https://docs.aws.amazon.com//redshift/latest/mgmt/security-network-isolation.html#network-isolation)」を参照してください。
**重要**
データファイルを保持する Amazon S3 バケットがクラスターと同じ AWS リージョンに存在しない場合は、[REGION](#copy-region)パラメータを使用して、データがあるリージョンを指定する必要があります。
**Topics**
+ [構文](#copy-parameters-data-source-s3-syntax)
+ [例](#copy-parameters-data-source-s3-examples)
+ [任意指定のパラメータ](#copy-parameters-data-source-s3-optional-parms)
+ [サポートされないパラメータ](#copy-parameters-data-source-s3-unsupported-parms)
## 構文
```
FROM { 's3://objectpath' | 's3://manifest_file' }
authorization
| MANIFEST
| ENCRYPTED
| REGION [AS] 'aws-region'
| optional-parameters
```
## 例
次の例では、オブジェクトパスを使用して Amazon S3 からデータをロードします。
```
copy customer
from 's3://amzn-s3-demo-bucket/customer'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
次の例では、マニフェストファイルを使用して Amazon S3 からデータをロードします。
```
copy customer
from 's3://amzn-s3-demo-bucket/cust.manifest'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
manifest;
```
### パラメータ
FROM
ロードするデータのソースです。Amazon S3 ファイルのエンコードの詳細については、[データ変換パラメータ](copy-parameters-data-conversion.md) を参照してください。
's3://*copy\$1from\$1s3\$1objectpath*'
データを含む Amazon S3 オブジェクトへのパスを指定します (例: `'s3://amzn-s3-demo-bucket/custdata.txt'`)。*s3://copy\$1from\$1s3\$1objectpath* パラメータは、1 つのファイルを参照することも、同じキープレフィックスを持つオブジェクトまたはフォルダの集合を参照することもできます。たとえば、名前 `custdata.txt` は `custdata.txt`、`custdata.txt.1`、`custdata.txt.2`、`custdata.txt.bak` など、複数の物理ファイルを参照するキープレフィックスです。キープレフィックスは複数のフォルダを参照することもできます。たとえば、`'s3://amzn-s3-demo-bucket/custfolder'`は `custfolder` フォルダや `custfolder_1` フォルダなどを参照します。`custfolder_2`キープレフィックスが複数のフォルダを参照する場合、フォルダ内のすべてのファイルがロードされます。キープレフィックスが `custfolder.log` などのフォルダだけでなくファイルとも一致する場合、COPY はファイルのロードも試みます。キープレフィックスが原因で COPY が不要なファイルをロードしようとした場合は、マニフェストファイルを使用します。詳細については、[copy_from_s3_manifest_file](#copy-manifest-file)を参照してください。
データファイルを保持する S3 バケットがクラスターと同じ AWS リージョンに存在しない場合は、[REGION](#copy-region)パラメータを使用して、データがあるリージョンを指定する必要があります。
詳細については、「[Amazon S3 からデータをロードする](t_Loading-data-from-S3.md)」を参照してください。
's3://*copy\$1from\$1s3\$1manifest\$1file*'
ロードするデータファイルをリストするマニフェストファイルの Amazon S3 オブジェクトキーを指定します。*'s3://*copy\$1from\$1s3\$1manifest\$1file'** 引数は、単一のファイル (`'s3://amzn-s3-demo-bucket/manifest.txt'` など) を明示的に参照する必要があります。キープレフィックスを参照することはできません。
マニフェストは、Amazon S3 からロードする各ファイルの URL をリストする、JSON 形式のテキストファイルです。URL にはバケット名およびファイルの完全オブジェクトパスが含まれます。マニフェストで指定するファイルの場所は異なるバケットでもかまいませんが、すべてのバケットは Amazon Redshift クラスターと同じ AWS リージョンに置かれている必要があります。ファイルが 2 回リストされている場合、ファイルは 2 回ロードされます。次の例は、3 つのファイルをロードするマニフェストの JSON を示しています。
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket1/custdata.1","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket1/custdata.2","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket2/custdata.1","mandatory":false}
]
}
```
二重引用符は必須であり、傾きの付いた "高機能な" 引用符ではなくシンプルな引用符 (0x22) にする必要があります。マニフェストの各エントリには、オプションとして `mandatory` フラグを含めることができます。`mandatory` が `true` に設定されている場合、そのエントリのファイルが見つからなければ、COPY は終了します。ファイルが見つかれば、COPY 処理は継続します。`mandatory` のデフォルト値は `false` です。
以下の例に示すように、Parquet または ORC 形式のデータファイルからロードする場合、`meta`フィールドは必須です。
```
{
"entries":[
{
"url":"s3://amzn-s3-demo-bucket1/orc/2013-10-04-custdata",
"mandatory":true,
"meta":{
"content_length":99
}
},
{
"url":"s3://amzn-s3-demo-bucket2/orc/2013-10-05-custdata",
"mandatory":true,
"meta":{
"content_length":99
}
}
]
}
```
ENCRYPTED、GZIP、LZOP、BZIP2、または ZSTD オプションを指定している場合でも、マニフェストファイルの暗号化または圧縮は行わないでください。指定したマニフェストファイルが見つからないか、マニフェストファイルの形式が適切ではない場合、COPY はエラーを返します。
マニフェストファイルを使用する場合、COPY コマンドに MANIFEST パラメータを指定する必要があります。MANIFEST パラメータを指定しない場合、COPY では、FROM で指定されたファイルがデータファイルであると想定します。
詳細については、「[Amazon S3 からデータをロードする](t_Loading-data-from-S3.md)」を参照してください。
*authorization*
COPY コマンドが、他の AWS リソース (Amazon S3、Amazon EMR、Amazon DynamoDB、Amazon EC2 など) のデータにアクセスするにためには承認が必要です。この認可を付与するには、クラスターにアタッチした AWS Identity and Access Management (IAM) ロールを参照 (ロールベースのアクセスコントロール) するか、ユーザーのアクセス認証情報を指定 (キーベースのアクセスコントロール) します。セキュリティと柔軟性を強化するために、IAM ロールベースのアクセスコントロールを使用することをお勧めします。詳細については、「[認可パラメータ](copy-parameters-authorization.md)」を参照してください。
MANIFEST
Amazon S3 からロードするデータファイルの識別にマニフェストを使用することを指定します。MANIFEST パラメータが使用されている場合、COPY は *'s3://copy\$1from\$1s3\$1manifest\$1file'* によって参照されるマニフェストに記載されているファイルからデータをロードします。マニフェストファイルが見つからない場合、または形式が正しくない場合、COPY は失敗します。詳細については、「[マニフェストを使用し、データファイルを指定する](loading-data-files-using-manifest.md)」を参照してください。
ENCRYPTED
Amazon S3 にある入力ファイルの暗号化が、カスタマーマネージドのキーを使用したクライアント側の暗号化であることを指定する句。詳細については、「[暗号化されたデータファイルを Amazon S3 からロードする](c_loading-encrypted-files.md)」を参照してください。入力ファイルが Amazon S3 サーバー側の暗号化 (SSE-KMS または SSE-S3) を使用して暗号化されている場合は、ENCRYPTED を指定しないでください。COPY では、サーバー側で暗号化されたファイルを自動的に読み取ります。
ENCRYPTED パラメータを指定する場合は、[MASTER_SYMMETRIC_KEY](#copy-master-symmetric-key)パラメータも指定するか、**master\$1symmetric\$1key**値を [CREDENTIALS パラメータの使用](copy-parameters-authorization.md#copy-credentials) 文字列に含める必要があります。
暗号化されたファイルが圧縮形式である場合は、GZIP、LZOP、BZIP2、ZSTD パラメータを追加してください。
ENCRYPTED を指定している場合でも、マニフェストファイルと JSONPaths ファイルの暗号化は行わないでください。
MASTER\$1SYMMETRIC\$1KEY '*root\$1key*'
Amazon S3 のデータファイルの暗号化に使用されたルート対称キー。MASTER\$1SYMMETRIC\$1KEY を指定する場合、[ENCRYPTED](#copy-encrypted)パラメータも指定する必要があります。MASTER\$1SYMMETRIC\$1KEY は CREDENTIALS パラメータと併用できません。詳細については、「[暗号化されたデータファイルを Amazon S3 からロードする](c_loading-encrypted-files.md)」を参照してください。
暗号化されたファイルが圧縮形式である場合は、GZIP、LZOP、BZIP2、ZSTD パラメータを追加してください。
REGION [AS] '*aws-region*'
ソースデータが配置されている AWS のリージョンを指定します。REGION は、データを含む AWS のリソースが Amazon Redshift クラスターと同じリージョンにない場合に、Amazon S3 バケットまたは DynamoDB テーブルから COPY を実行するために必要となります。
*aws\$1region* の値は、[Amazon Redshift リージョンとエンドポイント](https://docs.aws.amazon.com/general/latest/gr/rande.html#redshift_region)テーブルに示されているリージョンと一致している必要があります。
REGION パラメータが指定されている場合、マニフェストファイルや複数の Amazon S3 バケットを含むすべてのリソースが指定されたリージョンに存在している必要があります。
リージョン間でデータを転送する場合、Amazon S3 バケットやデータを含む DynamoDB テーブルに対して追加料金が発生します。料金の詳細については、「[Amazon S3 料金](https://aws.amazon.com/s3/pricing/)」ページの「**Amazon S3 から別の AWS リージョンへのデータ転送 (アウト)**」、および「[Amazon DynamoDB 料金](https://aws.amazon.com/dynamodb/pricing/)」ページの「**データ転送 (アウト)**」を参照してください。
デフォルトでは、COPY はデータが Amazon Redshift クラスターと同じリージョンにあると見なします。
## 任意指定のパラメータ
Amazon S3 からの COPY では、オプションで次のパラメータを指定できます。
+ [列のマッピングオプション](copy-parameters-column-mapping.md)
+ [データ形式パラメータ](copy-parameters-data-format.md#copy-data-format-parameters)
+ [データ変換パラメータ](copy-parameters-data-conversion.md)
+ [データのロード操作](copy-parameters-data-load.md)
## サポートされないパラメータ
Amazon S3 からの COPY では、次のパラメータは使用できません。
+ SSH
+ READRATIO
# Amazon EMR からの COPY
COPY コマンドを使用することで、クラスターの Hadoop Distributed File System (HDFS) に、固定幅ファイル、文字区切りファイル、CSV ファイル、JSON 形式ファイル、または Avro ファイルでテキストファイルを書き込むように設定された Amazon EMR クラスターから、データを並列にロードできます。
**Topics**
+ [Syntax](#copy-parameters-data-source-emr-syntax)
+ [例](#copy-parameters-data-source-emr-example)
+ [パラメータ](#copy-parameters-data-source-emr-parameters)
+ [サポートされているパラメータ](#copy-parameters-data-source-emr-optional-parms)
+ [サポートされないパラメータ](#copy-parameters-data-source-emr-unsupported-parms)
## Syntax
```
FROM 'emr://emr_cluster_id/hdfs_filepath'
authorization
[ optional_parameters ]
```
## 例
次の例では、Amazon EMR クラスターからデータをロードします。
```
copy sales
from 'emr://j-SAMPLE2B500FC/myoutput/part-*'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
## パラメータ
FROM
ロードするデータのソースです。
'emr://*emr\$1cluster\$1id*/*hdfs\$1file\$1path*'
Amazon EMR クラスターの一意の識別子、および COPY コマンドのデータファイルを参照する HDFS ファイルパスです。HDFS データファイル名には、ワイルドカード文字のアスタリスク (\$1) および疑問符 (?) を含めることはできません。
Amazon EMR クラスターは、COPY 操作が完了するまで稼動している必要があります。COPY 操作が完了する前に HDFS データファイルのいずれかが変更または削除されると、予期しない結果を招いたり、COPY 操作が失敗したりする可能性があります。
ファイル名の引数には、ロードする複数のファイルを指定する *hdfs\$1file\$1path* 引数の一部としてアスタリスク (\$1) および疑問符 (?) を使用できます。たとえば、`'emr://j-SAMPLE2B500FC/myoutput/part*'`であれば、`part-0000`、`part-0001`などのファイルが識別されます。ファイルパスにワイルドカード文字が含まれていない場合は、文字列リテラルとして処理されます。COPY コマンドでフォルダー名のみを指定した場合には、フォルダー内のすべてのファイルがロードされます。
ワイルドカード文字を使用する場合、またはフォルダ名のみを使用する場合は、不要なファイルがロードされないことを確認してください。例えば、一部のプロセスでは出力フォルダにログファイルが書き込まれることがあります。
詳細については、「[Amazon EMR からのデータのロード](loading-data-from-emr.md)」を参照してください。
*authorization*
COPY コマンドが、他の AWS リソース (Amazon S3、Amazon EMR、Amazon DynamoDB、Amazon EC2 など) のデータにアクセスするにためには承認が必要です。この認可を付与するには、クラスターにアタッチした AWS Identity and Access Management (IAM) ロールを参照 (ロールベースのアクセスコントロール) するか、ユーザーのアクセス認証情報を指定 (キーベースのアクセスコントロール) します。セキュリティと柔軟性を強化するために、IAM ロールベースのアクセスコントロールを使用することをお勧めします。詳細については、「[認可パラメータ](copy-parameters-authorization.md)」を参照してください。
## サポートされているパラメータ
Amazon EMR からの COPY では、オプションで次のパラメータを指定できます。
+ [列のマッピングオプション](copy-parameters-column-mapping.md)
+ [データ形式パラメータ](copy-parameters-data-format.md#copy-data-format-parameters)
+ [データ変換パラメータ](copy-parameters-data-conversion.md)
+ [データのロード操作](copy-parameters-data-load.md)
## サポートされないパラメータ
Amazon EMR からの COPY では、次のパラメータは使用できません。
+ ENCRYPTED
+ MANIFEST
+ REGION
+ READRATIO
+ SSH
# リモートホスト (SSH) からの COPY
COPY コマンドでは、Amazon Elastic Compute Cloud (Amazon EC2) インスタンスをはじめとするコンピュータなど、1 つ以上のリモートホストから同時にデータをロードすることができます。COPY では Secure Shell (SSH) を使用してリモートホストに接続し、そのホストのコマンドを実行してテキスト出力を生成します。リモートホストになることができるのは、EC2 の Linux インスタンスか、SSH 接続を許可するように設定されている Unix コンピュータまたは Linux コンピュータです。Amazon Redshift は複数のホストに接続でき、各ホストに対して複数の SSH 接続を開くことができます。Amazon Redshift は、各接続を介して一意のコマンドを送信し、ホストの標準出力にテキスト出力を生成します。Amazon Redshift は、テキストファイルと同じようにそれを読み込みます。
FROM 句を使用してマニフェストファイルの Amazon S3 オブジェクトキーを指定します。そのマニフェストファイルは、COPY が SSH 接続を開いてリモートコマンドを実行するために使用する情報を提供します。
**Topics**
+ [構文](#copy-parameters-data-source-ssh-syntax)
+ [例](#copy-parameters-data-source-ssh-examples)
+ [パラメータ](#copy-parameters-data-source-ssh-parameters)
+ [任意指定のパラメータ](#copy-parameters-data-source-ssh-optional-parms)
+ [サポートされないパラメータ](#copy-parameters-data-source-ssh-unsupported-parms)
**重要**
マニフェストファイルを保持する S3 バケットがクラスターと同じ AWS リージョンに存在しない場合は、REGION パラメータを使用して、バケットがあるリージョンを指定する必要があります。
## 構文
```
FROM 's3://'ssh_manifest_file' }
authorization
SSH
| optional-parameters
```
## 例
次の例では、マニフェストファイルを使用し、SSH を使用してリモートホストからデータをロードします。
```
copy sales
from 's3://amzn-s3-demo-bucket/ssh_manifest'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
ssh;
```
## パラメータ
FROM
ロードするデータのソースです。
's3://*copy\$1from\$1ssh\$1manifest\$1file*'
COPY コマンドは、SSH を使用して複数のホストに接続できるだけでなく、各ホストに対して複数の SSH 接続を作成できます。COPY はそれぞれのホスト接続を介してコマンドを実行し、コマンドからの出力を並列的にテーブルにロードします。*s3://copy\$1from\$1ssh\$1manifest\$1file* 引数は、マニフェストファイルの Amazon S3 オブジェクトキーを指定します。そのマニフェストファイルは、COPY が SSH 接続を開いてリモートコマンドを実行するために使用する情報を提供します。
*s3://copy\$1from\$1ssh\$1manifest\$1file* 引数は 1 つのファイルを明示的に参照する必要があります。これをキープレフィックスにすることはできません。例を以下に示します。
```
's3://amzn-s3-demo-bucket/ssh_manifest.txt'
```
マニフェストファイルは、Amazon Redshift がホストに接続する際に使用する JSON 形式のテキストファイルです。マニフェストファイルでは、SSH ホストのエンドポイント、ならびに、Amazon Redshift にデータを返すためにホストで実行されるコマンドを指定します。このほか、ホストのパブリックキー、ログインユーザー名、および各エントリの必須フラグを記載することもできます。次の例は、2 つの SSH 接続を作成するマニフェストファイルを示しています。
```
{
"entries": [
{"endpoint":"",
"command": "",
"mandatory":true,
"publickey": "",
"username": ""},
{"endpoint":"",
"command": "",
"mandatory":true,
"publickey": "",
"username": ""}
]
}
```
マニフェストファイルには、SSH 接続ごとに 1 つずつ `"entries"` 構造が含まれます。単一のホストに対して接続を複数作成することも、複数のホストに対して複数の接続を作成することもできます。例に示すように、フィールド名と値のどちらにも二重引用符が必要です。引用符の文字は、傾きの付いた "高機能な" 引用符ではなくシンプルな引用符 (0x22) にする必要があります。`"mandatory"` フィールドの中で二重引用符を必要としない値は、`true` または `false` のブール値のみです。
次のリストでは、マニフェストファイルのフィールドについて説明します。
endpoint
ホストの URL アドレスまたは IP アドレス (`"ec2-111-222-333.compute-1.amazonaws.com"` や `"198.51.100.0"` など)。
コマンド
テキスト出力またはバイナリ出力を gzip、lzop、bzip2、zstd 形式で生成する際にホストが実行するコマンド。コマンドは、ユーザー *"host\$1user\$1name"* が実行権限を持つコマンドであれば、どれでも指定できます。ファイルを印刷するなどのシンプルなコマンドでも、データベースにクエリを実行したり、スクリプトを実行したりするコマンドでもかまいません。出力 (テキストファイル、gzip バイナリファイル、lzop バイナリファイル、または bzip2 バイナリファイル) は、Amazon Redshift の COPY コマンドが取り込める形式にする必要があります。詳細については、「[入力データを準備する](t_preparing-input-data.md)」を参照してください。
publickey
(オプション) ホストのパブリックキー。公開キーが指定されている場合、Amazon Redshift は公開キーを使用してホストを特定します。公開キーが指定されていなければ、Amazon Redshift がホストの特定を試みることはありません。例えば、リモートホストのパブリックキーが `ssh-rsa AbcCbaxxx…Example root@amazon.com` であれば、パブリックキーのフィールドには `"AbcCbaxxx…Example"` と入力してください。
mandatory
(オプション) 接続ができなかった場合に COPY コマンドを失敗とするかどうかを示す句です。デフォルトは `false` です。Amazon Redshift が接続を 1 つも正常に確立できなかった場合に、COPY コマンドが失敗になります。
username
(オプション) ホストシステムにログオンし、リモートコマンドを実行する際に使用するユーザー名。ユーザーログイン名は、ホストの認可されたキーファイルに Amazon Redshift クラスターの公開キーを追加するときに使用したログイン名と同じものにする必要があります。デフォルトのユーザー名は `redshift` です。
マニフェストファイルの作成の詳細については、「[データをロードする手順](loading-data-from-remote-hosts.md#load-from-host-process)」を参照してください。
リモートホストから COPY を実行するには、COPY コマンドに SSH パラメータを指定する必要があります。SSH パラメータを指定しない場合、COPY では、FROM で指定されたファイルがデータファイルであると想定され、COPY は失敗します。
自動圧縮を使用する場合には、COPY コマンドでデータの読み込みオペレーションが 2 回実行されます。つまり、COPY コマンドではリモートコマンドが 2 回実行されることになります。初回の読み取り操作は圧縮の分析用データサンプルを提供するためのものであり、実際にデータがロードされるのは 2 回目の読み取り操作です。リモートコマンドを 2 回実行することが問題になるようであれば、自動圧縮は無効にする必要があります。自動圧縮を無効にするには、COMPUPDATE パラメータを OFF に設定して COPY コマンドを実行します。詳細については、「[自動圧縮ありでテーブルをロードする](c_Loading_tables_auto_compress.md)」を参照してください。
SSH から COPY を使用するための詳細な手順については、「[リモートホストからデータをロードする](loading-data-from-remote-hosts.md)」を参照してください。
*authorization*
COPY コマンドが、他の AWS リソース (Amazon S3、Amazon EMR、Amazon DynamoDB、Amazon EC2 など) のデータにアクセスするにためには承認が必要です。この認可を付与するには、クラスターにアタッチした AWS Identity and Access Management (IAM) ロールを参照 (ロールベースのアクセスコントロール) するか、ユーザーのアクセス認証情報を指定 (キーベースのアクセスコントロール) します。セキュリティと柔軟性を強化するために、IAM ロールベースのアクセスコントロールを使用することをお勧めします。詳細については、「[認可パラメータ](copy-parameters-authorization.md)」を参照してください。
SSH
SSH プロトコルを使用してリモートホストからデータがロードされることを指定する句です。SSH を指定する場合は、[s3://copy_from_ssh_manifest_file](#copy-ssh-manifest)引数を使用してマニフェストファイルを指定する必要もあります。
SSH を使用してリモート VPC でプライベート IP アドレスを使用しているホストからコピーしている場合、VPC は拡張された VPC ルーティングを有効化する必要があります。拡張された VPC ルーティングの詳細については、「[Amazon Redshift 拡張 VPC ルーティング](https://docs.aws.amazon.com/redshift/latest/mgmt/enhanced-vpc-routing.html)」を参照してください。
## 任意指定のパラメータ
SSH からの COPY では、オプションで次のパラメータを指定できます。
+ [列のマッピングオプション](copy-parameters-column-mapping.md)
+ [データ形式パラメータ](copy-parameters-data-format.md#copy-data-format-parameters)
+ [データ変換パラメータ](copy-parameters-data-conversion.md)
+ [データのロード操作](copy-parameters-data-load.md)
## サポートされないパラメータ
SSH からの COPY では、次のパラメータは使用できません。
+ ENCRYPTED
+ MANIFEST
+ READRATIO
# Amazon DynamoDB からの COPY
既存の DynamoDB テーブルからデータをロードするには、FROM 句を使用して DynamoDB テーブル名を指定します。
**Topics**
+ [構文](#copy-parameters-data-source-dynamodb-syntax)
+ [例](#copy-parameters-data-source-dynamodb-examples)
+ [任意指定のパラメータ](#copy-parameters-data-source-dynamodb-optional-parms)
+ [サポートされないパラメータ](#copy-parameters-data-source-dynamodb-unsupported-parms)
**重要**
DynamoDB テーブルが Amazon Redshift クラスターと同じリージョンに存在しない場合は、REGION パラメータを使用して、データがあるリージョンを指定する必要があります。
## 構文
```
FROM 'dynamodb://table-name'
authorization
READRATIO ratio
| REGION [AS] 'aws_region'
| optional-parameters
```
## 例
次の例では、DynamoDB テーブルからデータをロードします。
```
copy favoritemovies from 'dynamodb://ProductCatalog'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
readratio 50;
```
### パラメータ
FROM
ロードするデータのソースです。
'dynamodb://*table-name*'
データが入った DynamoDB テーブルの名前 (`'dynamodb://ProductCatalog'` など)。DynamoDB で Amazon Redshift 列に属性がマッピングされる方法の詳細については、[Amazon DynamoDB テーブルからのデータのロード](t_Loading-data-from-dynamodb.md)を参照してください。
DynamoDB テーブル名は AWS アカウントに固有のものです。アカウントは AWS アクセス認証情報によって識別されます。
*authorization*, \$1
COPY コマンドには、Amazon S3、Amazon EMR、DynamoDB、Amazon EC2 を含む、別の AWS リソースのデータにアクセスするための許可が必要になります。この認可を付与するには、クラスターにアタッチした AWS Identity and Access Management (IAM) ロールを参照 (ロールベースのアクセスコントロール) するか、ユーザーのアクセス認証情報を指定 (キーベースのアクセスコントロール) します。セキュリティと柔軟性を強化するために、IAM ロールベースのアクセスコントロールを使用することをお勧めします。詳細については、「[認可パラメータ](copy-parameters-authorization.md)」を参照してください。
READRATIO [AS] *ratio*
データロードに使用する DynamoDB テーブルのプロビジョニングされたスループットの比率です。READRATIO は DynamoDB からの COPY では必須です。Amazon S3 からの COPY の実行には使用できません。この割合については、未使用のプロビジョニングされたスループットの平均よりも小さい値に設定することを強くお勧めします。有効な値は、1～200 の整数です。
READRATIO を 100 以上に設定すると、Amazon Redshift で DynamoDB テーブルのプロビジョニングされたスループット全体を使用できるようになり、COPY セッション中に同じテーブルに対する同時読み込みオペレーションのパフォーマンスが大きく低下します。書き込みトラフィックは影響を受けません。Amazon Redshift がテーブルのプロビジョニングされたスループットを満たさないまれなシナリオをトラブルシューティングする場合には、100 を超える値を使用できます。DynamoDB から Amazon Redshift に継続的にデータをロードする場合、DynamoDB テーブルを時系列テーブルとして編成し、COPY 操作からライブトラフィックを分離することを検討してください。
## 任意指定のパラメータ
Amazon DynamoDB からの COPY では、オプションで次のパラメータを指定できます。
+ [列のマッピングオプション](copy-parameters-column-mapping.md)
+ 次のデータ変換パラメータがサポートされています。
+ [ACCEPTANYDATE](copy-parameters-data-conversion.md#copy-acceptanydate)
+ [BLANKSASNULL](copy-parameters-data-conversion.md#copy-blanksasnull)
+ [DATEFORMAT](copy-parameters-data-conversion.md#copy-dateformat)
+ [EMPTYASNULL](copy-parameters-data-conversion.md#copy-emptyasnull)
+ [ROUNDEC](copy-parameters-data-conversion.md#copy-roundec)
+ [TIMEFORMAT](copy-parameters-data-conversion.md#copy-timeformat)
+ [TRIMBLANKS](copy-parameters-data-conversion.md#copy-trimblanks)
+ [TRUNCATECOLUMNS](copy-parameters-data-conversion.md#copy-truncatecolumns)
+ [データのロード操作](copy-parameters-data-load.md)
## サポートされないパラメータ
DynamoDB からの COPY では、次のパラメータは使用できません。
+ 全データ形式パラメータ
+ ESCAPE
+ FILLRECORD
+ IGNOREBLANKLINES
+ IGNOREHEADER
+ NULL
+ REMOVEQUOTES
+ ACCEPTINVCHARS
+ MANIFEST
+ ENCRYPTED
# 認可パラメータ
COPY コマンドが、他の AWS リソース (Amazon S3、Amazon EMR、Amazon DynamoDB、Amazon EC2 など) のデータにアクセスするにためには承認が必要です。この承認は、クラスターにアタッチされた [AWS Identity and Access Management (IAM) ロール](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) (*ロールベースのアクセスコントロール*) を参照することで提供できます。Amazon S3 のロードデータを暗号化できます。
以下のトピックでは、認証オプションの詳細と例をさらに示します。
+ [COPY、UNLOAD、CREATE LIBRARY のための IAM のアクセス許可](copy-usage_notes-access-permissions.md#copy-usage_notes-iam-permissions)
+ [ロールベースアクセスコントロール](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based)
+ [キーベースのアクセスコントロール](copy-usage_notes-access-permissions.md#copy-usage_notes-access-key-based)
以下のいずれかを使用して COPY コマンドに認可を提供します。
+ [IAM\$1ROLE パラメータの使用](#copy-iam-role) パラメータ
+ [ACCESS\$1KEY\$1ID および SECRET\$1ACCESS\$1KEY パラメータの使用](#copy-access-key-id) 個のパラメータ
+ [CREDENTIALS パラメータの使用](#copy-credentials) 句
## IAM\$1ROLE パラメータの使用
### IAM\$1ROLE
デフォルトキーワードを使用して、COPY コマンドの実行時にデフォルトとして設定され、クラスターに関連付けられた IAM ロールの使用を、Amazon Redshift に指示します。
クラスターが認証と認可に使用する IAM ロールの Amazon リソースネーム (ARN) を使用します。IAM\$1ROLE を指定すると、ACCESS\$1KEY\$1ID および SECRET\$1ACCESS\$1KEY、SESSION\$1TOKEN、または CREDENTIALS は使用できません。
以下に、IAM\$1ROLE パラメータの構文を示します。
```
IAM_ROLE { default | 'arn:aws:iam:::role/' }
```
詳細については、「[ロールベースアクセスコントロール](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based)」を参照してください。
## ACCESS\$1KEY\$1ID および SECRET\$1ACCESS\$1KEY パラメータの使用
### ACCESS\$1KEY\$1ID、SECRET\$1ACCESS\$1KEY
この認可方法は推奨されません。
**注記**
アクセス認証情報をプレーンテキストで提供するのではなく、IAM\$1ROLE パラメータを指定してロールベースの認証を使用することを強くお勧めします。詳細については、「[ロールベースアクセスコントロール](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based)」を参照してください。
### SESSION\$1TOKEN
一時的アクセス認証情報で使用するセッショントークン。SESSION\$1TOKEN を指定した場合、ACCESS\$1KEY\$1ID と SECRET\$1ACCESS\$1KEY も使用して一時的アクセスキー認証情報を指定する必要があります。SESSION\$1TOKEN を指定した場合、IAM\$1ROLE または CREDENTIALS は使用できません。詳細については、IAM ユーザーガイドの「[一時的な認証情報](copy-usage_notes-access-permissions.md#r_copy-temporary-security-credentials)」を参照してください。
**注記**
一時的セキュリティ認証情報を作成するのではなく、ロールベースの認証を使用することを強くお勧めします。IAM ロールを使用して認可すると、Amazon Redshift が自動的に各セッション用の一時的ユーザー認証情報を作成します。詳細については、「[ロールベースアクセスコントロール](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based)」を参照してください。
以下に、ACCESS\$1KEY\$1ID と SECRET\$1ACCESS\$1KEY パラメータを使用した SESSION\$1TOKEN パラメータの構文を示します。
```
ACCESS_KEY_ID ''
SECRET_ACCESS_KEY ''
SESSION_TOKEN '';
```
SESSION\$1TOKEN を指定した場合、CREDENTIALS または IAM\$1ROLE は使用できません。
## CREDENTIALS パラメータの使用
### CREDENTIALS
クラスターが、データファイルまたはマニフェストファイルを含む他の AWS リソースにアクセスする際の方法を示す句。CREDENTIALS パラメータは、IAM\$1ROLE または ACCESS\$1KEY\$1ID と SECRET\$1ACCESS\$1KEY との併用はできません。
次に示すのは CREDENTIALS パラメータの構文です。
```
[WITH] CREDENTIALS [AS] 'credentials-args'
```
**注記**
柔軟性を強化するために、CREDENTIALS パラメータの代わりに [IAM\$1ROLE](#copy-iam-role-iam) パラメータを使用することをお勧めします。
必要に応じて [ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted) パラメータを使用する場合は、*credentials-args* 文字列が、暗号化キーを提供します。
*credentials-args* 文字列では大文字と小文字が区別され、空白を含めることはできません。
キーワード WITH および AS はオプションで、無視されます。
[role-based access control](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based.phrase) または [key-based access control](copy-usage_notes-access-permissions.md#copy-usage_notes-access-key-based.phrase) のどちらかを指定できます。どちらの場合も、IAM ロールまたはユーザーは、指定された AWS リソースにアクセスするために必要なアクセス許可が必要です。詳細については、「[COPY、UNLOAD、CREATE LIBRARY のための IAM のアクセス許可](copy-usage_notes-access-permissions.md#copy-usage_notes-iam-permissions)」を参照してください。
**注記**
AWS 認証情報および機密データを保護するには、ロールベースのアクセスコントロールを使用することを強くお勧めします。
ロールベースのアクセスコントロールを指定するには、次の形式で *credentials-args* 文字列を指定します。
```
'aws_iam_role=arn:aws:iam:::role/'
```
一時トークン認証情報を使用するには、一時アクセスキー ID、一時秘密アクセスキー、および一時トークンを提供する必要があります。*credentials-args* 文字列は次の形式になります。
```
CREDENTIALS
'aws_access_key_id=;aws_secret_access_key=;token='
```
一時的な認証情報でロールベースのアクセスコントロールを使用する COPY コマンドは、次のサンプルステートメントのようになります。
```
COPY customer FROM 's3://amzn-s3-demo-bucket/mydata'
CREDENTIALS
'aws_access_key_id=;aws_secret_access_key=;token='
```
詳細については、「[一時的な認証情報](copy-usage_notes-access-permissions.md#r_copy-temporary-security-credentials)」を参照してください。
[ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted) パラメータを使用する場合、*credentials-args* 文字列は下記のような形式になります。ここで ** はファイルの暗号化に使用されたルートキーの値です。
```
CREDENTIALS
';master_symmetric_key='
```
暗号化キーでロールベースのアクセスコントロールを使用する COPY コマンドは、次のサンプルステートメントのようになります。
```
COPY customer FROM 's3://amzn-s3-demo-bucket/mydata'
CREDENTIALS
'aws_iam_role=arn:aws:iam:::role/;master_symmetric_key='
```
# 列のマッピングオプション
デフォルトでは、COPY はデータファイルで発生したフィールドと同じ順序でターゲットテーブルの列に値を挿入します。デフォルトの列順序が機能しない場合は、列リストを指定するか、JSONPath 式を使用してソースデータフィールドをターゲット列にマッピングできます。
+ [Column List](#copy-column-list)
+ [JSONPaths File](#copy-column-mapping-jsonpaths)
## 列リスト
ソースデータフィールドを特定のターゲット列にロードするには、列名のカンマ区切りリストを指定します。COPY ステートメントで列は任意の順序に指定できますが、Amazon S3 バケットなどにあるフラットファイルからロードする場合、ソースデータの順序に一致する必要があります。
Amazon DynamoDB テーブルからロードする場合、順序は関係ありません。COPY コマンドは、DynamoDB テーブルから取得した項目の属性名と、Amazon Redshift テーブルの列名を一致させます。詳細については、「[Amazon DynamoDB テーブルからのデータのロード](t_Loading-data-from-dynamodb.md)」を参照してください。
列リストの形式は次のとおりです。
```
COPY tablename (column1 [,column2, ...])
```
ターゲットテーブルの列が列リストから削除された場合は、COPY はターゲット列の [DEFAULT](r_CREATE_TABLE_NEW.md#create-table-default) 式をロードします。
ターゲット列にデフォルトがない場合は、COPY は NULL をロードします。
COPY を実行し、NOT NULL として定義されている列に NULL を割り当てようとすると、COPY コマンドは失敗します。
列リストに [IDENTITY](r_CREATE_TABLE_NEW.md#identity-clause) 列が含まれている場合、[EXPLICIT_IDS](copy-parameters-data-conversion.md#copy-explicit-ids) も指定する必要があります。IDENTITY 列を省略した場合、EXPLICIT\$1IDS は指定できません。列リストを指定しない場合、コマンドは、完全で順序正しい列リストが指定されたように動作します。EXPLICIT\$1IDS も指定しなかった場合、IDENTITY 列は省略されます。
列がGENERATED BY DEFAULT AS IDENTITYで定義されている場合は、コピーできます。値は、指定した値で生成または更新されます。EXPLICIT\$1IDS オプションは必須ではありません。COPY は IDENTITY のハイウォーターマークを更新しません。詳細については、「[GENERATED BY DEFAULT AS IDENTITY](r_CREATE_TABLE_NEW.md#identity-generated-bydefault-clause)」を参照してください。
## JSONPaths ファイル
JSON または Avro 形式からデータファイルをロードする場合、COPY は JSON または Avro ソースデータのデータ要素をターゲットテーブルの列に自動的にマッピングします。Avro スキーマのフィールド名をターゲットテーブルまたは列リストの列名に一致させることで、行われます。
場合によっては、列名とフィールド名が一致しないか、データ階層のより深いレベルにマッピングする必要があります。このような場合、明示的に列に JSON または Avro のデータ要素をマッピングするには、JSONPaths ファイルを使用できます。
詳細については、「[JSONPaths ファイル](copy-parameters-data-format.md#copy-json-jsonpaths)」を参照してください。
# データ形式パラメータ
デフォルトでは、COPY コマンドはソースデータを文字区切り形式 UTF-8 のテキストと見なします。デフォルトの区切り文字はパイプ文字です。ソースデータが別の形式である場合は、以下のパラメータを使用してデータ形式を指定します。
+ [FORMAT](#copy-format)
+ [CSV](#copy-csv)
+ [DELIMITER](#copy-delimiter)
+ [FIXEDWIDTH](#copy-fixedwidth)
+ [SHAPEFILE](#copy-shapefile)
+ [AVRO](#copy-avro)
+ [JSON format for COPY](#copy-json)
+ [PARQUET](#copy-parquet)
+ [ORC](#copy-orc)
標準データ形式に加えて、COPY は、Amazon S3 から COPY の以下の列データ形式をサポートしています。
+ [ORC](#copy-orc)
+ [PARQUET](#copy-parquet)
列形式の COPY は、特定の制限でサポートされています。詳細については、「[列データ形式の COPY](copy-usage_notes-copy-from-columnar.md)」を参照してください。データ形式パラメータ
FORMAT [AS]
(オプション) データ形式キーワードを識別します。FORMAT 引数については以下で説明します。
CSV [ QUOTE [AS] *'quote\$1character'* ]
入力データで CSV 形式の使用を有効にします。区切り記号、改行文字、およびキャリッジリターンを自動的にエスケープするには、QUOTE パラメータで指定した文字でフィールドを囲みます。デフォルトの引用文字は二重引用符 (") です。フィールド内で引用文字が使用されている場合、引用文字を追加してその文字をエスケープします。例えば、引用文字が二重引用符である場合、文字列 `A "quoted" word` を挿入するには、入力ファイルに文字列 `"A ""quoted"" word"` を含める必要があります。CSV パラメータを使用する場合、デフォルトの区切り記号はカンマ (,) です。DELIMITER パラメータを使用して、異なる区切り記号を指定できます。
フィールドを引用符で囲んだ場合、区切り記号と引用文字との間の空白は無視されます。区切り記号がタブなどの空白文字である場合、その区切り記号は空白として扱われません。
CSV は FIXEDWIDTH、REMOVEQUOTES、または ESCAPE と共に使用することはできません。
QUOTE [AS] *'quote\$1character'*
省略可能。CSV パラメータを使用する場合に引用文字として使用する文字を指定します。デフォルトは二重引用符 (") です。QUOTE パラメータを使用して二重引用符以外の引用文字を定義した場合、フィールド内で二重引用符をエスケープする必要はありません。QUOTE パラメータは CSV パラメータと共にしか使用できません。AS キーワードはオプションです。
DELIMITER [AS] ['*delimiter\$1char*']
パイプ文字 (`|`)、カンマ (`,`)、タブ (`\t`)、複数の文字 (`|~|`) など、入力ファイル内のフィールドを区切るときに使用する文字を指定します。印刷不可の文字がサポートされています。文字は UTF-8 コード単位として 8 進数で表すこともできます。8 進数の場合は、「\$1ddd」の形式を使用します。「d」は 8 進数 (0～7) です。デフォルトの区切り記号はパイプ文字 (`|`) です。ただし、CSV パラメータを使用する場合、デフォルトの区切り記号はカンマ (`,`) です。AS キーワードはオプションです。DELIMITER と FIXEDWIDTH は併用できません。
FIXEDWIDTH '*fixedwidth\$1spec*'
列を区切り記号で区切らずに各列幅を固定長にしたファイルからデータをロードします。*fixedwidth\$1spec* はユーザー定義の列ラベルと列幅を指定する文字列です。列ラベルには、ユーザーの選択に従って、テキスト文字列または整数を指定できます。列ラベルは列名と関係ありません。ラベル/幅のペアの順序はテーブルの列の順序に正確に一致する必要があります。FIXEDWIDTH と CSV または DELIMITER を併用することはできません。Amazon Redshift では、CHAR 列および VARCHAR 列の長さがバイト単位で表されるため、ロードするファイルを準備する際には、指定する列幅がマルチバイト文字のバイナリ長に対応できることを確認してください。詳細については、「[文字型](r_Character_types.md)」を参照してください。
*fixedwidth\$1spec* の形式を次に示します。
```
'colLabel1:colWidth1,colLabel:colWidth2, ...'
```
SHAPEFILE [ SIMPLIFY [AUTO] [*'tolerance'*] ]
入力データで SHAPEFILE 形式の使用を有効にします。デフォルトでは、シェープファイルの最初の列は `GEOMETRY` 列または `IDENTITY` 列のいずれかです。後続のすべての列は、シェープファイルで指定された順序に従います。
SHAPEFILE を FIXEDWIDTH、EMOVEQUOTES、または ESCAPE と一緒に使用することはできません。
`COPY FROM SHAPEFILE` で `GEOGRAPHY` オブジェクトを使用するには、まずオブジェクトを `GEOMETRY` 列に取り込んだ後に、そのオブジェクトを `GEOGRAPHY` オブジェクトにキャストします。
SIMPLIFY [*tolerance*]
(オプション) Ramer-Douglas-Peucker アルゴリズムと指定された許容値を使用して、取り込みプロセス中のすべてのジオメトリを簡略化します。
SIMPLIFY AUTO [*tolerance*]
(オプション) 最大ジオメトリのサイズより大きいジオメトリのみを簡略化します。この簡略化では、Ramer-Douglas-Peucker アルゴリズムと、指定した許容値を超えない場合に自動的に計算された許容値が使用されます。このアルゴリズムは、指定された許容値内でオブジェクトを保存するためのサイズを計算します。*許容値*は任意の値です。
シェープファイルのロードの例については、「[シェープファイルを Amazon Redshift にロードする](r_COPY_command_examples.md#copy-example-spatial-copy-shapefile)」を参照してください。
AVRO [AS] '*avro\$1option*'
ソースデータが Avro 形式であることを指定します。
Avro 形式はここに挙げるサービスおよびプロトコルから実行する COPY でサポートされます。
+ Amazon S3
+ Amazon EMR
+ リモートホスト (SSH)
Avro は DynamoDB から実行する COPY ではサポートされません。
Avro はデータのシリアル化プロトコルです。Avro のソースファイルには、データ構造を定義するスキーマが含まれています。Avro のスキーマ型は `record` である必要があります。COPY は、デフォルトの非圧縮コーデック、および `deflate` と `snappy` の圧縮コーデックを使用して作成された、Avro ファイルを受け入れます。Avro に関する詳細については、「[Apache Avro](https://avro.apache.org/)」を参照してください。
*avro\$1option* の有効な値は次のとおりです。
+ `'auto'`
+ `'auto ignorecase'`
+ `'s3://jsonpaths_file'`
デフォルトは `'auto'` です。
COPY は Avro ソースデータのデータ要素をターゲットテーブルの列に自動的にマッピングします。Avro スキーマのフィールド名をターゲットテーブルの列名に一致させることで、行われます。一致で、`'auto'`では大文字と小文字が区別され、`'auto ignorecase'`では大文字と小文字が区別されません。
Amazon Redshift テーブルの列名は常に小文字になるため、`'auto'` オプションを使用する場合、対応するフィールド名も小文字である必要があります。フィールド名がすべて小文字でない場合は、`'auto ignorecase'`オプションを使用できます。デフォルトの `'auto'` 引数を使用すると、COPY は構造内の最初のレベルのフィールドまたは*外部フィールド*のみを認識します。
列名を Avro フィールド名に明示的にマップするには、[JSONPaths ファイル](#copy-json-jsonpaths) を使用できます。
デフォルトでは、COPY はターゲットテーブルのすべての列が Avro のフィールド名に一致するように試みます。列のサブセットをロードするには、オプションで列リストを指定できます。ターゲットテーブルの列が列リストから削除された場合は、COPY はターゲット列の [DEFAULT](r_CREATE_TABLE_NEW.md#create-table-default) 式をロードします。ターゲット列にデフォルトがない場合は、COPY は NULL をロードしようとします。列が列リストに含まれており、COPY が Avro データで一致するフィールドを見つけることができなかった場合、COPY はその列に NULL をロードしようと試みます。
COPY を実行し、NOT NULL として定義されている列に NULL を割り当てようとすると、COPY コマンドは失敗します。
**Avro スキーマ**
Avro のソースデータファイルには、データ構造を定義するスキーマが含まれています。COPY は Avro のソースデータファイルの一部であるスキーマを読み込み、ターゲットテーブルの列にデータ要素をマッピングします。次の例で Avro のスキーマを示します。
```
{
"name": "person",
"type": "record",
"fields": [
{"name": "id", "type": "int"},
{"name": "guid", "type": "string"},
{"name": "name", "type": "string"},
{"name": "address", "type": "string"}]
}
```
Avro スキーマは JSON 形式を使用して定義されています。最上位の JSON オブジェクトには、名前または *キー*の付いた 3 つの名前と値のペア `"name"`、`"type"`、および `"fields"` があります。
オブジェクトの配置を含む `"fields"` キーペアは、データ構造の各フィールド名とデータ型を定義します。デフォルトでは、COPY はフィールド名を列名に自動的に一致させます。列名は常に小文字であるため、`‘auto ignorecase’` オプションを指定しない限り、一致させるフィールド名もまた小文字にする必要があります。列名と一致しないフィールド名はすべて無視されます。順序は関係ありません。前の例では、COPY は列名 `id`、`guid`、`name`および `address` にマッピングしています。
デフォルトの `'auto'` 引数を使用すると、COPY は列の第 1 レベルのオブジェクトのみと一致します。スキーマのより深いレベルにマッピングする場合、またはフィールド名と列名が一致しない場合は、JSONPaths ファイルを使用してマッピングを定義します。詳細については、「[JSONPaths ファイル](#copy-json-jsonpaths)」を参照してください。
キーに関連付けられた値が Avro の複雑なデータ型 (バイト、配列、レコード、マップ、リンクなど) である場合、COPY は値を文字列としてロードします。ここで、文字列はデータの JSON 表現です。COPY は Avro ENUM データ型を文字列としてロードします。文字列の内容は型名です。例については、「[JSON 形式からの COPY](copy-usage_notes-copy-from-json.md)」を参照してください。
スキーマおよびファイルメタデータを含む Avro ファイルヘッダーの最大サイズは 1 MB です。
単一の Avro データブロックの最大サイズは 4 MB です。これは、行の最大サイズとは異なります。単一の Avro データブロックの最大サイズを超えた場合は、最終的な行サイズが 4 MB 未満であっても COPY コマンドは失敗します。
行のサイズを計算する際、Amazon Redshift では、パイプ文字 ( \$1 ) を 2 回内部的にカウントします。入力データに非常に多くのパイプ文字が含まれる場合、データブロックが 4 MB 未満であっても行サイズが 4 MB を超えることは可能です。
JSON [AS] '*json\$1option*'
ソースデータは JSON 形式です。
JSON 形式は次のサービスおよびプロトコルからの COPY でサポートされています。
+ Amazon S3
+ Amazon EMR からの COPY
+ SSH からの COPY
JSON は DynamoDB からの COPY ではサポートされません。
*json\$1option* の有効な値は次のとおりです。
+ `'auto'`
+ `'auto ignorecase'`
+ `'s3://jsonpaths_file'`
+ `'noshred'`
デフォルトは `'auto'` です。Amazon Redshift は、JSON ドキュメントのロード中に JSON 構造の属性を複数の列に細分化しません。
デフォルトでは、COPY はターゲットテーブルのすべての列を JSON のフィールド名キーに一致させるように試みます。列のサブセットをロードするには、オプションで列リストを指定できます。JSON フィールド名のキーがすべて小文字でない場合は、`'auto ignorecase'` オプションまたは [JSONPaths ファイル](#copy-json-jsonpaths) を使用して、明示的に列名を JSON フィールド名のキーにマッピングすることができます。
ターゲットテーブルの列が列リストから削除された場合は、COPY はターゲット列の [DEFAULT](r_CREATE_TABLE_NEW.md#create-table-default) 式をロードします。ターゲット列にデフォルトがない場合は、COPY は NULL をロードしようとします。列が列リストに含まれており、COPY が JSON データで一致するフィールドを見つけることができなかった場合、COPY はその列に NULL をロードしようと試みます。
COPY を実行し、NOT NULL として定義されている列に NULL を割り当てようとすると、COPY コマンドは失敗します。
COPY は、JSON ソースデータ内のデータ要素をターゲットテーブル内の列にマッピングします。これは、ソースの名前と値のペアの*オブジェクトキー*または名前を、ターゲットテーブルの列の名前と一致させることによって行われます。
各 *json\$1option* 値については、次の詳細を参照してください。
'auto'
このオプションでは、一致では大文字と小文字が区別されます。Amazon Redshift テーブルの列名は常に小文字になるため、`'auto'` オプションを使用する場合、対応する JSON フィールド名も小文字である必要があります。
'auto ignorecase'
このオプションでは、一致では大文字と小文字は区別されません。Amazon Redshift テーブルの列名は常に小文字であるため、`'auto ignorecase'` オプションを使用する場合、対応する JSON フィールド名は小文字、大文字、または大文字と小文字を混在させることができます。
's3://*jsonpaths\$1file*'
このオプションでは、COPY は指定された JSONPaths ファイルを使用して、JSON ソースデータ内のデータ要素をターゲットテーブル内の列にマッピングします。*`s3://jsonpaths_file`* 引数は、単一のファイルを明示的に参照する Amazon S3 オブジェクトキーである必要があります。例: 「`'s3://amzn-s3-demo-bucket/jsonpaths.txt`」。引数をキープレフィックスにすることはできません。JSONPaths ファイルの使用方法の詳細については、「[JSONPaths ファイル](#copy-json-jsonpaths)」を参照してください。
場合によっては、`jsonpaths_file` で指定されたファイルのプレフィックスが、`copy_from_s3_objectpath` で指定されたデータファイルのパスと同じになります。その場合、COPY は JSONPaths ファイルをデータファイルとして読み込み、エラーを返します。例えば、データファイルがオブジェクトパス `s3://amzn-s3-demo-bucket/my_data.json` を使用し、JSONPaths ファイルが `s3://amzn-s3-demo-bucket/my_data.jsonpaths` であるとします。この場合、COPY は `my_data.jsonpaths` をデータファイルとしてロードしようとします。
'noshred'
このオプションを使用すると、Amazon Redshift は JSON ドキュメントのロード中に JSON 構造の属性を複数の列に細分化しません。
## JSON データファイル
JSON データファイルには、一連のオブジェクトまたは配列が含まれます。COPY は、それぞれの JSON オブジェクトまたは JSON 配列をターゲットテーブルの 1 つの行にロードします。行に対応する各オブジェクトまたは配列は、スタンドアロンのルートレベル構造である必要があります。つまり、別の JSON 構造のメンバーではない必要があります。
JSON *オブジェクト*の先頭と末尾には中括弧 (\$1 \$1) が付き、順序が設定されていない一連の名前と値のペアが含まれます。ペアの名前と値はコロンで区切られ、各ペアはカンマで区切られます。デフォルトでは、名前と値のペアに含まれる*オブジェクトキー* (名前) は、テーブル内の対応する列の名前に一致する必要があります。Amazon Redshift テーブルの列名は常に小文字であるため、一致する JSON フィールド名のキーも小文字である必要があります。列名と JSON キーが一致しない場合、[JSONPaths ファイル](#copy-json-jsonpaths)を使用して明示的に列をキーにマッピングします。
JSON オブジェクト内の順序は問題ではありません。列名と一致しない名前はすべて無視されます。次に、簡単な JSON オブジェクトの構造を示します。
```
{
"column1": "value1",
"column2": value2,
"notacolumn" : "ignore this value"
}
```
JSON *配列*の先頭と末尾には角括弧 ([ ]) が付き、順序が設定された一連のカンマ区切りの値が含まれます。データファイルで配列を使用している場合は、JSONPaths ファイルを指定して、値を列に一致させる必要があります。次に、簡単な JSON 配列の構造を示します。
```
["value1", value2]
```
JSON は正しい形式になっている必要があります。例えば、オブジェクトまたは配列をカンマまたは空白以外の他の文字で区切ることはできません。文字列は、二重引用文字で囲む必要があります。引用符は、傾きの付いた "高機能な" 引用符ではなくシンプルな引用符 (0x22) にする必要があります。
1 つの JSON オブジェクトまたは JSON 配列の最大サイズ (中括弧または角括弧を含む) は 4 MB です。これは、行の最大サイズとは異なります。単一の JSON オブジェクトまたは配列の最大サイズを超えた場合は、最終的な行サイズが 4 MB 未満であっても COPY コマンドは失敗します。
行のサイズを計算する際、Amazon Redshift では、パイプ文字 ( \$1 ) を 2 回内部的にカウントします。入力データに非常に多くのパイプ文字が含まれる場合、オブジェクトサイズが 4 MB 未満であっても行サイズが 4 MB を超えることは可能です。
COPY は改行文字として `\n` を、タブ文字として `\t` をロードします。バックスラッシュをロードするには、バックスラッシュをバックスラッシュでエスケープします (`\\`)。
COPY は、指定した JSON ソースにおいて、正しい形式の有効な JSON オブジェクトまたは JSON 配列を検索します。使用可能な JSON 構造体を見つける前に、または有効な JSON オブジェクトまたは配列の間で COPY が空白以外の文字を検出した場合、COPY は各インスタンスについてエラーを返します。このエラーは、MAXERROR のエラー数としてカウントされます。エラー数が MAXERROR 以上に達すると、COPY は失敗します。
それぞれのエラーについて、Amazon Redshift は STL\$1LOAD\$1ERRORS システムテーブルの行を記録します。LINE\$1NUMBER 列には、エラーの原因となった JSON オブジェクトの最後の行が記録されます。
IGNOREHEADER を指定した場合、COPY は JSON データの指定数の行を無視します。JSON データに含まれる改行文字は、常に IGNOREHEADER の計算にカウントされます。
デフォルトでは、COPY は空の文字列を空のフィールドとしてロードします。EMPTYASNULL を指定した場合、COPY は CHAR および VARCHAR フィールドの空の文字列を NULL としてロードします。INT など、他のデータ型の空の文字列は常に NULL でロードされます。
次のオプションは JSON ではサポートされません。
+ CSV
+ DELIMITER
+ ESCAPE
+ FILLRECORD
+ FIXEDWIDTH
+ IGNOREBLANKLINES
+ NULL AS
+ READRATIO
+ REMOVEQUOTES
詳細については、「[JSON 形式からの COPY](copy-usage_notes-copy-from-json.md)」を参照してください。JSON データ構造の詳細については、[www.json.org](https://www.json.org/) を参照してください。
## JSONPaths ファイル
JSON 形式または Avro ソースのデータからロードする場合、デフォルトでは COPY はソースデータ内の第 1 レベルのデータ要素をターゲットテーブル内の列にマッピングします。これは、名前と値のペアの各名前またはオブジェクトキーを、ターゲットテーブルの列の名前と一致させることによって行われます。
列名とオブジェクトキーが一致しない場合、またはデータ階層のより深いレベルまでマッピングする場合は、JSONPaths ファイルを使用して明示的に JSON または Avro のデータ要素を列にマッピングできます。JSONPaths ファイルは、ターゲットテーブルまたは列リストで列の順序を一致させることで、JSON データ要素を列にマッピングします。
JSONPaths には、単一の JSON オブジェクト (配列ではない) を格納しなければなりません。JSON オブジェクトは、名前と値のペアです。*オブジェクトキー* (名前と値のペアの名前) は、`"jsonpaths"`にする必要があります。名前の値のペアに含まれる*値*は、*JSONPath 式*の配列です。各 JSONPath 式は、JSON データ階層内または Avro スキーマの単一の要素を参照します。XPath 式が XML ドキュメント内の要素を参照する方法と似ています。詳細については、「[JSONPath 式](#copy-json-jsonpath-expressions)」を参照してください。
JSONPaths ファイルを使用するには、JSON または AVRO キーワードを COPY コマンドに追加します。次の形式を使用して、JSONPaths ファイルの S3 バケット名とオブジェクトパスを指定します。
```
COPY tablename
FROM 'data_source'
CREDENTIALS 'credentials-args'
FORMAT AS { AVRO | JSON } 's3://jsonpaths_file';
```
`s3://jsonpaths_file` 値は、`'s3://amzn-s3-demo-bucket/jsonpaths.txt'`などの単一のファイルを明示的に参照する Amazon S3 オブジェクトキーである必要があります。キープレフィックスにすることはできません。
場合によっては、Amazon S3 からロードする場合、`jsonpaths_file` で指定されたファイルのプレフィックスは、`copy_from_s3_objectpath` で指定されたデータファイルのパスと同じになります。その場合、COPY は JSONPaths ファイルをデータファイルとして読み込み、エラーを返します。例えば、データファイルがオブジェクトパス `s3://amzn-s3-demo-bucket/my_data.json` を使用し、JSONPaths ファイルが `s3://amzn-s3-demo-bucket/my_data.jsonpaths` であるとします。この場合、COPY は `my_data.jsonpaths` をデータファイルとしてロードしようとします。
キー名が `"jsonpaths"` 以外の文字列である場合、COPY コマンドはエラーを返しませんが、*jsonpaths\$1file* を無視して `'auto'` 引数を代わりに使用します。
以下のいずれかの状況に当てはまる場合、COPY コマンドは失敗します。
+ JSON が正しい形式ではない。
+ 複数の JSON オブジェクトがある。
+ オブジェクトの外に空白以外の文字が存在する。
+ 配列エレメントが空の文字列であるか、文字列ではない。
MAXERROR は JSONPaths には適用されません。
[ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted) オプションを指定している場合でも、JSONPaths ファイルの暗号化は行わないでください。
詳細については、「[JSON 形式からの COPY](copy-usage_notes-copy-from-json.md)」を参照してください。
## JSONPath 式
JSONPaths ファイルは JSONPath 式を使用してターゲット列にデータフィールドをマッピングします。各 JSONPath 式は、Amazon Redshift のターゲットテーブル内の 1 列に対応しています。JSONPath 配列要素の順序は、ターゲットテーブル内の列の順序または列リストが使用される場合は列リスト内の列の順序と一致していなければなりません。
例に示すように、フィールド名と値のどちらにも二重引用符が必要です。引用符の文字は、傾きの付いた "高機能な" 引用符ではなくシンプルな引用符 (0x22) にする必要があります。
JSONPath 式によって参照されるオブジェクト要素が JSON データにない場合、COPY は NULL 値をロードしようとします。参照されるオブジェクトが正しい形式ではない場合、COPY はロードエラーを返します。
JSONPath 式により参照される配列要素が JSON データまたは Avro データに見つからない場合、COPY は次のエラー `Invalid JSONPath format: Not an array or index out of range.` で失敗します。ソースデータに存在しない配列要素を JSONPaths からすべて削除し、ソースデータの配列が正しい形式であることを確認してください。
JSONPath 式では、ブラケット表記またはドット表記のいずれかを使用できますが、両方の表記を混ぜて使用することはできません。次の例は、ブラケット表記を使用した JSONPath 式を示しています。
```
{
"jsonpaths": [
"$['venuename']",
"$['venuecity']",
"$['venuestate']",
"$['venueseats']"
]
}
```
次の例は、ドット表記を使用した JSONPath 式を示しています。
```
{
"jsonpaths": [
"$.venuename",
"$.venuecity",
"$.venuestate",
"$.venueseats"
]
}
```
Amazon Redshift COPY 構文のコンテキストでは、JSONPath 式は、JSON または Avro の階層データ構造内の 1 つの名前要素に対する明示的なパスを指定する必要があります。Amazon Redshift では、あいまいなパスや複数の名前要素に解決される可能性がある、ワイルドカード文字やフィルター式などの JSONPath 要素をサポートしていません。
詳細については、「[JSON 形式からの COPY](copy-usage_notes-copy-from-json.md)」を参照してください。
## Avro データに対する JSONPaths の使用
次の例で、複数のレベルがある Avro スキーマを示します。
```
{
"name": "person",
"type": "record",
"fields": [
{"name": "id", "type": "int"},
{"name": "guid", "type": "string"},
{"name": "isActive", "type": "boolean"},
{"name": "age", "type": "int"},
{"name": "name", "type": "string"},
{"name": "address", "type": "string"},
{"name": "latitude", "type": "double"},
{"name": "longitude", "type": "double"},
{
"name": "tags",
"type": {
"type" : "array",
"name" : "inner_tags",
"items" : "string"
}
},
{
"name": "friends",
"type": {
"type" : "array",
"name" : "inner_friends",
"items" : {
"name" : "friends_record",
"type" : "record",
"fields" : [
{"name" : "id", "type" : "int"},
{"name" : "name", "type" : "string"}
]
}
}
},
{"name": "randomArrayItem", "type": "string"}
]
}
```
次の例で、AvroPath 式を使用して前のスキーマを参照する JSONPaths ファイルを示します。
```
{
"jsonpaths": [
"$.id",
"$.guid",
"$.address",
"$.friends[0].id"
]
}
```
JSONPaths の例には、以下の要素が含まれています。
jsonpaths
AvroPath 式を含む JSON オブジェクトの名前です。
[ … ]
かっこ内にパス要素を含む JSON 配列を囲みます。
\$1
ドル記号は、`"fields"`配列である Avro スキーマのルート要素を表します。
"\$1.id",
AvroPath 式のターゲットです。このインスタンスでは、ターゲットは `"fields"` 配列の `"id"` という名前の要素です。式はカンマで区切ります。
"\$1.friends[0].id"
かっこは配列インデックスを示します。JSONPath 式はゼロベースのインデックスを使用します。従って、この式は `"friends"` 配列の第 1 要素を `"id"` と言う名前で参照します。
Avro スキーマの構文では、*内部フィールド*を使用してレコード構造および配列データ型を定義する必要があります。内部フィールドは AvroPath 式には無視されます。例えば、フィールド `"friends"` は `"inner_friends"` という名前の配列を定義し、は `"friends_record"` という名前のレコードを定義します。フィールド `"id"` を参照する AvroPath 式は、追加のフィールドを無視してターゲットフィールドを直接参照できます。次の AvroPath 式は、`"friends"`配列内に属する 2 つのフィールドを参照します。
```
"$.friends[0].id"
"$.friends[0].name"
```
## 列データ形式のパラメータ
標準データ形式に加えて、COPY は、Amazon S3 から COPY の以下の列データ形式をサポートしています。列形式の COPY は、特定の制限でサポートされています。詳細については、「[列データ形式の COPY](copy-usage_notes-copy-from-columnar.md)」を参照してください。
ORC
最適化された行列 (ORC) ファイル形式を使用するファイルからデータをロードします。
PARQUET
Parquet ファイル形式を使用するファイルからデータをロードします。
# ファイル圧縮パラメータ
次のパラメータを指定して、圧縮されたデータファイルからロードできます。ファイル圧縮パラメータ
BZIP2
入力ファイルが圧縮された bzip2 形式 (.bz2 ファイル) であることを指定する値です。COPY 操作では、圧縮されたそれぞれのファイルを読み取り、ロード時にデータを解凍します。
GZIP
入力ファイルが圧縮された gzip 形式 (.gz 形式) であることを指定する値です。COPY 操作では、圧縮されたそれぞれのファイルを読み取り、ロード時にデータを解凍します。
LZOP
入力ファイルが圧縮された lzop 形式 (.lzo ファイル) であることを指定する値です。COPY 操作では、圧縮されたそれぞれのファイルを読み取り、ロード時にデータを解凍します。
COPY は、lzop *--filter* オプションを使用して圧縮されたファイルをサポートしていません。
ZSTD
入力ファイルが圧縮された Zstandard 形式 (.zst ファイル) であることを指定する値です。COPY 操作では、圧縮されたそれぞれのファイルを読み取り、ロード時にデータを解凍します。
ZSTD は、Amazon S3 から COPY を使用する場合のみサポートされます。
# データ変換パラメータ
テーブルをロードする際に、COPY は暗黙的にソースデータの文字列をターゲット列のデータ型に変換しようとします。デフォルトの動作とは異なる変換を指定する必要がある場合、またはデフォルトの変換がエラーになった場合、次のパラメータを指定してデータ変換を管理できます。これらのパラメータの構文に関する詳細については、「[COPY 構文](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY.html#r_COPY-syntax)」を参照してください。
+ [ACCEPTANYDATE](#copy-acceptanydate)
+ [ACCEPTINVCHARS](#copy-acceptinvchars)
+ [BLANKSASNULL](#copy-blanksasnull)
+ [DATEFORMAT](#copy-dateformat)
+ [EMPTYASNULL](#copy-emptyasnull)
+ [ENCODING](#copy-encoding)
+ [ESCAPE](#copy-escape)
+ [EXPLICIT_IDS](#copy-explicit-ids)
+ [FILLRECORD](#copy-fillrecord)
+ [IGNOREBLANKLINES](#copy-ignoreblanklines)
+ [IGNOREHEADER](#copy-ignoreheader)
+ [NULL AS](#copy-null-as)
+ [REMOVEQUOTES](#copy-removequotes)
+ [ROUNDEC](#copy-roundec)
+ [TIMEFORMAT](#copy-timeformat)
+ [TRIMBLANKS](#copy-trimblanks)
+ [TRUNCATECOLUMNS](#copy-truncatecolumns) データ変換パラメータ
ACCEPTANYDATE
`00/00/00 00:00:00` などの無効な形式を含め、任意の日付形式をエラーなしにロードできるようにします。このパラメータは TIMESTAMP 列および DATE 列にのみ適用されます。ACCEPTANYDATE は常に DATEFORMAT パラメータと共に使用します。データの日付形式が DATEFORMAT の仕様と一致しない場合、Amazon Redshift はそのフィールドに NULL 値を挿入します。
ACCEPTINVCHARS [AS] ['*replacement\$1char*']
データに無効な UTF-8 文字がある場合でも、VARCHAR 列へのデータのロードを有効にします。ACCEPTINVCHARS を指定した場合、COPY は *replacement\$1char* で指定されている文字列から構成される同じ長さの文字列で、無効な各 UTF-8 文字を置き換えます。例えば、置換文字が '`^`' である場合、無効な 3 バイト文字は '`^^^`' で置き換えられます。
置換文字には NULL 以外の任意の ASCII 文字を使用できます。デフォルトは疑問符 (?) です。無効な UTF-8 文字の詳細については、「[マルチバイト文字のロードエラー](multi-byte-character-load-errors.md)」を参照してください。
COPY は無効な UTF-8 文字を含んだ行の数を返し、対象行ごとに [STL\$1REPLACEMENTS](r_STL_REPLACEMENTS.md) システムテーブルにエントリを追加します (各ノードスライスで最大 100 行まで)。さらに多くの無効な UTF-8 文字も置き換えられますが、それらの置換イベントは記録されません。
ACCEPTINVCHARS を指定しなかった場合、無効な UTF-8 文字があるごとに、COPY はエラーを返します。
ACCEPTINVCHARS は VARCHAR 列に対してのみ有効です。
BLANKSASNULL
NULL など、空白文字のみから構成される空のフィールドをロードします。このオプションは CHAR と VARCHAR の列にのみ適用されます。INT など、他のデータ型の空のフィールドは常に NULL でロードされます。例えば、3 つの連続するスペース文字を含む (それ以外の文字はない) 文字列は NULL としてロードされます。このオプションなしのデフォルト動作では、スペース文字をそのままロードします。
DATEFORMAT [AS] \$1'*dateformat\$1string*' \$1 'auto' \$1
DATEFORMAT を指定しない場合、デフォルト形式は `'YYYY-MM-DD'` です。例えば、有効な代替形式は `'MM-DD-YYYY'` です。
COPY コマンドが日付値または時刻値の形式を認識しない場合、または日付値または時刻値で異なる形式が使用されている場合は、`'auto'`引数を DATEFORMAT または TIMEFORMAT パラメータとともに使用します。`'auto'` 引数は、DATEFORMAT および TIMEFORMAT 文字列を使用する場合にサポートされない形式を認識します。`'auto'` キーワードでは大文字小文字を区別します。詳細については、「[DATEFORMAT と TIMEFORMAT で自動認識を使用する](automatic-recognition.md)」を参照してください。
日付形式には時間情報 (時、分、秒) を含めることができますが、この情報は無視されます。AS キーワードはオプションです。詳細については、「[DATEFORMAT と TIMEFORMAT の文字列例](r_DATEFORMAT_and_TIMEFORMAT_strings.md)」を参照してください。
EMPTYASNULL
Amazon Redshift で CHAR と VARCHAR の空のフィールドを NULL としてロードすることを指定します。INT など、他のデータ型の空のフィールドは常に NULL でロードされます。データに 2 つの区切り記号が連続し、区切り記号の間に文字がない場合、空のフィールドになります。EMPTYASNULL と NULL AS '' (空の文字列) は同じ動作を生成します。
ENCODING [AS] *file\$1encoding*
ロードデータのエンコードタイプを指定します。COPY コマンドは、ロード時にデータを指定されたエンコードから UTF-8 に変換します。
*file\$1encoding* の有効な値は次のとおりです。
+ `UTF8`
+ `UTF16`
+ `UTF16LE`
+ `UTF16BE`
+ `ISO88591`
デフォルトは `UTF8` です。
ソースファイル名には UTF-8 エンコードを使用する必要があります。
ロードデータに別のエンコードが指定されている場合でも、以下のファイルには UTF-8 エンコードを使用する必要があります。
+ マニフェストファイル
+ JSONPaths ファイル
次のパラメータを使用して指定される引数文字列には UTF-8 を使用する必要があります。
+ FIXEDWIDTH '*fixedwidth\$1spec*'
+ ACCEPTINVCHARS '*replacement\$1char*'
+ DATEFORMAT '*dateformat\$1string*'
+ TIMEFORMAT '*timeformat\$1string*'
+ NULL AS '*null\$1string*'
固定幅データファイルは UTF-8 エンコーディングを使用する必要があります。フィールド幅はバイト数ではなく、文字数をベースにしています。
すべてのロードデータには、指定されたエンコードを使用する必要があります。COPY が別のエンコードを検出した場合、ファイルがスキップされてエラーが返されます。
`UTF16` を指定した場合、データにはバイトオーダーマーク (BOM) が必要です。UTF-16 データがリトルエンディアン (LE) であるかビッグエンディアン (BE) であるかがわかっている場合、BOM があるかどうかに関係なく `UTF16LE` または `UTF16BE` を使用できます。
ISO-8859-1 エンコーディングを使用するには、`ISO88591` を指定します。詳細については、Wikipedia の「[ISO/IEC 8859-1](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)」を参照してください。**
ESCAPE
このパラメータを指定した場合、入力データのバックスラッシュ文字 (`\`) はエスケープ文字として扱われます。バックスラッシュ文字の直後に続く文字は、通常は特定の目的に使用される文字である場合でも、現在の列の値の一部としてテーブルにロードされます。例えば、区切り文字、引用符、埋め込まれた改行文字、またはエスケープ文字自体のいずれかが正当な列の値として含まれている場合、このパラメータを使用してその文字をエスケープできます。
REMOVEQUOTES パラメータと組み合わせて ESCAPE パラメータを使用すると、他の場合には削除される引用符 (`'` または `"`) をエスケープし保持することができます。デフォルトの null 文字列 `\N` はそのまま使用できますが、入力データで `\\N` としてエスケープすることもできます。NULL AS パラメータで代替 null 文字列を指定しない限り、`\N`と `\\N` は同じ結果になります。
制御文字 `0x00` (NUL) はエスケープできません。入力データから削除するか変換してください。この文字はレコードの終わり (EOR) マーカーとして扱われ、レコードの残りの部分は切り捨てられます。
FIXEDWIDTH ロードに対して ESCAPE パラメータを使用することはできません。また、エスケープ文字自体を指定することはできません。エスケープ文字は常にバックスラッシュ文字です。また、入力データの適切な場所にエスケープ文字が含まれていることを確認する必要があります。
次に、ESCAPE パラメータを指定する場合の入力データおよびその結果、ロードされるデータの例を示します。行 4 の結果は、REMOVEQUOTES パラメータも指定されていることを想定しています。入力データはパイプで区切られたフィールド 2 つで構成されます。
```
1|The quick brown fox\[newline]
jumped over the lazy dog.
2| A\\B\\C
3| A \| B \| C
4| 'A Midsummer Night\'s Dream'
```
データは列 2 に次にようにロードされます。
```
The quick brown fox
jumped over the lazy dog.
A\B\C
A|B|C
A Midsummer Night's Dream
```
ロード用の入力データにエスケープ文字を適用する作業はユーザーが担当します。ただし、ESCAPE パラメータを使用して以前アンロードされたデータを再ロードした場合は例外となります。この場合、データにはすでに必要なエスケープ文字が含まれています。
ESCAPE パラメータでは 8 進数、16 進数、Unicode、またはその他のエスケープシーケンス表記を解釈しません。例えば、ソースデータに 8 進数のラインフィード値 (`\012`) があり、ESCAPE パラメータを使用してこのデータをロードしようとすると、Amazon Redshift は値 `012` をテーブルにロードします。この値は、エスケープされているラインフィードとしては解釈されません。
Microsoft Windows プラットフォームからのデータの改行文字をエスケープするには、2 つのエスケープ文字の使用が必要となることがあります。1 つはキャリッジリターン用、もう 1 つはラインフィード用です。または、ファイルのロード前にキャリッジリターンを削除することができます (例えば、dos2unix utility を使用)。
EXPLICIT\$1IDS
自動生成される値をテーブルのソースデータファイルの明示的値でオーバーライドするには、IDENTITY 列を持つテーブルに EXPLICIT\$1IDS を使用します。コマンドに列リストが含まれる場合、そのリストにはこのパラメータを使用する IDENTITY 列が含まれている必要があります。EXPLICIT\$1IDS 値のデータ形式は、CREATE TABLE 定義で指定された IDENTITY 形式に一致する必要があります。
EXPLICIT\$1IDS オプションを使用してテーブルに対して COPY コマンドを実行する際、Amazon Redshift はテーブル内の IDENTITY 列の一意性をチェックしません。
列がGENERATED BY DEFAULT AS IDENTITYで定義されている場合は、コピーできます。値は、指定した値で生成または更新されます。EXPLICIT\$1IDS オプションは必須ではありません。COPY は IDENTITY のハイウォーターマークを更新しません。
EXPLICIT\$1IDS を使用する COPY コマンドの例については、「[IDENTITY 列の明示的値を使用して VENUE をロードする](r_COPY_command_examples.md#r_COPY_command_examples-load-venue-with-explicit-values-for-an-identity-column)」を参照してください。
FILLRECORD
一部のレコードの最後で連続する列が欠落している場合に、データをロードできるようにします。欠落している列は NULL としてロードされます。テキスト形式と CSV 形式では、VARCHAR 列が欠落している場合、NULL の代わりに長さ 0 の文字列がロードされます。テキストおよび CSV から VARCHAR 列に NULL をロードするには、EMPTYASNULL キーワードを指定します。NULL の置き換えは、列定義で NULL が使用できる場合にのみ可能です。
例えば、テーブル定義に 4 つの null が許容された CHAR 列があり、レコードに値 `apple, orange, banana, mango` がある場合、COPY コマンドは値 `apple, orange` のみを含むレコードをロードし、記入できます。欠落している CHAR 値は NULL 値としてロードされます。
IGNOREBLANKLINES
データファイルでラインフィードのみ含む空白行を無視し、ロードしません。
IGNOREHEADER [ AS ] *number\$1rows*
指定された *number\$1rows* をファイルヘッダーとして扱い、ロードしません。並列ロードですべてのファイルのファイルヘッダーをスキップするには、IGNOREHEADER を使用します。
NULL AS '*null\$1string*'
*null\$1string* に一致するフィールドを NULL としてロードします。ここで *null\$1string* は任意の文字列です。データに null ターミネータ (NUL (UTF-8 0000) またはバイナリゼロ (0x000) と呼ばれることもあります) が含まれる場合、COPY はそれを他の文字として扱います。例えば、'1' \$1\$1 NUL \$1\$1 '2' を含むレコードは長さ 3 バイトの文字列としてコピーされます。フィールドに NUL のみが含まれている場合は、NULL AS を使用して、`'\0'` または `'\000'` (例えば、`NULL AS '\0'` または `NULL AS '\000'`) を指定することにより、null ターミネータを NULL に置き換えることができます。フィールドに NUL で終わる文字列が含まれており、NULL AS を指定した場合、文字列の最後に NUL が挿入されます。*null\$1string* 値に '\$1 n' (改行) を使用しないでください。Amazon Redshift は、行区切り文字として使用するために '\$1n' を予約します。デフォルトの *null\$1string* は `'\N`' です。
NOT NULL として定義された列に Null のロードを試みた場合、COPY コマンドは失敗します。
REMOVEQUOTES
入力データの文字列を囲む引用符を削除します。区切り記号を含む引用符内のすべての文字は保持されます。文字列に開始の一重または二重引用符があるが、対応する終了引用符がない場合、COPY コマンドはその行をロードできず、エラーを返します。次の表は、引用符を含む文字列とその結果、ロードされる値の簡単な例を示しています。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/copy-parameters-data-conversion.html)
ROUNDEC
入力値の小数点以下の桁数が列の小数点以下の桁数よりも多い場合に数値を四捨五入します。COPY のデフォルト動作では、列の小数点以下の桁数に合わせて必要に応じて値が切り捨てられます。たとえば、`20.259`という値が DECIMAL(8,2) 列にロードされた場合、COPY はデフォルトでこの値を `20.25` に切り捨てます。ROUNDEC が指定されている場合、COPY はこの値を `20.26` に四捨五入します。INSERT コマンドでは、列の小数点以下の桁数に合わせて必要に応じて値が四捨五入されます。そのため、COPY コマンドを ROUNDEC パラメータとともに使用した場合の動作は、INSERT コマンドを実行した場合の動作と同じになります。
TIMEFORMAT [AS] \$1'*timeformat\$1string*' \$1 'auto' \$1 'epochsecs' \$1 'epochmillisecs' \$1
時間形式を指定します。TIMEFORMAT が指定されていない場合、デフォルトの形式は、TIMESTAMP 列では `YYYY-MM-DD HH:MI:SS`、TIMESTAMPTZ 列では `YYYY-MM-DD HH:MI:SSOF` です。`OF` は協定世界時 (UTC) からのオフセットです。*timeformat\$1string* には、タイムゾーン指定子を含めることができません。デフォルトの形式と異なる形式の TIMESTAMPTZ データをロードするには、「auto」を指定します。詳細については、「[DATEFORMAT と TIMEFORMAT で自動認識を使用する](automatic-recognition.md)」を参照してください。*timeformat\$1string* の詳細については、「[DATEFORMAT と TIMEFORMAT の文字列例](r_DATEFORMAT_and_TIMEFORMAT_strings.md)」を参照してください。
`'auto'` 引数は、DATEFORMAT および TIMEFORMAT 文字列を使用する場合にサポートされない形式を認識します。COPY コマンドが日付値または時刻値の形式を認識しない場合、または日付値および時刻値でそれぞれ異なる形式が使用されている場合は、`'auto'`引数を DATEFORMAT または TIMEFORMAT パラメータとともに使用します。詳細については、「[DATEFORMAT と TIMEFORMAT で自動認識を使用する](automatic-recognition.md)」を参照してください。
ソースデータがエポック時間 (1970 年 1 月 1 日 00:00:00 UTC からの秒数またはミリ秒数) で表されている場合、`'epochsecs'`または `'epochmillisecs'` を指定します。
`'auto'`、`'epochsecs'`、`'epochmillisecs'`の各キーワードでは大文字小文字を区別します。
AS キーワードはオプションです。
TRIMBLANKS
VARCHAR 文字列から末尾の空白文字を削除します。このパラメータは VARCHAR データ型の列にのみ適用されます。
TRUNCATECOLUMNS
列の仕様に合うよう、該当する文字数で列のデータを切り捨てます。データ型が VARCHAR または CHAR の列、およびサイズが 4 MB 以下の行にのみ適用されます。
# データのロード操作
次のパラメータを指定して、トラブルシューティングの際のロード操作のデフォルトの動作を管理したり、ロード時間を短縮します。
+ [COMPROWS](#copy-comprows)
+ [COMPUPDATE](#copy-compupdate)
+ [IGNOREALLERRORS](#copy-ignoreallerrors)
+ [MAXERROR](#copy-maxerror)
+ [NOLOAD](#copy-noload)
+ [STATUPDATE](#copy-statupdate) パラメータ
COMPROWS *numrows*
圧縮分析のサンプルサイズとして使用される行数を指定します。分析は各データスライスの行に対して実行されます。たとえば、`COMPROWS 1000000`(1,000,000) を指定し、システムに合計 4 つのスライスが含まれている場合、スライスごとに 250,000 行のみが読み取られ、分析されます。
COMPROWS を指定しない場合、サンプルサイズはデフォルトでスライスごとに 100,000 になります。COMPROWS の値がスライスごとに 100,000 行のデフォルト値より小さい場合、自動的にデフォルト値にアップグレードされます。ただし、ロードされるデータの量が有意のサンプルとしては不十分な場合、自動圧縮は実行されません。
COMPROWS 数が入力ファイルの行数より大きい場合でも、COPY コマンドは続行し、利用可能なすべての行で圧縮分析を実行します。この引数の許容範囲は 1000～2147483647 (2,147,483,647) の数値です。
COMPUPDATE [ PRESET \$1 \$1 ON \$1 TRUE \$1 \$1 \$1 OFF \$1 FALSE \$1 ]
COPY 実行中に圧縮エンコードを自動的に適用するかどうかを制御します。
COMPUPDATE が PRESET の場合、COPY コマンドを実行すると、ターゲットテーブルが空の場合、列に RAW 以外のエンコードが既に指定されていても、各列に圧縮エンコードが選択されます。現在指定されている列のエンコードは置き換えることができます。各列のエンコードは、列のデータタイプに基づきます。サンプリングされているデータはありません。Amazon Redshift では、次のように圧縮エンコードが自動的に割り当てられます。
+ ソートキーとして定義されている列には、RAW 圧縮が割り当てられます。
+ BOOLEAN、REAL、または DOUBLE PRECISION データ型として定義されている列には、RAW 圧縮が割り当てられます。
+ SMALLINT、INTEGER、BIGINT、DECIMAL、DATE、TIMESTAMP、または TIMESTAMPTZ として定義された列には AZ64 圧縮が割り当てられます。
+ CHAR または VARCHAR として定義された列には、LZO 圧縮が割り当てられます。
COMPUPDATE を削除して COPY コマンドを実行すると、ターゲットテーブルが空で、どの列にもエンコード (RAW は除く) を指定していない場合にのみ、各列に圧縮エンコードが選択されます。各列のエンコードは、Amazon Redshift によって決定されます。サンプリングされているデータはありません。
COMPUPDATE が ON (または TRUE) の場合、または COMPUPDATE がオプションなしで指定されている場合は、テーブルの列に RAW 以外のエンコードがすでに指定されていても、テーブルが空であれば COPY によって自動圧縮が適用されます。現在指定されている列のエンコードは置き換えることができます。列ごとのエンコードは、サンプルデータの分析によって異なります。詳細については、「[自動圧縮ありでテーブルをロードする](c_Loading_tables_auto_compress.md)」を参照してください。
COMPUPDATE OFF (または FALSE) の場合、自動圧縮は無効になります。列のエンコードを変更することはできません。
圧縮を分析するシステムテーブルの詳細については、「[STL\$1ANALYZE\$1COMPRESSION](r_STL_ANALYZE_COMPRESSION.md)」を参照してください。
IGNOREALLERRORS
このオプションを指定すると、ロードオペレーション中に発生したすべてのエラーを無視します。
MAXERROR オプションを指定している場合は、IGNOREALLERRORS オプションを指定することはできません。ORC や Parquet の列形式に対しては、IGNOREALLERRORS オプションを指定できません。
MAXERROR [AS] *error\$1count*
ロードのエラー数が *error\$1count* 以上である場合、ロードは失敗します。ロードのエラーがそれより少ない場合、処理は続行され、ロードできなかった行数を示す INFO メッセージが返されます。データの形式エラーやその他の不整合のために一部の行をテーブルにロードできないときにロードを継続するには、このパラメータを使用します。
最初のエラーが発生したときにロードを失敗させる場合、この値を `0` または `1` に設定します。AS キーワードはオプションです。MAXERROR のデフォルト値は `0`、そしてその限度は `100000` です。
Amazon Redshift の並列処理のため、報告される実際のエラー数が指定された MAXERROR より大きくなることがあります。Amazon Redshift クラスターのノードで MAXERROR を超えたことが検出された場合、各ノードは発生したすべてのエラーを報告します。
NOLOAD
データを実際にロードせずにデータファイルの有効性をチェックします。実際にデータロードを実行せずに、エラーなしでデータファイルがロードされることを確認するには、NOLOAD パラメータを使用します。NOLOAD パラメータと共に COPY を実行すると、ファイルを解析するだけであるため、データのロードよりはるかに高速になります。
STATUPDATE [ \$1 ON \$1 TRUE \$1 \$1 \$1 OFF \$1 FALSE \$1 ]
COPY コマンドが成功したとき最後に行う自動計算とオプティマイザ統計の更新を制御します。デフォルトでは、STATUPDATE パラメータを使用しない場合、テーブルが最初は空ならば、統計は自動的に更新されます。
データを空ではないテーブルに入れるとテーブルのサイズが大きく変化する場合は、常に [ANALYZE](r_ANALYZE.md) コマンドを実行するか STATUPDATE ON 引数を使用して統計を更新することをお勧めします。
STATUPDATE ON (または TRUE) の場合、テーブルが最初に空であるかどうかに関係なく、統計は自動的に更新されます。STATUPDATE を使用する場合、現在のユーザーはテーブル所有者またはスーパーユーザーであることが必要です。STATUPDATE を指定しない場合、INSERT 権限のみ必要です。
STATUPDATE OFF (または FALSE) を使用すると、統計は更新されません。
詳細については、「[テーブルを分析する](t_Analyzing_tables.md)」を参照してください。
# パラメータリスト (アルファベット順)
次の一覧は、アルファベット順にソートされた COPY コマンドパラメータのそれぞれの説明へのリンクです。
+ [ACCEPTANYDATE](copy-parameters-data-conversion.md#copy-acceptanydate)
+ [ACCEPTINVCHARS](copy-parameters-data-conversion.md#copy-acceptinvchars)
+ [ACCESS\$1KEY\$1ID、SECRET\$1ACCESS\$1KEY](copy-parameters-authorization.md#copy-access-key-id-access)
+ [AVRO](copy-parameters-data-format.md#copy-avro)
+ [BLANKSASNULL](copy-parameters-data-conversion.md#copy-blanksasnull)
+ [BZIP2](copy-parameters-file-compression.md#copy-bzip2)
+ [COMPROWS](copy-parameters-data-load.md#copy-comprows)
+ [COMPUPDATE](copy-parameters-data-load.md#copy-compupdate)
+ [CREDENTIALS](copy-parameters-authorization.md#copy-credentials-cred)
+ [CSV](copy-parameters-data-format.md#copy-csv)
+ [DATEFORMAT](copy-parameters-data-conversion.md#copy-dateformat)
+ [DELIMITER](copy-parameters-data-format.md#copy-delimiter)
+ [EMPTYASNULL](copy-parameters-data-conversion.md#copy-emptyasnull)
+ [ENCODING](copy-parameters-data-conversion.md#copy-encoding)
+ [ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted)
+ [ESCAPE](copy-parameters-data-conversion.md#copy-escape)
+ [EXPLICIT_IDS](copy-parameters-data-conversion.md#copy-explicit-ids)
+ [FILLRECORD](copy-parameters-data-conversion.md#copy-fillrecord)
+ [FIXEDWIDTH](copy-parameters-data-format.md#copy-fixedwidth)
+ [FORMAT](copy-parameters-data-format.md#copy-format)
+ [FROM](copy-parameters-data-source-s3.md#copy-parameters-from)
+ [GZIP](copy-parameters-file-compression.md#copy-gzip)
+ [IAM\$1ROLE](copy-parameters-authorization.md#copy-iam-role-iam)
+ [IGNOREALLERRORS](copy-parameters-data-load.md#copy-ignoreallerrors)
+ [IGNOREBLANKLINES](copy-parameters-data-conversion.md#copy-ignoreblanklines)
+ [IGNOREHEADER](copy-parameters-data-conversion.md#copy-ignoreheader)
+ [JSON format for COPY](copy-parameters-data-format.md#copy-json)
+ [LZOP](copy-parameters-file-compression.md#copy-lzop)
+ [MANIFEST](copy-parameters-data-source-s3.md#copy-manifest)
+ [MASTER_SYMMETRIC_KEY](copy-parameters-data-source-s3.md#copy-master-symmetric-key)
+ [MAXERROR](copy-parameters-data-load.md#copy-maxerror)
+ [NOLOAD](copy-parameters-data-load.md#copy-noload)
+ [NULL AS](copy-parameters-data-conversion.md#copy-null-as)
+ [READRATIO](copy-parameters-data-source-dynamodb.md#copy-readratio)
+ [REGION](copy-parameters-data-source-s3.md#copy-region)
+ [REMOVEQUOTES](copy-parameters-data-conversion.md#copy-removequotes)
+ [ROUNDEC](copy-parameters-data-conversion.md#copy-roundec)
+ [SESSION\$1TOKEN](copy-parameters-authorization.md#copy-token)
+ [SHAPEFILE](copy-parameters-data-format.md#copy-shapefile)
+ [SSH](copy-parameters-data-source-ssh.md#copy-ssh)
+ [STATUPDATE](copy-parameters-data-load.md#copy-statupdate)
+ [TIMEFORMAT](copy-parameters-data-conversion.md#copy-timeformat)
+ [TRIMBLANKS](copy-parameters-data-conversion.md#copy-trimblanks)
+ [TRUNCATECOLUMNS](copy-parameters-data-conversion.md#copy-truncatecolumns)
+ [ZSTD](copy-parameters-file-compression.md#copy-zstd)
# 使用に関する注意事項
**Topics**
+ [他の AWS リソースにアクセスするアクセス許可](copy-usage_notes-access-permissions.md)
+ [Amazon S3 アクセスポイントのエイリアスで COPY を使用する](copy-usage_notes-s3-access-point-alias.md)
+ [Amazon S3 からマルチバイトのデータをロードする](copy-usage_notes-multi-byte.md)
+ [GEOMETRY もしくは GEOGRAPHY データ型の列のロード](copy-usage_notes-spatial-data.md)
+ [HLLSKETCH データ型のロード](copy-usage_notes-hll.md)
+ [VARBYTE データ型の列のロード](copy-usage-varbyte.md)
+ [複数ファイル読み取り時のエラー](copy-usage_notes-multiple-files.md)
+ [JSON 形式からの COPY](copy-usage_notes-copy-from-json.md)
+ [列データ形式の COPY](copy-usage_notes-copy-from-columnar.md)
+ [DATEFORMAT と TIMEFORMAT の文字列](r_DATEFORMAT_and_TIMEFORMAT_strings.md)
+ [DATEFORMAT と TIMEFORMAT で自動認識を使用する](automatic-recognition.md)
# 他の AWS リソースにアクセスするアクセス許可
クラスターと他の AWS リソース (Amazon S3、Amazon DynamoDB、Amazon EMR、または Amazon EC2 など) との間でデータを移動する場合、クラスターには、リソースにアクセスして必要なアクションを実行するための許可が必要です。例えば、Amazon S3 からデータをロードする場合、COPY はバケットへの LIST アクセスとバケットオブジェクトへの GET アクセスが必要です。最小限のアクセス権限については、「[COPY、UNLOAD、CREATE LIBRARY のための IAM のアクセス許可](#copy-usage_notes-iam-permissions)」を参照してください。
リソースにアクセスする認可を取得するには、クラスターが認証される必要があります。次の認証方法のいずれかを選択できます。
+ [ロールベースアクセスコントロール](#copy-usage_notes-access-role-based)– ロールベースのアクセスコントロールの場合、クラスターが認証と認可に使用する AWS Identity and Access Management (IAM) ロールを指定します。AWS 認証情報および機密データを保護するには、ロールベースの認証を使用することを強くお勧めします。
+ [キーベースのアクセスコントロール](#copy-usage_notes-access-key-based) – キーベースのアクセスコントロールの場合は、ユーザーの AWS アクセス認証情報 (アクセスキー ID とシークレットアクセスキー) をプレーンテキストとして指定します。
## ロールベースアクセスコントロール
ロールベースのアクセスコントロールを使用して、クラスターはユーザーに代わって一時的に、IAM ロールを引き受けます。その後、そのロールに付与された承認内容に基づいて、クラスターは必要な AWS のリソースにアクセスできるようになります。
IAM *ロール*の作成は、ロールが AWS アイデンティティであり、AWS で何を実行でき、何を実行できないかを決定するアクセス許可ポリシーを持つという点で、ユーザーへのアクセス許可の付与と似ています。ただし、1 人のユーザーに一意に関連付けられるのではなく、ロールは必要に応じてすべてのエンティティが引き受けることができます。また、ロールにはいずれの認証情報 (パスワードやアクセスキー) も関連付けられません。代わりに、ロールがクラスターに関連付けられた場合は、アクセスキーが動的に作成され、クラスターに提供されます。
AWS 認証情報を保護することに加えて、AWSのリソースおよび機密ユーザーデータへのアクセスに対して、より安全で、きめの細かいコントロールを提供するロールベースのアクセスコントロールの使用をお勧めします。
ロールベースの認証には次の利点があります。
+ AWS 標準の IAM ツールを使用して、IAM ロールを定義し、そのロールを複数のクラスターと関連付けられます。ロールのためにアクセスポリシーを変更すると、変更はロールを使用するすべてのクラスターに自動的に適用されます。
+ 特定の AWS リソースおよびアクションへのアクセス許可を、特定のクラスターとデータベースユーザーに付与するための、きめ細かな IAM ポリシーを定義できます。
+ クラスターは、実行時に一時的なセッション認証情報を取得し、必要に応じて操作が完了するまで認証情報を更新します。キーに基づく一時的認証情報を使用する場合、完了する前に一時的認証情報の期限が切れると、操作は失敗します。
+ アクセスキー ID とシークレットアクセスキー ID は SQL コードには格納、送信されません。
ロールベースのアクセスコントロールを使用するには、Amazon Redshift サービスロールタイプを使用して IAM ロールを作成してから、クラスターにロールをアタッチする必要があります。ロールは、少なくとも [COPY、UNLOAD、CREATE LIBRARY のための IAM のアクセス許可](#copy-usage_notes-iam-permissions) に示されたアクセス権限が必要です。IAM ロールを作成してクラスターにアタッチするステップについては、「*Amazon Redshift 管理ガイド*」の「[ユーザーに代わって Amazon Redshift が他の AWS サービスにアクセスすることを認可する](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html)」を参照してください。
クラスターにロールを追加するか、Amazon Redshift マネジメントコンソール、CLI、または API を使用してクラスターに関連付けられるロールを表示できます。詳細については、「*Amazon Redshift 管理ガイド*」の「[IAM ロールとクラスターの関連付け](https://docs.aws.amazon.com/redshift/latest/mgmt/copy-unload-iam-role.html)」を参照してください。
IAM ロールを作成する場合、IAM はロールの Amazon リソースネーム (ARN) を返します。IAM ロールを指定するには、[IAM\$1ROLE パラメータの使用](copy-parameters-authorization.md#copy-iam-role)パラメータまたは [CREDENTIALS パラメータの使用](copy-parameters-authorization.md#copy-credentials) パラメータでロールの ARN を指定します。
例えば、以下のロールがクラスターにアタッチされるとします。
```
"IamRoleArn": "arn:aws:iam::0123456789012:role/MyRedshiftRole"
```
次の COPY コマンドの例では、Amazon S3 への認証とアクセスのために前の例の IAM\$1ROLE パラメータと ARN を使用します。
```
copy customer from 's3://amzn-s3-demo-bucket/mydata'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
次の COPY コマンドの例は、CREDENTIALS パラメータを使用して IAM ロールを指定しています。
```
copy customer from 's3://amzn-s3-demo-bucket/mydata'
credentials
'aws_iam_role=arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
さらに、スーパーユーザーは、データベースユーザーおよびグループに ASSUMEROLE 権限を付与して、COPY オペレーションのロールへのアクセスを提供できます。詳細については、[GRANT](r_GRANT.md)を参照してください。
## キーベースのアクセスコントロール
キーベースのアクセスコントロールを使用して、データが含まれている AWS リソースへのアクセスを許可された、IAM ユーザーのアクセスキー ID とシークレットアクセスキーを提供します。[ACCESS\$1KEY\$1ID および SECRET\$1ACCESS\$1KEY パラメータの使用](copy-parameters-authorization.md#copy-access-key-id) パラメータを一緒に使用するか、[CREDENTIALS パラメータの使用](copy-parameters-authorization.md#copy-credentials)パラメータを使用できます。
**注記**
プレーンテキストのアクセスキー ID とシークレットアクセスキーを指定する代わりに、認証のために IAM ロールを使用することを強くお勧めします。キーベースのアクセスコントロールを選択する場合は、AWSアカウント (ルート) 認証情報を使用しないでください。常に IAM ユーザーを作成し、そのユーザーのアクセスキー ID とシークレットアクセスキーを指定します。IAM ユーザーを作成する手順については、「[AWS アカウントでの IAM ユーザーの作成](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html)」を参照してください。
ACCESS\$1KEY\$1ID と SECRET\$1ACCESS\$1KEY を使用して認証するには、次に示すように、承認されたユーザーのアクセスキー ID および完全なシークレットアクセスキーで、** と ** を置き換えます。
```
ACCESS_KEY_ID ''
SECRET_ACCESS_KEY '';
```
CREDENTIALS パラメータを使用して認証するには、次に示すように、承認されたユーザーのアクセスキー ID および完全なシークレットアクセスキーで、** と ** を置き換えます。
```
CREDENTIALS
'aws_access_key_id=;aws_secret_access_key=';
```
IAM ユーザーは、少なくとも [COPY、UNLOAD、CREATE LIBRARY のための IAM のアクセス許可](#copy-usage_notes-iam-permissions) に示された許可が必要です。
### 一時的な認証情報
キーに基づくアクセスコントロールを使用する場合、一時的なセキュリティ認証情報を使用して、データへのユーザーのアクセスを制限できます。ロールベースの認証は、自動的に一時的な認証情報を使用します。
**注記**
一時的な認証情報を作成してアクセスキー ID とシークレットアクセスキーをプレーンテキストで提供するのではなく、「[role-based access control](#copy-usage_notes-access-role-based.phrase)」を使用することを強くお勧めします。ロールベースのアクセスコントロールは、自動的に一時的な認証情報を使用します。
一時的セキュリティ認証情報はセキュリティを強化します。使用期限が短く、期限が切れた後は再利用できないためです。トークンを使用して生成されるアクセスキー ID とシークレットアクセスキーはトークンなしに使用できません。これらの一時的セキュリティ認証情報を持つユーザーは認証情報の有効期限内のみリソースにアクセスできます。
ユーザーにリソースへの一時的アクセスを許可するには AWS Security Token Service (AWS STS) API 操作を呼び出します。AWS STS API 操作は、セキュリティトークン、アクセスキー ID、およびシークレットアクセスキーから構成される一時的セキュリティ認証情報を返します。一時的セキュリティ認証情報は、リソースへの一時的アクセスを必要とするユーザーに発行します。これらのユーザーは既存の IAM ユーザーであるか、非 AWS ユーザーです。一時的なセキュリティ認証情報の作成に関する詳細については、IAM ユーザーガイドの[一時的なセキュリティ認証情報の使用](https://docs.aws.amazon.com/STS/latest/UsingSTS/Welcome.html)を参照してください。
[ACCESS\$1KEY\$1ID および SECRET\$1ACCESS\$1KEY パラメータの使用](copy-parameters-authorization.md#copy-access-key-id) パラメータとともに [SESSION\$1TOKEN](copy-parameters-authorization.md#copy-token) パラメータを使用するか、[CREDENTIALS パラメータの使用](copy-parameters-authorization.md#copy-credentials)パラメータを使用できます。また、トークンと共に提供されているアクセスキー ID とシークレットアクセスキーを指定する必要があります。
ACCESS\$1KEY\$1ID、SECRET\$1ACCESS\$1KEY、および SESSION\$1TOKEN を使用して認証するには、次に示すように、**、**、および ** を置き換えます。
```
ACCESS_KEY_ID ''
SECRET_ACCESS_KEY ''
SESSION_TOKEN '';
```
CREDENTIALS を使用して認証するには、次のように `session_token=` を認証情報文字列に含めます。
```
CREDENTIALS
'aws_access_key_id=;aws_secret_access_key=;session_token=';
```
次の例は、一時的セキュリティ認証情報を使用する COPY コマンドを示しています。
```
copy table-name
from 's3://objectpath'
access_key_id ''
secret_access_key ''
session_token '';
```
次の例では、一時的認証情報とファイル暗号化を使用して LISTING テーブルをロードします。
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings_pipe.txt'
access_key_id ''
secret_access_key ''
session_token ''
master_symmetric_key ''
encrypted;
```
次の例では、CREDENTIALS パラメータを一時的認証情報およびファイル暗号化とともに使用して LISTING テーブルをロードします。
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings_pipe.txt'
credentials
'aws_access_key_id=;aws_secret_access_key=;session_token=;master_symmetric_key='
encrypted;
```
**重要**
一時的セキュリティ認証情報は、COPY および UNLOAD 操作の期間全体で有効にする必要があります。一時的セキュリティ認証情報の期限が操作中に切れた場合、コマンドは失敗し、処理はロールバックされます。例えば、一時的セキュリティ認証情報の期限が 15 分後に切れるときに COPY 操作に 1 時間かかる場合、COPY 操作は完了前に失敗します。ロールベースのアクセスを使用する場合、一時的なセキュリティ認証情報は操作が完了するまで自動的に更新されます。
## COPY、UNLOAD、CREATE LIBRARY のための IAM のアクセス許可
CREDENTIALS パラメータによって参照される IAM ロールまたはユーザーには、少なくとも、次のアクセス許可が必要です。
+ Amazon S3 から COPY の場合、Amazon S3 バケットを LIST するアクセス許可であり、ロードされている Amazon S3 オブジェクトと、マニフェストファイル (使用する場合) を GET するアクセス許可。
+ Amazon S3、Amazon EMR、および JSON 形式のデータのリモートホスト (SSH) から COPY を実行する場合は、Amazon S3 の JSONPaths ファイル (使用する場合) に対して LIST および GET を実行するアクセス許可。
+ DynamoDB から COPY を実行する場合は、ロードされた DynamoDB テーブルに対して SCAN および DESCRIBE を実行するアクセス許可。
+ Amazon EMR クラスターから COPY を実行する場合、`ListInstances` アクションを Amazon EMR クラスターで実行するための許可。
+ Amazon S3 への UNLOAD の場合、データファイルのアンロード先 Amazon S3 バケットに対する GET、LIST、および PUT 許可。
+ Amazon S3 からの CREATE LIBRARY の場合、Amazon S3 バケットを一覧表示し、インポートされる Amazon S3 オブジェクトを取得する許可。
**注記**
COPY、UNLOAD、CREATE LIBRARY コマンドの実行時に、`S3ServiceException: Access Denied`というエラーメッセージが返される場合、クラスターには Amazon S3 への適切なアクセス許可がありません。
IAM ポリシーを管理するには、クラスター、ユーザー、またはユーザーが属するグループにアタッチされている IAM ロールに IAM ポリシーをアタッチします。例えば、`AmazonS3ReadOnlyAccess` マネージドポリシーは、Amazon S3 リソースへの LIST および GET 許可を付与します。IAM ポリシーの詳細については、*IAM ユーザーガイド*の [IAM ポリシーの管理](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage.html)を参照してください。
# Amazon S3 アクセスポイントのエイリアスで COPY を使用する
COPY は、Amazon S3 アクセスポイントのエイリアスをサポートしています。詳細については、*Amazon Simple Storage Service ユーザーガイド*の[アクセスポイントにバケットスタイルのエイリアスを使用する](https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-points-alias.html)を参照してください。
# Amazon S3 からマルチバイトのデータをロードする
データに ASCII 以外のマルチバイト文字 (漢字やキリル文字) が含まれる場合、データを VARCHAR 列にロードする必要があります。VARCHAR データ型は 4 バイトの UTF-8 文字をサポートしますが、CHAR データ型はシングルバイトの ASCII 文字のみを受け取ります。5 バイト以上の文字を Amazon Redshift テーブルにロードすることはできません。詳細については、「[マルチバイト文字](c_Supported_data_types.md#c_Supported_data_types-multi-byte-characters)」を参照してください。
# GEOMETRY もしくは GEOGRAPHY データ型の列のロード
CSV ファイルなどの文字区切りのテキストファイルに含まれるデータから、`GEOMETRY` あるいは `GEOGRAPHY` 列に対して COPY が可能です。データは、Well-known Binary (WKB もしくは EWKB のいずれか) 形式、または Well-known Text (WKT もしくは EWKT) 形式の 16 進表記であり、COPY コマンドへの単一の入力行の最大サイズ内に収まる必要があります。詳細については、「[COPY](r_COPY.md)」を参照してください。
シェープファイルからロードする方法については、「[シェープファイルを Amazon Redshift にロードする](spatial-copy-shapefile.md)」を参照してください。
`GEOMETRY` および `GEOGRAPHY` データ型の詳細については、「[Amazon Redshift での空間データのクエリ](geospatial-overview.md)」を参照してください。
# HLLSKETCH データ型のロード
HLL スケッチは、Amazon Redshift でサポートされているスパース形式またはデンス形式でのみコピーできます。HyperLogLog スケッチで COPY コマンドを使用するには、デンスの HyperLogLog スケッチには Base64 形式を使用し、スパースの HyperLogLog スケッチには JSON 形式を使用します。詳細については、「[HyperLogLog 関数](hyperloglog-functions.md)」を参照してください。
次の例では、CREATE TABLE および COPY を使用して、CSV ファイルからテーブルにデータをインポートします。まず、この例では、CREATE TABLE を使用してテーブル `t1` を作成します。
```
CREATE TABLE t1 (sketch hllsketch, a bigint);
```
次に、COPY を使用して CSV ファイルからテーブル `t1` にデータをインポートします。
```
COPY t1 FROM s3://amzn-s3-demo-bucket/unload/' IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole' NULL AS 'null' CSV;
```
# VARBYTE データ型の列のロード
CSV、Parquet、ORC 形式のファイルからデータをロードできます。CSV の場合、データは、VARBYTE データの 16 進数表現によりファイルからロードされます。`FIXEDWIDTH` オプションを指定して VARBYTE データをロードすることはできません。COPY の `ADDQUOTES` または `REMOVEQUOTES` オプションは、サポートされていません。VARBYTE 列をパーティション列として使用することはできません。
# 複数ファイル読み取り時のエラー
COPY コマンドはアトミックでトランザクショナルです。つまり、COPY コマンドが複数のファイルからデータを読み取る場合でも、プロセス全体は 1 つのトランザクションとして扱われます。COPY でファイル読み込みにエラーが発生した場合、プロセスがタイムアウトになるまで ([statement\$1timeout](r_statement_timeout.md) を参照)、または長時間 (15～30 分間) Amazon S3 からデータをダウンロードできないときは各ファイルを 1 回のみロードするようにして、自動的にファイル読み込みを再試行します。COPY コマンドが失敗した場合、トランザクション全体がキャンセルされ、変更はすべてロールバックされます。ロードエラー処理の詳細については、「[データロードのトラブルシューティング](t_Troubleshooting_load_errors.md)」を参照してください。
COPY コマンドが正常に開始されると、クライアントによる切断などでセッションが終了しても、アプリケーションは停止しません。ただし、COPY コマンドが BEGIN … END セッションブロック内にあり、セッションが終了したためにこのブロックが完了していない場合、COPY を含むすべてのトランザクションがロールバックされます。トランザクションの詳細については、「[BEGIN](r_BEGIN.md)」を参照してください。
# JSON 形式からの COPY
JSON のデータ構造は、一連のオブジェクトまたは配列により構成されています。JSON *オブジェクト*の先頭と末尾には中括弧が付き、順序が設定されていない一連の名前と値のペアが含まれます。各名前と値はコロンで区切られ、ペアはカンマで区切られます。名前は二重引用符で囲まれた文字列です。引用符は、傾きの付いた「高機能な」引用符ではなくシンプルな引用符 (0x22) にする必要があります。
JSON *配列*の先頭と末尾には角括弧が付き、順序が設定された一連のカンマ区切りの値が含まれます。値には、二重引用符で囲まれた文字列、数値、ブール値の true または false、Null、JSON オブジェクト、配列を指定できます。
JSON のオブジェクトと配列を入れ子にして、階層データ構造を実現できます。次の例は、2 つの有効なオブジェクトを持つ JSON データ構造を示しています。
```
{
"id": 1006410,
"title": "Amazon Redshift Database Developer Guide"
}
{
"id": 100540,
"name": "Amazon Simple Storage Service User Guide"
}
```
2 つの JSON 配列と同じデータを次に示します。
```
[
1006410,
"Amazon Redshift Database Developer Guide"
]
[
100540,
"Amazon Simple Storage Service User Guide"
]
```
## JSON の COPY オプション
JSON 形式のデータで COPY を使用する場合は、次のオプションを指定できます。
+ `'auto' ` – COPY は JSON ファイルからフィールドを自動的にロードします。
+ `'auto ignorecase'` – COPY は、フィールド名の大文字と小文字を区別せずに、JSON ファイルからフィールドを自動的にロードします。
+ `s3://jsonpaths_file` – COPY は JSONPaths ファイルを使用して JSON ソースデータを解析します。*JSONPaths ファイル*は、JSONPath 式の配列とペアになった `"jsonpaths"` という名前の単一の JSON オブジェクトを格納するテキストファイルです。名前が `"jsonpaths"` 以外の文字列である場合、COPY は JSONPaths ファイルの代わりに `'auto'` 引数を使用します。
`'auto'`、`'auto ignorecase'`、または JSONPaths ファイルを使用し、JSON オブジェクトまたは配列のいずれかを使用してデータをロードする方法を示す例については、[JSON からのコピーの例](r_COPY_command_examples.md#r_COPY_command_examples-copy-from-json) を参照してください。
## JSONPath オプション
Amazon Redshift COPY 構文では、JSONPath 式は、角括弧表記またはドット表記のいずれかを使用して、JSON の階層データ構造内の 1 つの名前要素に対する明示的なパスを指定します。Amazon Redshift では、あいまいなパスや複数の名前要素に解決される可能性がある、ワイルドカード文字やフィルター式などの JSONPath 要素をサポートしていません。その結果、Amazon Redshift は複雑な複数レベルのデータ構造を解析することはできません。
次は、ブラケット表記を使用した JSONPath 式を含む JSONPaths ファイルの例です。ドル記号 (\$1) はルートレベル構造を現します。
```
{
"jsonpaths": [
"$['id']",
"$['store']['book']['title']",
"$['location'][0]"
]
}
```
前の例で、`$['location'][0]`は配列内の最初の要素を参照します。JSON はゼロベースの配列インデックス付けを使用します。配列インデックスは正の整数 (0 以上) である必要があります。
次の例は、前出の JSONPaths ファイルをドット表記で表したものです。
```
{
"jsonpaths": [
"$.id",
"$.store.book.title",
"$.location[0]"
]
}
```
`jsonpaths` 配列でブラケット表記とドット表記を混在させることはできません。ブラケットは、配列要素を参照するためにブラケット表記とドット表記の両方で使用できます。
ドット表記を使用する場合、JSONPath の式は以下の文字を含む必要があります。
+ 1 つの一重引用符 ( ' )
+ ピリオドまたはドット (.)
+ 配列要素を参照するために使用されていない場合はブラケット ( [ ] )
JSONPath 式によって参照される名前と値のペアの値がオブジェクトまたは配列の場合は、中括弧または角括弧を含むオブジェクトまたは配列全体が文字列としてロードされます。例えば、JSON データに次のオブジェクトが含まれているとします。
```
{
"id": 0,
"guid": "84512477-fa49-456b-b407-581d0d851c3c",
"isActive": true,
"tags": [
"nisi",
"culpa",
"ad",
"amet",
"voluptate",
"reprehenderit",
"veniam"
],
"friends": [
{
"id": 0,
"name": "Martha Rivera"
},
{
"id": 1,
"name": "Renaldo"
}
]
}
```
この場合、JSONPath 式 `$['tags']` は次の値を返します。
```
"["nisi","culpa","ad","amet","voluptate","reprehenderit","veniam"]"
```
この場合、JSONPath 式 `$['friends'][1]` は次の値を返します。
```
"{"id": 1,"name": "Renaldo"}"
```
`jsonpaths` 配列の各 JSONPath 式は、Amazon Redshift のターゲットテーブル内の 1 列に対応しています。`jsonpaths` 配列要素の順序は、ターゲットテーブル内の列の順序または列リストが使用される場合は列リスト内の列の順序と一致していなければなりません。
`'auto'` 引数または JSONPaths ファイルを使用し、JSON オブジェクトまたは配列のいずれかを使用してデータをロードする方法を示す例については、「[JSON からのコピーの例](r_COPY_command_examples.md#r_COPY_command_examples-copy-from-json)」を参照してください。
複数の JSON ファイルをコピーする方法については、[マニフェストを使用し、データファイルを指定する](loading-data-files-using-manifest.md) を参照してください。
## JSON のエスケープ文字
COPY は改行文字として `\n` を、タブ文字として `\t` をロードします。バックスラッシュをロードするには、バックスラッシュをバックスラッシュでエスケープします (`\\`)。
例えば、バケット `escape.json` 内の `s3://amzn-s3-demo-bucket/json/` という名前のファイルに、次の JSON があるとします。
```
{
"backslash": "This is a backslash: \\",
"newline": "This sentence\n is on two lines.",
"tab": "This sentence \t contains a tab."
}
```
ESCAPES テーブルを作成し JSON をロードするには、次のコマンドを実行します。
```
create table escapes (backslash varchar(25), newline varchar(35), tab varchar(35));
copy escapes from 's3://amzn-s3-demo-bucket/json/escape.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as json 'auto';
```
ESCAPES テーブルにクエリを実行し、結果を表示します。
```
select * from escapes;
backslash | newline | tab
------------------------+-------------------+----------------------------------
This is a backslash: \ | This sentence | This sentence contains a tab.
: is on two lines.
(1 row)
```
## 数値の精度の喪失
JSON 形式のデータファイルから数値データ型として定義された列に数値をロードするときに、精度が失われる可能性があります。一部の浮動小数点値は、コンピュータシステムで正確に表されません。そのため、JSON ファイルからコピーするデータは、想定したとおりに丸められない可能性があります。精度の喪失を避けるため、次のいずれかの代替策を使用することをお勧めします。
+ 二重引用文字で値を囲んで、数値を文字列として表します。
+ [ROUNDEC](copy-parameters-data-conversion.md#copy-roundec) を使用して、数値を切り捨てるのではなく丸めます。
+ JSON または Avro ファイルを使用する代わりに、CSV、文字区切り形式、または固定幅形式のテキストファイルを使用します。
# 列データ形式の COPY
COPY では、次の列形式で Amazon S3 からデータをロードできます。
+ ORC
+ Parquet
列データ形式からの COPY の使用例については、「[COPY の例](r_COPY_command_examples.md)」を参照してください。
COPY では、列形式のデータがサポートされますが、以下の考慮事項があります。
+ Amazon S3 バケットは、Amazon Redshift データベースと同じ AWS リージョンに存在する必要があります。
+ VPC エンドポイントを介して Amazon S3 データにアクセスするには、「*Amazon Redshift 管理ガイド*」の「[拡張 VPC のルーティングで Amazon Redshift Spectrum を使用する](https://docs.aws.amazon.com/redshift/latest/mgmt/spectrum-enhanced-vpc.html)」の説明に沿って、IAM ポリシーと IAM ロールを使用してアクセスを設定します。
+ COPY では、圧縮エンコードは自動的に適用されません。
+ 以下の COPY パラメータのみサポートされています。
+ ORC または Parquet ファイルからコピーする場合は [ACCEPTINVCHARS](copy-parameters-data-conversion.md#copy-acceptinvchars)。
+ [FILLRECORD](copy-parameters-data-conversion.md#copy-fillrecord)
+ [FROM](copy-parameters-data-source-s3.md#copy-parameters-from) ...
+ [IAM\$1ROLE](copy-parameters-authorization.md#copy-iam-role)
+ [CREDENTIALS](copy-parameters-authorization.md#copy-credentials)
+ [STATUPDATE ](copy-parameters-data-load.md#copy-statupdate)
+ [MANIFEST](copy-parameters-data-source-s3.md#copy-manifest)
+ [EXPLICIT\$1IDS](copy-parameters-data-conversion.md#copy-explicit-ids)
+ ロード中に COPY でエラーが発生すると、コマンドは失敗します。ACCEPTANYDATE および MAXERROR は、列データ型ではサポートされていません。
+ エラーメッセージは、SQL クライアントに送信されます。一部のエラーは、STL\$1LOAD\$1ERRORS と STL\$1ERROR に記録されます。
+ COPY は列データファイルで発生した列と同じ順序でターゲットテーブルの列に値を挿入します。ターゲットテーブルの列数とデータファイルの列数が一致する必要があります。
+ COPY オペレーションに指定したファイルに以下のいずれかの拡張子が含まれている場合、データを圧縮解除するためにパラメータを追加する必要はありません。
+ `.gz`
+ `.snappy`
+ `.bz2`
+ Parquet および ORC ファイル形式からの COPY では、Redshift Spectrum とバケットアクセスが使用されます。これらの形式で COPY を使用するには、Amazon S3 の署名付き URL の使用をブロックする IAM ポリシーがないことを確認してください。Amazon Redshift によって生成された署名付き URL は 1 時間有効です。これにより、Amazon Redshift は Amazon S3 バケットからすべてのファイルをロードするのに十分な時間を確保できます。列指向形式から COPY でスキャンしたファイルごとに、一意の署名付き URL が生成されます。`s3:signatureAge` アクションを含むバケットポリシーの場合は、値を少なくとも 3,600,000 ミリ秒に設定してください。詳細については、[拡張された VPC のルーティングで Amazon Redshift Spectrum を使用する](https://docs.aws.amazon.com/redshift/latest/mgmt/spectrum-enhanced-vpc.html)を参照してください。
+ REGION パラメータは、列データ形式からの COPY では使用できません。Amazon S3 バケットとデータベースが同じ AWS リージョンにある場合でも、REGION argument is not supported for PARQUET based COPY などのエラーが発生する可能性があります。
+ 列形式の COPY が同時実行スケーリングをサポートするようになりました。同時実行スケーリングを有効にするには、「[同時実行スケーリングキューの設定](https://docs.aws.amazon.com/redshift/latest/dg/concurrency-scaling.html#concurrency-scaling-queues)」を参照してください。
# DATEFORMAT と TIMEFORMAT の文字列
COPY コマンドは、DATEFORMAT オプションと TIMEFORMAT オプションを使用して、ソースデータの日付と時刻の値を解析します。DATEFORMAT と TIMEFORMAT はフォーマットされた文字列であり、ソースデータの日付と時刻の値の形式と一致する必要があります。例えば、日付値が `Jan-01-1999` のソースデータをロードする COPY コマンドには、次の DATEFORMAT 文字列を含める必要があります。
```
COPY ...
DATEFORMAT AS 'MON-DD-YYYY'
```
COPY データ変換の管理の詳細については、「[データ変換パラメータ](https://docs.aws.amazon.com/redshift/latest/dg/copy-parameters-data-conversion.html)」を参照してください。
DATEFORMAT と TIMEFORMAT 文字列には、日時区切り記号 ('`-`'、'`/`'、'`:`' など)、および次の「日付部分」と「時間部分」を含めることができます。
**注記**
日付値または時刻値の形式を次の dateparts および timeparts と一致させることができない場合、または互いに異なる形式を使用する日付値および時刻値がある場合は、`'auto'` 引数を DATEFORMAT または TIMEFORMAT パラメータと共に使用します。`'auto'` 引数は、DATEFORMAT または TIMEFORMAT 文字列を使用する場合にサポートされない形式を認識します。詳細については、「[DATEFORMAT と TIMEFORMAT で自動認識を使用する](automatic-recognition.md)」を参照してください。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_DATEFORMAT_and_TIMEFORMAT_strings.html)
デフォルトの日付形式は YYYY-MM-DD です。タイムゾーン (TIMESTAMP) 形式なしのデフォルトのタイプスタンプは YYYY-MM-DD HH:MI:SS です。タイムゾーン付きのデフォルトのタイムスタンプ (TIMESTAMPTZ) 形式は、YYYY-MM-DD HH:MI:SSOF です。ここで、OF は UTC からのオフセットです (例えば、–8:00。timeformat\$1string のタイムゾーン指定子 (TZ、tz または OF) を含めることはできません。秒 (SS) フィールドは、マイクロ秒レベルの詳細に至るまでの分数秒もサポートします。デフォルト形式と異なる形式の TIMESTAMPTZ データをロードするには、「auto」を指定します。
次に、ソースデータで検出できるサンプルの日付または時刻と、それらに対応する DATEFORMAT または TIMEFORMAT 文字列を示します。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_DATEFORMAT_and_TIMEFORMAT_strings.html)
## 例
TIMEFORMAT の使用例については、「[タイムスタンプまたは日付スタンプのロード](r_COPY_command_examples.md#r_COPY_command_examples-load-a-time-datestamp)」を参照してください。
# DATEFORMAT と TIMEFORMAT で自動認識を使用する
DATEFORMAT または TIMEFORMAT パラメータの引数として `'auto'` を指定すると、Amazon Redshift ではソースデータの日付形式または時間形式を自動的に認識して変換します。例を以下に示します。
```
copy favoritemovies from 'dynamodb://ProductCatalog'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
dateformat 'auto';
```
DATEFORMAT と TIMEFORMAT に `'auto'` 引数を使用すると、COPY は「[DATEFORMAT と TIMEFORMAT の文字列例](r_DATEFORMAT_and_TIMEFORMAT_strings.md)」の表に示された日付と時間の形式を認識して変換します。`'auto'` 引数は、DATEFORMAT および TIMEFORMAT 文字列を使用する場合にサポートされない次の形式も認識します。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/automatic-recognition.html)
自動認識は epochsecs および epochmillisecs はサポートしていません。
日付またはタイムスタンプの値が自動的に変換されるかどうかをテストするには、CAST 関数を使用して文字列を日付またはタイムスタンプの値に変換します。例えば、次のコマンドはタイムスタンプ値 `'J2345678 04:05:06.789'` をテストします。
```
create table formattest (test char(21));
insert into formattest values('J2345678 04:05:06.789');
select test, cast(test as timestamp) as timestamp, cast(test as date) as date from formattest;
test | timestamp | date
----------------------+---------------------+------------
J2345678 04:05:06.789 1710-02-23 04:05:06 1710-02-23
```
DATE 列のソースデータに時間情報が含まれる場合、時間コンポーネントは切り捨てられます。TIMESTAMP 列のソースデータで時間情報が省略されている場合、時間コンポーネントには 00:00:00 が使用されます。
# COPY の例
**注記**
次の例では読みやすくするため、改行しています。*credentials-args* 文字列には改行やスペースを含めないでください。
**Topics**
+ [DynamoDB テーブルから FAVORITEMOVIES をロードする](#r_COPY_command_examples-load-favoritemovies-from-an-amazon-dynamodb-table)
+ [Amazon S3 バケットから LISTING をロードする](#r_COPY_command_examples-load-listing-from-an-amazon-s3-bucket)
+ [Amazon EMR クラスターから LISTING をロードする](#copy-command-examples-emr)
+ [Example: COPY from Amazon S3 using a manifest](#copy-command-examples-manifest)
+ [パイプ区切りファイル (デフォルトの区切り記号）から LISTING をロードする](#r_COPY_command_examples-load-listing-from-a-pipe-delimited-file-default-delimiter)
+ [Parquet 形式の列指向データを使用した LISTING のロード](#r_COPY_command_examples-load-listing-from-parquet)
+ [ORC 形式の列指向データを使用した LISTING のロード](#r_COPY_command_examples-load-listing-from-orc)
+ [オプションを使用した EVENT のロード](#r_COPY_command_examples-load-event-with-options)
+ [固定幅のデータファイルから VENUE をロードする](#r_COPY_command_examples-load-venue-from-a-fixed-width-data-file)
+ [CSV ファイルから CATEGORY をロードする](#load-from-csv)
+ [IDENTITY 列の明示的値を使用して VENUE をロードする](#r_COPY_command_examples-load-venue-with-explicit-values-for-an-identity-column)
+ [パイプ区切りの GZIP ファイルから TIME をロードする](#r_COPY_command_examples-load-time-from-a-pipe-delimited-gzip-file)
+ [タイムスタンプまたは日付スタンプのロード](#r_COPY_command_examples-load-a-time-datestamp)
+ [デフォルト値を使用してファイルのデータをロードする](#r_COPY_command_examples-load-data-from-a-file-with-default-values)
+ [ESCAPE データを使用したデータのコピー](#r_COPY_command_examples-copy-data-with-the-escape-option)
+ [JSON からのコピーの例](#r_COPY_command_examples-copy-from-json)
+ [Avro の例からのコピー](#r_COPY_command_examples-copy-from-avro)
+ [ESCAPE オプションを指定する COPY 用のファイルの準備](#r_COPY_preparing_data)
+ [シェープファイルを Amazon Redshift にロードする](#copy-example-spatial-copy-shapefile)
+ [NOLOAD オプションを使用する COPY コマンド](#r_COPY_command_examples-load-noload-option)
+ [マルチバイト区切り文字と ENCODING オプションを含む COPY コマンド](#r_COPY_command_examples-load-encoding-multibyte-delimiter-option)
## DynamoDB テーブルから FAVORITEMOVIES をロードする
AWS SDK には、*Movies* という名前の DynamoDB テーブルを作成する簡単な例が含まれています。(この例については、[DynamoDB の使用開始](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStarted.html)を参照)。次の例では、DynamoDB テーブルから Amazon Redshift MOVIES テーブルにデータをロードします。Amazon Redshift テーブルはすでにデータベースに存在する必要があります。
```
copy favoritemovies from 'dynamodb://Movies'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
readratio 50;
```
## Amazon S3 バケットから LISTING をロードする
次の例では、Amazon S3 バケットから LISTING をロードします。COPY コマンドは `/data/listing/` フォルダ内のすべてのファイルをロードします。
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listing/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
## Amazon EMR クラスターから LISTING をロードする
次の例は、タブ区切りデータを含んだ SALES テーブルを Amazon EMR クラスター上の LZOP 圧縮ファイルからロードします。COPY は、`myoutput/`フォルダ内の `part-` で始まるすべてのファイルをロードします。
```
copy sales
from 'emr://j-SAMPLE2B500FC/myoutput/part-*'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '\t' lzop;
```
次の例は、Amazon EMR クラスター上の JSON 形式データを SALES テーブルにロードします。COPY は、`myoutput/json/`フォルダ内のすべてのファイルをロードします。
```
copy sales
from 'emr://j-SAMPLE2B500FC/myoutput/json/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
JSON 's3://amzn-s3-demo-bucket/jsonpaths.txt';
```
## マニフェストを使用し、データファイルを指定する
マニフェストを使用すると、COPY コマンドで必要なすべてのファイル、しかも必要なファイルのみを Amazon S3 からロードできます。異なるバケットの複数のファイル、または同じプレフィックスを共有しない複数のファイルをロードする必要がある場合も、マニフェストを使用できます。
たとえば、3 つのファイル `custdata1.txt`、`custdata2.txt`、`custdata3.txt`をロードする必要があるとします。次のコマンドを使用し、プレフィックスを指定することで、`amzn-s3-demo-bucket`内で `custdata` で始まるすべてのファイルをロードすることができます。
```
copy category
from 's3://amzn-s3-demo-bucket/custdata'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
エラーのために 2 つのファイルしか存在しない場合、COPY はこれら 2 つのファイルのみロードして正常に終了しますが、データロードは未完了になります。バケット内に同じプレフィックスを使用する不要なファイル (`custdata.backup` などのファイル) がある場合、COPY はそのファイルもロードするため、不要なデータがロードされることになります。
必要なファイルがすべてロードされ、不要なデータがロードされないようにするには、マニフェストファイルを使用できます。マニフェストは、COPY コマンドで処理されるファイルをリストする、JSON 形式のテキストファイルです。例えば、次のマニフェストは前の例の 3 つのファイルをロードします。
```
{
"entries":[
{
"url":"s3://amzn-s3-demo-bucket/custdata.1",
"mandatory":true
},
{
"url":"s3://amzn-s3-demo-bucket/custdata.2",
"mandatory":true
},
{
"url":"s3://amzn-s3-demo-bucket/custdata.3",
"mandatory":true
}
]
}
```
オプションの `mandatory` フラグは、ファイルが存在しない場合に COPY を終了することを示します。デフォルトは `false` です。mandatory 設定と関係なく、どのファイルも見つからない場合、COPY は終了します。この例で、ファイルが見つからない場合、COPY はエラーを返します。`custdata.backup` など、キープレフィックスのみ指定した場合に選択された可能性がある不要なファイルは、マニフェストにないため、無視されます。
以下の例に示すように、Parquet または ORC 形式のデータファイルからロードする場合、`meta`フィールドは必須です。
```
{
"entries":[
{
"url":"s3://amzn-s3-demo-bucket1/orc/2013-10-04-custdata",
"mandatory":true,
"meta":{
"content_length":99
}
},
{
"url":"s3://amzn-s3-demo-bucket2/orc/2013-10-05-custdata",
"mandatory":true,
"meta":{
"content_length":99
}
}
]
}
```
次の例では、`cust.manifest`という名前のマニフェストを使用します。
```
copy customer
from 's3://amzn-s3-demo-bucket/cust.manifest'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as orc
manifest;
```
マニフェストを使用し、異なるバケットからファイルをロードしたり、同じプレフィックスを共有しないファイルをロードしたりできます。次の例は、日付スタンプで始まる名前を持つファイルのデータをロードする JSON を示しています。
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket/2013-10-04-custdata.txt","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket/2013-10-05-custdata.txt","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket/2013-10-06-custdata.txt","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket/2013-10-07-custdata.txt","mandatory":true}
]
}
```
バケットがクラスターと同じ AWS リージョンにある限り、マニフェストは異なるバケットにあるファイルをリストできます。
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket1/custdata1.txt","mandatory":false},
{"url":"s3://amzn-s3-demo-bucket2/custdata1.txt","mandatory":false},
{"url":"s3://amzn-s3-demo-bucket2/custdata2.txt","mandatory":false}
]
}
```
## パイプ区切りファイル (デフォルトの区切り記号）から LISTING をロードする
次の例は、オプションが指定されておらず、入力ファイルにデフォルトの区切り記号であるパイプ文字 (\$1) が含まれる簡単な場合を示しています。
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
## Parquet 形式の列指向データを使用した LISTING のロード
次の例では、parquet と呼ばれる Amazon S3 のフォルダからデータをロードします。
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings/parquet/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as parquet;
```
## ORC 形式の列指向データを使用した LISTING のロード
次の例では、`orc`と呼ばれる Amazon S3 のフォルダからデータをロードします。
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings/orc/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as orc;
```
## オプションを使用した EVENT のロード
次の例では、パイプ区切りデータを EVENT テーブルにロードし、次のルールを適用します。
+ 引用符のペアを使用して文字列を囲んでいる場合、引用符は削除されます。
+ 空の文字列と空白を含む文字列は NULL 値としてロードされます。
+ 5 件を超えるエラーが返されると、ロードは失敗します。
+ タイムスタンプ値は指定された形式に準拠する必要があります。たとえば、`2008-09-26 05:43:12`は有効なタイムスタンプです。
```
copy event
from 's3://amzn-s3-demo-bucket/data/allevents_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
removequotes
emptyasnull
blanksasnull
maxerror 5
delimiter '|'
timeformat 'YYYY-MM-DD HH:MI:SS';
```
## 固定幅のデータファイルから VENUE をロードする
```
copy venue
from 's3://amzn-s3-demo-bucket/data/venue_fw.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
fixedwidth 'venueid:3,venuename:25,venuecity:12,venuestate:2,venueseats:6';
```
前述の例では、次のサンプルデータと同じ形式のデータファイルを想定しています。次の例では、すべての列が仕様に示された幅と同じになるよう、スペースがプレースホルダーの役割を果たします。
```
1 Toyota Park Bridgeview IL0
2 Columbus Crew Stadium Columbus OH0
3 RFK Stadium Washington DC0
4 CommunityAmerica BallparkKansas City KS0
5 Gillette Stadium Foxborough MA68756
```
## CSV ファイルから CATEGORY をロードする
次の表に示す値とともに CATEGORY をロードしたいとします。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_COPY_command_examples.html)
次の例は、テキストファイルの内容をカンマで区切ったフィールド値とともに示しています。
```
12,Shows,Musicals,Musical theatre
13,Shows,Plays,All "non-musical" theatre
14,Shows,Opera,All opera, light, and "rock" opera
15,Concerts,Classical,All symphony, concerto, and choir concerts
```
カンマ区切り入力を指定する DELIMITER パラメータを使用してファイルをロードした場合、一部の入力フィールドにカンマが含まれているため、COPY コマンドは失敗します。この問題を避けるには、CSV パラメータを使用し、カンマを含むフィールドを引用符で囲みます。引用符で囲んだ文字列内に引用符がある場合、引用符を 2 つにしてエスケープする必要があります。デフォルトの引用符は二重引用符です。したがって、二重引用符を追加して各二重引用符をエスケープする必要があります。新しい入力ファイルは次のようになります。
```
12,Shows,Musicals,Musical theatre
13,Shows,Plays,"All ""non-musical"" theatre"
14,Shows,Opera,"All opera, light, and ""rock"" opera"
15,Concerts,Classical,"All symphony, concerto, and choir concerts"
```
ファイル名が `category_csv.txt` であるとした場合、次の COPY コマンドを使用してファイルをロードできます。
```
copy category
from 's3://amzn-s3-demo-bucket/data/category_csv.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
csv;
```
または、入力内の二重引用符をエスケープする必要をなくすため、QUOTE AS パラメータを使用して異なる引用文字を指定できます。例えば、`category_csv.txt` の次のバージョンでは引用文字として "`%`" を使用しています。
```
12,Shows,Musicals,Musical theatre
13,Shows,Plays,%All "non-musical" theatre%
14,Shows,Opera,%All opera, light, and "rock" opera%
15,Concerts,Classical,%All symphony, concerto, and choir concerts%
```
次の COPY コマンドでは QUOTE AS を使用して `category_csv.txt` をロードします。
```
copy category
from 's3://amzn-s3-demo-bucket/data/category_csv.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
csv quote as '%';
```
## IDENTITY 列の明示的値を使用して VENUE をロードする
次の例では、VENUE テーブルの作成時に少なくとも 1 列 (`venueid` 列など) は IDENTITY 列とするよう指定されたと想定しています。このコマンドは IDENTITY 列の自動生成値のデフォルトの IDENTITY 動作をオーバーライドし、代わりに venue.txt ファイルから明示的値をロードします。Amazon Redshift は、EXLICIT\$1IDS オプションを使用するときに、重複する IDENTITY 値がテーブルにロードされているかどうかを確認しません。
```
copy venue
from 's3://amzn-s3-demo-bucket/data/venue.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
explicit_ids;
```
## パイプ区切りの GZIP ファイルから TIME をロードする
次の例では、パイプ区切りの GZIP ファイルから TIME テーブルをロードします。
```
copy time
from 's3://amzn-s3-demo-bucket/data/timerows.gz'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
gzip
delimiter '|';
```
## タイムスタンプまたは日付スタンプのロード
次の例では、書式設定したタイムスタンプ付きのデータをロードします。
**注記**
TIMEFORMAT `HH:MI:SS` では、`SS`を超える小数点以下の秒数もマイクロ秒レベルまでサポートします。この例で使用されるファイル `time.txt` には `2009-01-12 14:15:57.119568` という 1 行が含まれています。
```
copy timestamp1
from 's3://amzn-s3-demo-bucket/data/time.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
timeformat 'YYYY-MM-DD HH:MI:SS';
```
このコピーの結果は次のとおりです。
```
select * from timestamp1;
c1
----------------------------
2009-01-12 14:15:57.119568
(1 row)
```
## デフォルト値を使用してファイルのデータをロードする
次の例では、TICKIT データベースの VENUE テーブルのバリエーションを使用します。次のステートメントで定義される VENUE\$1NEW テーブルを考えてみます。
```
create table venue_new(
venueid smallint not null,
venuename varchar(100) not null,
venuecity varchar(30),
venuestate char(2),
venueseats integer not null default '1000');
```
次の例に示すように、VENUESEATS 列に値がない venue\$1noseats.txt データファイルを考えてみます。
```
1|Toyota Park|Bridgeview|IL|
2|Columbus Crew Stadium|Columbus|OH|
3|RFK Stadium|Washington|DC|
4|CommunityAmerica Ballpark|Kansas City|KS|
5|Gillette Stadium|Foxborough|MA|
6|New York Giants Stadium|East Rutherford|NJ|
7|BMO Field|Toronto|ON|
8|The Home Depot Center|Carson|CA|
9|Dick's Sporting Goods Park|Commerce City|CO|
10|Pizza Hut Park|Frisco|TX|
```
次の COPY ステートメントはファイルからテーブルを正しくロードし、省略された列に DEFAULT 値 ('1000') を適用します。
```
copy venue_new(venueid, venuename, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_noseats.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|';
```
ロードされたテーブルを表示します。
```
select * from venue_new order by venueid;
venueid | venuename | venuecity | venuestate | venueseats
---------+----------------------------+-----------------+------------+------------
1 | Toyota Park | Bridgeview | IL | 1000
2 | Columbus Crew Stadium | Columbus | OH | 1000
3 | RFK Stadium | Washington | DC | 1000
4 | CommunityAmerica Ballpark | Kansas City | KS | 1000
5 | Gillette Stadium | Foxborough | MA | 1000
6 | New York Giants Stadium | East Rutherford | NJ | 1000
7 | BMO Field | Toronto | ON | 1000
8 | The Home Depot Center | Carson | CA | 1000
9 | Dick's Sporting Goods Park | Commerce City | CO | 1000
10 | Pizza Hut Park | Frisco | TX | 1000
(10 rows)
```
次の例の場合、ファイルに VENUESEATS データが含まれていないことを想定すると共に、VENUENAME データも含まれていないことを想定します。
```
1||Bridgeview|IL|
2||Columbus|OH|
3||Washington|DC|
4||Kansas City|KS|
5||Foxborough|MA|
6||East Rutherford|NJ|
7||Toronto|ON|
8||Carson|CA|
9||Commerce City|CO|
10||Frisco|TX|
```
同じテーブル定義を使用すると、次の COPY ステートメントは失敗します。これは、VENUENAME に対して DEFAULT 値が指定されておらず、VENUENAME が NOT NULL 列であるためです。
```
copy venue(venueid, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|';
```
次に、IDENTITY 列を使用する VENUE テーブルのバリエーションを考えてみます。
```
create table venue_identity(
venueid int identity(1,1),
venuename varchar(100) not null,
venuecity varchar(30),
venuestate char(2),
venueseats integer not null default '1000');
```
前の例と同じように、VENUESEATS 列にはソースファイルに対応する値がないと想定します。次の COPY ステートメントは、IDENTITY データ値を自動生成する代わりに事前定義済みの IDENTITY データ値を含め、テーブルを正しくロードします。
```
copy venue(venueid, venuename, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|' explicit_ids;
```
次のステートメントは失敗します。これは、IDENTITY 列が含まれていない (列リストから VENUEID が抜けています) が、EXPLICIT\$1IDS パラメータが含まれているためです。
```
copy venue(venuename, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|' explicit_ids;
```
次のステートメントは失敗します。これは EXPLICIT\$1IDS パラメータが含まれていないためです。
```
copy venue(venueid, venuename, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|';
```
## ESCAPE データを使用したデータのコピー
次の例は、区切り文字 (この場合、パイプ文字) に一致する文字をロードする方法を示しています。入力ファイルで、ロードするすべてのパイプ文字 (\$1) がバックスラッシュ文字 (\$1) でエスケープされていることを確認します。次に、ESCAPE パラメータを使用してファイルをロードします。
```
$ more redshiftinfo.txt
1|public\|event\|dwuser
2|public\|sales\|dwuser
create table redshiftinfo(infoid int,tableinfo varchar(50));
copy redshiftinfo from 's3://amzn-s3-demo-bucket/data/redshiftinfo.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|' escape;
select * from redshiftinfo order by 1;
infoid | tableinfo
-------+--------------------
1 | public|event|dwuser
2 | public|sales|dwuser
(2 rows)
```
ESCAPE パラメータを使用しないと、`Extra column(s) found`エラーが発生して、この COPY コマンドは失敗します。
**重要**
ESCAPE パラメータを指定した COPY を使用してデータをロードした場合、対応する出力ファイルを生成するには、UNLOAD コマンドにも ESCAPE パラメータを指定する必要があります。同様に、ESCAPE パラメータを使って UNLOAD を実行すると、同じデータを COPY する場合に ESCAPE を使用する必要があります。
## JSON からのコピーの例
以下の例で、次のデータを含む CATEGORY テーブルをロードします。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_COPY_command_examples.html)
**Topics**
+ ['auto' オプションを使用した JSON データからのロード](#copy-from-json-examples-using-auto)
+ ['auto ignorecase' オプションを使用した JSON データからのロード](#copy-from-json-examples-using-auto-ignorecase)
+ [JSONPaths ファイルを使用した JSON データからのロード](#copy-from-json-examples-using-jsonpaths)
+ [JSONPaths ファイルを使用した JSON 配列からのロード](#copy-from-json-examples-using-jsonpaths-arrays)
### 'auto' オプションを使用した JSON データからのロード
`'auto'` オプションを使用して JSON データからロードするには、JSON データが一連のオブジェクトで構成されている必要があります。キー名が列名と一致している必要がありますが、順序は関係ありません。`category_object_auto.json` という名前のファイルの内容を次に示します。
```
{
"catdesc": "Major League Baseball",
"catid": 1,
"catgroup": "Sports",
"catname": "MLB"
}
{
"catgroup": "Sports",
"catid": 2,
"catname": "NHL",
"catdesc": "National Hockey League"
}
{
"catid": 3,
"catname": "NFL",
"catgroup": "Sports",
"catdesc": "National Football League"
}
{
"bogus": "Bogus Sports LLC",
"catid": 4,
"catgroup": "Sports",
"catname": "NBA",
"catdesc": "National Basketball Association"
}
{
"catid": 5,
"catgroup": "Shows",
"catname": "Musicals",
"catdesc": "All symphony, concerto, and choir concerts"
}
```
前の例の JSON データファイルからロードするには、次の COPY コマンドを実行します。
```
copy category
from 's3://amzn-s3-demo-bucket/category_object_auto.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
json 'auto';
```
### 'auto ignorecase' オプションを使用した JSON データからのロード
`'auto ignorecase'` オプションを使用して JSON データからロードするには、JSON データが一連のオブジェクトで構成されている必要があります。キー名の大文字と小文字は列名と一致する必要がなく、順序は関係ありません。`category_object_auto-ignorecase.json` という名前のファイルの内容を次に示します。
```
{
"CatDesc": "Major League Baseball",
"CatID": 1,
"CatGroup": "Sports",
"CatName": "MLB"
}
{
"CatGroup": "Sports",
"CatID": 2,
"CatName": "NHL",
"CatDesc": "National Hockey League"
}
{
"CatID": 3,
"CatName": "NFL",
"CatGroup": "Sports",
"CatDesc": "National Football League"
}
{
"bogus": "Bogus Sports LLC",
"CatID": 4,
"CatGroup": "Sports",
"CatName": "NBA",
"CatDesc": "National Basketball Association"
}
{
"CatID": 5,
"CatGroup": "Shows",
"CatName": "Musicals",
"CatDesc": "All symphony, concerto, and choir concerts"
}
```
前の例の JSON データファイルからロードするには、次の COPY コマンドを実行します。
```
copy category
from 's3://amzn-s3-demo-bucket/category_object_auto ignorecase.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
json 'auto ignorecase';
```
### JSONPaths ファイルを使用した JSON データからのロード
JSON データオブジェクトが列名に直接対応していない場合、JSONPaths ファイルを使用して、JSON 要素を列にマッピングすることができます。JSON ソースデータの順序は重要ではありませんが、JSONPaths ファイルの式の順序は列の順序と一致している必要があります。`category_object_paths.json` という名前の次のようなデータファイルがあるとします。
```
{
"one": 1,
"two": "Sports",
"three": "MLB",
"four": "Major League Baseball"
}
{
"three": "NHL",
"four": "National Hockey League",
"one": 2,
"two": "Sports"
}
{
"two": "Sports",
"three": "NFL",
"one": 3,
"four": "National Football League"
}
{
"one": 4,
"two": "Sports",
"three": "NBA",
"four": "National Basketball Association"
}
{
"one": 6,
"two": "Shows",
"three": "Musicals",
"four": "All symphony, concerto, and choir concerts"
}
```
`category_jsonpath.json` という名前の次の JSONPaths ファイルで、ソースデータをテーブルの列にマッピングします。
```
{
"jsonpaths": [
"$['one']",
"$['two']",
"$['three']",
"$['four']"
]
}
```
前の例の JSON データファイルからロードするには、次の COPY コマンドを実行します。
```
copy category
from 's3://amzn-s3-demo-bucket/category_object_paths.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
json 's3://amzn-s3-demo-bucket/category_jsonpath.json';
```
### JSONPaths ファイルを使用した JSON 配列からのロード
一連の配列で構成される JSON データからロードするには、JSONPaths ファイルを使用して、配列の要素を列にマッピングする必要があります。`category_array_data.json` という名前の次のようなデータファイルがあるとします。
```
[1,"Sports","MLB","Major League Baseball"]
[2,"Sports","NHL","National Hockey League"]
[3,"Sports","NFL","National Football League"]
[4,"Sports","NBA","National Basketball Association"]
[5,"Concerts","Classical","All symphony, concerto, and choir concerts"]
```
`category_array_jsonpath.json` という名前の次の JSONPaths ファイルで、ソースデータをテーブルの列にマッピングします。
```
{
"jsonpaths": [
"$[0]",
"$[1]",
"$[2]",
"$[3]"
]
}
```
前の例の JSON データファイルからロードするには、次の COPY コマンドを実行します。
```
copy category
from 's3://amzn-s3-demo-bucket/category_array_data.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
json 's3://amzn-s3-demo-bucket/category_array_jsonpath.json';
```
## Avro の例からのコピー
以下の例で、次のデータを含む CATEGORY テーブルをロードします。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_COPY_command_examples.html)
**Topics**
+ ['auto' オプションを使用した Avro データからのロード](#copy-from-avro-examples-using-auto)
+ ['auto ignorecase' オプションを使用した Avro データからのロード](#copy-from-avro-examples-using-auto-ignorecase)
+ [JSONPaths ファイルを使用した Avro データからのロード](#copy-from-avro-examples-using-avropaths)
### 'auto' オプションを使用した Avro データからのロード
`'auto'` 引数を使用して Avro データからロードするには、Avro スキーマのフィールド名が列名と一致している必要があります。ただし、`'auto'` 引数を使用する場合は、順序は関係ありません。次で `category_auto.avro` という名前のファイルのスキーマを示します。
```
{
"name": "category",
"type": "record",
"fields": [
{"name": "catid", "type": "int"},
{"name": "catdesc", "type": "string"},
{"name": "catname", "type": "string"},
{"name": "catgroup", "type": "string"},
}
```
Avro ファイルのデータはバイナリ形式であるため、人には読み取り不可能です。次に、`category_auto.avro`ファイルのデータの JSON 形式を示します。
```
{
"catid": 1,
"catdesc": "Major League Baseball",
"catname": "MLB",
"catgroup": "Sports"
}
{
"catid": 2,
"catdesc": "National Hockey League",
"catname": "NHL",
"catgroup": "Sports"
}
{
"catid": 3,
"catdesc": "National Basketball Association",
"catname": "NBA",
"catgroup": "Sports"
}
{
"catid": 4,
"catdesc": "All symphony, concerto, and choir concerts",
"catname": "Classical",
"catgroup": "Concerts"
}
```
前の例の Avro データファイルからロードするには、次の COPY コマンドを実行します。
```
copy category
from 's3://amzn-s3-demo-bucket/category_auto.avro'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as avro 'auto';
```
### 'auto ignorecase' オプションを使用した Avro データからのロード
`'auto ignorecase'` 引数を使用して Avro データからロードするために、Avro スキーマのフィールド名の大文字と小文字が列名の大文字と小文字を一致させる必要はありません。ただし、`'auto ignorecase'` 引数を使用する場合は、順序は関係ありません。次で `category_auto-ignorecase.avro` という名前のファイルのスキーマを示します。
```
{
"name": "category",
"type": "record",
"fields": [
{"name": "CatID", "type": "int"},
{"name": "CatDesc", "type": "string"},
{"name": "CatName", "type": "string"},
{"name": "CatGroup", "type": "string"},
}
```
Avro ファイルのデータはバイナリ形式であるため、人には読み取り不可能です。次に、`category_auto-ignorecase.avro`ファイルのデータの JSON 形式を示します。
```
{
"CatID": 1,
"CatDesc": "Major League Baseball",
"CatName": "MLB",
"CatGroup": "Sports"
}
{
"CatID": 2,
"CatDesc": "National Hockey League",
"CatName": "NHL",
"CatGroup": "Sports"
}
{
"CatID": 3,
"CatDesc": "National Basketball Association",
"CatName": "NBA",
"CatGroup": "Sports"
}
{
"CatID": 4,
"CatDesc": "All symphony, concerto, and choir concerts",
"CatName": "Classical",
"CatGroup": "Concerts"
}
```
前の例の Avro データファイルからロードするには、次の COPY コマンドを実行します。
```
copy category
from 's3://amzn-s3-demo-bucket/category_auto-ignorecase.avro'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as avro 'auto ignorecase';
```
### JSONPaths ファイルを使用した Avro データからのロード
Avro スキーマのフィールド名が列名に直接対応しない場合、JSONPaths ファイルを使用してスキーマの要素を列にマッピングできます。JSONPaths のファイル式の順序は、列の順序に一致している必要があります。
前の例と同じデータだが次のスキーマを持った `category_paths.avro` という名前のデータファイルがあるとします。
```
{
"name": "category",
"type": "record",
"fields": [
{"name": "id", "type": "int"},
{"name": "desc", "type": "string"},
{"name": "name", "type": "string"},
{"name": "group", "type": "string"},
{"name": "region", "type": "string"}
]
}
```
`category_path.avropath` という名前の次の JSONPaths ファイルで、ソースデータをテーブルの列にマッピングします。
```
{
"jsonpaths": [
"$['id']",
"$['group']",
"$['name']",
"$['desc']"
]
}
```
前の例の Avro データファイルからロードするには、次の COPY コマンドを実行します。
```
copy category
from 's3://amzn-s3-demo-bucket/category_object_paths.avro'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format avro 's3://amzn-s3-demo-bucket/category_path.avropath ';
```
## ESCAPE オプションを指定する COPY 用のファイルの準備
次の例では、ESCAPE パラメータを指定した COPY コマンドでデータを Amazon Redshift テーブルにインポートする前に、データを準備して改行文字を "エスケープする" 方法について説明します。データを準備して改行文字を区切らないと、Amazon Redshift は COPY コマンドの実行時にロードエラーを返します。通常、改行文字はレコード区切り文字として使用されるためです。
例えば、ファイルまたは外部テーブルの列を Amazon Redshift テーブルにコピーするとします。そのファイルまたは列に XML 形式のコンテンツまたは同様なデータが含まれている場合、コンテンツの一部である改行文字 (\$1n) はすべてバックスラッシュ文字 (\$1) でエスケープする必要があります。
埋め込み改行文字を含むファイルまたはテーブルは、比較的簡単に一致パターンを提供します。テキストファイル `>` の次の例に示すように、ほとんどの場合、それぞれの埋め込み改行文字は `' '` 文字の後に続きます。場合によっては、その間に空白文字 (`nlTest1.txt` またはタブ) が入ります。
```
$ cat nlTest1.txt
|1000
|2000
```
次の例では、テキスト処理ユーティリティを実行してソースファイルを事前処理し、必要な場所にエスケープ文字を挿入できます (`|` 文字は、Amazon Redshift テーブルにコピーされるときに列データを区切る区切り記号として使用されます。)
```
$ sed -e ':a;N;$!ba;s/>[[:space:]]*\n/>\\\n/g' nlTest1.txt > nlTest2.txt
```
同様に、Perl を使用しても同じような処理を行うことができます。
```
cat nlTest1.txt | perl -p -e 's/>\s*\n/>\\\n/g' > nlTest2.txt
```
`nlTest2.txt` ファイルから Amazon Redshift へのデータロードに対応するため、Amazon Redshift に 2 列のテーブルを作成しました。最初の列 c1 は文字の列です。この列は `nlTest2.txt` ファイルからの XML 形式のコンテンツを保持します。2 番目の列 c2 は同じファイルからロードされる整数値を保持します。
`sed` コマンドを実行した後、ESCAPE パラメータを使用して `nlTest2.txt` ファイルから Amazon Redshift テーブルにデータを正しくロードすることができます。
**注記**
COPY コマンドに ESCAPE パラメータを指定すると、バックスラッシュ文字を含むいくつかの特殊文字をエスケープします (改行文字を含む)。
```
copy t2 from 's3://amzn-s3-demo-bucket/data/nlTest2.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
escape
delimiter as '|';
select * from t2 order by 2;
c1 | c2
-------------+------
| 1000
| 2000
(2 rows)
```
外部データベースからエクスポートされるデータファイルも同様に準備できます。例えば、Oracle データベースの場合、Amazon Redshift にコピーするテーブルの各対象列に対して REPLACE 関数を使用できます。
```
SELECT c1, REPLACE(c2, \n',\\n' ) as c2 from my_table_with_xml
```
また、通常大量のデータを処理する多くのデータベースエクスポートツールや抽出、変換、ロード (ETL) ツールは、エスケープ文字と区切り文字を指定するオプションを備えています。
## シェープファイルを Amazon Redshift にロードする
次の例は、COPY を使用して Esri シェープファイルをロードする方法を示しています。シェープファイルのロードについての詳細は、「[シェープファイルを Amazon Redshift にロードする](spatial-copy-shapefile.md)」を参照してください。
### シェープファイルのロード
以下のステップは、COPY コマンドを使用して Amazon S3 から OpenStreetMap データを取り込む方法を示しています。この例では、ノルウェーの[Geofabrik のダウンロードサイト](https://download.geofabrik.de/europe.html)から得たシェープファイルアーカイブが、AWSリージョンのプライベート Amazon S3 バケットにアップロードされていることを前提としています。`.shp`、`.shx`、および `.dbf` ファイルは、同じ Amazon S3 プレフィックスとファイル名を共有する必要があります。
#### 簡素化されていないデータの取り込み
次のコマンドは、簡略化せずに最大ジオメトリのサイズに収まるテーブルを作成し、データを取り込みます。好みの GIS ソフトウェアで `gis_osm_natural_free_1.shp` を開き、このレイヤーの列を調べます。デフォルトでは、IDENTITY 列または GEOMETRY 列のいずれかが最初になります。GEOMETRY 列が最初である場合、次のようにテーブルを作成できます。
```
CREATE TABLE norway_natural (
wkb_geometry GEOMETRY,
osm_id BIGINT,
code INT,
fclass VARCHAR,
name VARCHAR);
```
または、IDENTITY 列が最初であるとき、次のようにテーブルを作成できます。
```
CREATE TABLE norway_natural_with_id (
fid INT IDENTITY(1,1),
wkb_geometry GEOMETRY,
osm_id BIGINT,
code INT,
fclass VARCHAR,
name VARCHAR);
```
これで、COPY を使用してデータを取り込むことができます。
```
COPY norway_natural FROM 's3://bucket_name/shapefiles/norway/gis_osm_natural_free_1.shp'
FORMAT SHAPEFILE
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_natural' completed, 83891 record(s) loaded successfully
```
または、次に示すように、データを取り込むことができます。
```
COPY norway_natural_with_id FROM 's3://bucket_name/shapefiles/norway/gis_osm_natural_free_1.shp'
FORMAT SHAPEFILE
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_natural_with_id' completed, 83891 record(s) loaded successfully.
```
#### 簡素化されたデータの取り込み
次のコマンドは、テーブルを作成し、最大ジオメトリのサイズに収まらないデータを簡略化せずに取り込もうとします。`gis_osm_water_a_free_1.shp` シェープファイルを調べて、次のように適切なテーブルを作成します。
```
CREATE TABLE norway_water (
wkb_geometry GEOMETRY,
osm_id BIGINT,
code INT,
fclass VARCHAR,
name VARCHAR);
```
COPY コマンドを実行すると、エラーが発生します。
```
COPY norway_water FROM 's3://bucket_name/shapefiles/norway/gis_osm_water_a_free_1.shp'
FORMAT SHAPEFILE
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
ERROR: Load into table 'norway_water' failed. Check 'stl_load_errors' system table for details.
```
`STL_LOAD_ERRORS` をクエリすると、ジオメトリが大きすぎることがわかります。
```
SELECT line_number, btrim(colname), btrim(err_reason) FROM stl_load_errors WHERE query = pg_last_copy_id();
line_number | btrim | btrim
-------------+--------------+-----------------------------------------------------------------------
1184705 | wkb_geometry | Geometry size: 1513736 is larger than maximum supported size: 1048447
```
これを克服するために、`SIMPLIFY AUTO` パラメータが COPY コマンドに追加され、形状が簡略化されています。
```
COPY norway_water FROM 's3://bucket_name/shapefiles/norway/gis_osm_water_a_free_1.shp'
FORMAT SHAPEFILE
SIMPLIFY AUTO
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_water' completed, 1989196 record(s) loaded successfully.
```
簡略化された行とジオメトリを表示するには、`SVL_SPATIAL_SIMPLIFY` をクエリします。
```
SELECT * FROM svl_spatial_simplify WHERE query = pg_last_copy_id();
query | line_number | maximum_tolerance | initial_size | simplified | final_size | final_tolerance
-------+-------------+-------------------+--------------+------------+------------+----------------------
20 | 1184704 | -1 | 1513736 | t | 1008808 | 1.276386653895e-05
20 | 1664115 | -1 | 1233456 | t | 1023584 | 6.11707814796635e-06
```
自動的に計算された許容値よりも低い許容値で SIMPLIFY AUTO *max\$1tolerance* を使用すると、おそらく取り込みエラーが発生します。この場合、MAXERROR を使用してエラーを無視します。
```
COPY norway_water FROM 's3://bucket_name/shapefiles/norway/gis_osm_water_a_free_1.shp'
FORMAT SHAPEFILE
SIMPLIFY AUTO 1.1E-05
MAXERROR 2
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_water' completed, 1989195 record(s) loaded successfully.
INFO: Load into table 'norway_water' completed, 1 record(s) could not be loaded. Check 'stl_load_errors' system table for details.
```
`SVL_SPATIAL_SIMPLIFY` を再度クエリして、COPY がロードできなかったレコードを特定します。
```
SELECT * FROM svl_spatial_simplify WHERE query = pg_last_copy_id();
query | line_number | maximum_tolerance | initial_size | simplified | final_size | final_tolerance
-------+-------------+-------------------+--------------+------------+------------+-----------------
29 | 1184704 | 1.1e-05 | 1513736 | f | 0 | 0
29 | 1664115 | 1.1e-05 | 1233456 | t | 794432 | 1.1e-05
```
この例では、最初のレコードがうまく収まらなかったため、`simplified` 列に false が表示されています。2 番目のレコードは、指定された許容値内でロードされました。ただし、最終的なサイズは、最大許容値を指定せずに自動的に計算された許容値を使用するよりも大きくなります。
### 圧縮シェープファイルからのロード
Amazon Redshift COPY は、圧縮されたシェープファイルからのデータの取り込みをサポートしています。すべてのシェープファイルコンポーネントには、同じ Amazon S3 プレフィックスと同じ圧縮サフィックスが必要です。例として、前の例からデータをロードするとします。この場合、ファイル `gis_osm_water_a_free_1.shp.gz`、`gis_osm_water_a_free_1.dbf.gz`、および `gis_osm_water_a_free_1.shx.gz` は同じ Amazon S3 ディレクトリを共有する必要があります。COPY コマンドには GZIP オプションが必要です。FROM 句では、次に示すように、正しい圧縮ファイルを指定する必要があります。
```
COPY norway_natural FROM 's3://bucket_name/shapefiles/norway/compressed/gis_osm_natural_free_1.shp.gz'
FORMAT SHAPEFILE
GZIP
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_natural' completed, 83891 record(s) loaded successfully.
```
### 列の順序が異なるテーブルへのデータのロード
最初の列が `GEOMETRY` でないテーブルがある場合は、列マッピングを使用して列をターゲットテーブルにマッピングできます。例えば、最初の列として `osm_id` を指定してテーブルを作成します。
```
CREATE TABLE norway_natural_order (
osm_id BIGINT,
wkb_geometry GEOMETRY,
code INT,
fclass VARCHAR,
name VARCHAR);
```
次に、列マッピングを使用してシェープファイルを取り込みます。
```
COPY norway_natural_order(wkb_geometry, osm_id, code, fclass, name)
FROM 's3://bucket_name/shapefiles/norway/gis_osm_natural_free_1.shp'
FORMAT SHAPEFILE
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_natural_order' completed, 83891 record(s) loaded successfully.
```
### Geogry 列を含めたデータのテーブルへのロード
`GEOGRAPHY` 列を含むテーブルがある場合は、まず、この列を `GEOMETRY` 列に取り込んだ上で、オブジェクトを `GEOGRAPHY` オブジェクトにキャストします。例えば、シェープファイルを `GEOMETRY` 列にコピーした後で、テーブルを変更して `GEOGRAPHY` データ型の列を追加します。
```
ALTER TABLE norway_natural ADD COLUMN wkb_geography GEOGRAPHY;
```
次に、ジオメトリをジオグラフィに変換します。
```
UPDATE norway_natural SET wkb_geography = wkb_geometry::geography;
```
オプションで、`GEOMETRY`列を削除できます。
```
ALTER TABLE norway_natural DROP COLUMN wkb_geometry;
```
## NOLOAD オプションを使用する COPY コマンド
実際にデータをロードする前にデータファイルを検証するには、COPY コマンドで NOLOAD オプションを使用します。Amazon Redshift は入力ファイルを解析し、発生したエラーをすべて表示します。次の例では NOLOAD オプションを使用しており、実際にテーブルに読み込まれた行はありません。
```
COPY public.zipcode1
FROM 's3://amzn-s3-demo-bucket/mydata/zipcode.csv'
DELIMITER ';'
IGNOREHEADER 1 REGION 'us-east-1'
NOLOAD
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/myRedshiftRole';
Warnings:
Load into table 'zipcode1' completed, 0 record(s) loaded successfully.
```
## マルチバイト区切り文字と ENCODING オプションを含む COPY コマンド
次の例では、マルチバイトデータを含む Amazon S3 ファイルから LATIN1 をロードします。COPY コマンドは、ISO-8859-1 としてエンコードされた入力ファイルのフィールドを区切る区切り文字として 8 進形式 (`\302\246\303\254`) を指定します。UTF-8 で同じ区切り文字を指定するには、`DELIMITER '¦ì'` を指定します。
```
COPY latin1
FROM 's3://amzn-s3-demo-bucket/multibyte/myfile'
IAM_ROLE 'arn:aws:iam::123456789012:role/myRedshiftRole'
DELIMITER '\302\246\303\254'
ENCODING ISO88591
```
# CREATE DATABASE
新しいデータベースを作成します。
データベースを作成するには、スーパーユーザーであるか、CREATEDB 権限を持っている必要があります。ゼロ ETL 統合に関連付けられたデータベースを作成するには、スーパーユーザーであるか、CREATEDB 権限と CREATEUSER 権限の両方を持っている必要があります。
トランザクションブロック (BEGIN ... END) 内で CREATE DATABASE を実行することはできません。トランザクションの詳細については、「[Amazon Redshift の分離レベル](c_serial_isolation.md)」を参照してください。
## 構文
```
CREATE DATABASE database_name
[ { [
FROM INTEGRATION ''[ DATABASE '' ]
[ SET ]
[ ACCEPTINVCHARS [=] { TRUE | FALSE }]
[ QUERY_ALL_STATES [=] { TRUE | FALSE }]
[ REFRESH_INTERVAL ]
[ TRUNCATECOLUMNS [=] { TRUE | FALSE } ]
[ HISTORY_MODE [=] {TRUE | FALSE} ]
]
[ WITH ]
[ OWNER [=] db_owner ]
[ CONNECTION LIMIT { limit | UNLIMITED } ]
[ COLLATE { CASE_SENSITIVE | CS | CASE_INSENSITIVE | CI } ]
[ ISOLATION LEVEL { SNAPSHOT | SERIALIZABLE } ]
}
| { FROM { { ARN '' } { WITH DATA CATALOG SCHEMA '' | WITH NO DATA CATALOG SCHEMA } } }
| { IAM_ROLE {default | 'SESSION' | 'arn:aws:iam:::role/' } }
| { [ WITH PERMISSIONS ] FROM DATASHARE datashare_name OF [ ACCOUNT account_id ] NAMESPACE namespace_guid }
]
```
## パラメータ
*database\$1name*
新しいデータベースの名前。有効な名前の詳細については、「[名前と識別子](r_names.md)」を参照してください。
FROM INTEGRATION '' [ DATABASE '' ]
ゼロ ETL 統合識別子を使用してデータベースを作成するかどうかを指定します。SVV\$1INTEGRATION システムビューから `integration_id` を取得できます。Aurora PostgreSQL のゼロ ETL 統合では、SVV\$1INTEGRATION から取得できる `source_database` 名前を指定する必要があります。
例については、[ゼロ ETL 統合の結果を受け取るデータベースを作成する](#r_CREATE_DATABASE-integration)を参照してください。ゼロ ETL 統合を使用したデータベースの作成の詳細については、「Amazon Redshift 管理ガイド」の「[Amazon Redshift でのデスティネーションデータベースの作成](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html)」を参照してください。**
SET
オプションキーワード
ACCEPTINVCHARS [=] \$1 TRUE \$1 FALSE \$1
ACCEPTINVCHARS 句を使用すると、VARCHAR データ型で無効な文字が検出された場合、ゼロ ETL 統合テーブルが取り込みを継続するかどうかを設定できます。無効な文字が検出されると、無効な文字はデフォルトの `?` 文字に置き換えられます。
QUERY\$1ALL\$1STATES [=] \$1 TRUE \$1 FALSE \$1
QUERY\$1ALL\$1STATES 句を使用すると、ゼロ ETL 統合テーブルをすべての状態 (`Synced`、`Failed`、`ResyncRequired`、`ResyncInitiated`) でクエリできるかどうかを設定できます。ゼロ ETL 統合テーブルはデフォルトでは、`Synced` 状態でのみクエリできます。
REFRESH\$1INTERVAL
REFRESH\$1INTERVAL 句を使用すると、ゼロ ETL ソースからターゲットデータベースにデータを更新するためのおよその時間間隔を秒単位で設定できます。この値は、ソースタイプが Aurora MySQL、Aurora PostgreSQL、または RDS for MySQL のゼロ ETL 統合では、0～432,000 秒 (5 日) に設定できます。Amazon DynamoDB ゼロ ETL 統合の場合、値は 900～432,000 秒 (15 分～5 日) に設定できます。ソースタイプが Aurora MySQL、Aurora PostgreSQL、または RDS for MySQL のゼロ ETL 統合では、デフォルトの `interval` はゼロ (0) 秒です。Amazon DynamoDB ゼロ ETL 統合の場合、デフォルトの `interval` は 900 秒 (15 分) です。
TRUNCATECOLUMNS [=] \$1 TRUE \$1 FALSE \$1
TRUNCATECOLUMNS 句を使用すると、VARCHAR 列の値または SUPER 列の属性が制限を超えた場合に、ゼロ ETL 統合テーブルが取り込みを続行するかどうかを設定できます。`TRUE` の場合、値は列に収まるように切り捨てられ、オーバーフローする JSON 属性の値は SUPER 列に収まるように切り捨てられます。
HISTORY\$1MODE [=] \$1TRUE \$1 FALSE\$1
Amazon Redshift が、が指定されたデータベース内のすべての新しいテーブルに履歴モードを設定するかどうかを指定する句。このオプションは、ゼロ ETL 統合用に作成されたデータベースにのみ適用されます。
HISTORY\$1MODE 句は `TRUE` または `FALSE` に設定できます。デフォルトは `FALSE` です。HISTORY\$1MODE の詳細については、「*Amazon Redshift 管理ガイド*」の「[History mode](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-history-mode.html)」(履歴モード) を参照してください。
WiTH
オプションキーワード
OWNER [=] db\$1owner
データベース所有者のユーザー名を指定します。
CONNECTION LIMIT \$1 *limit* \$1 UNLIMITED \$1
ユーザーが同時に開けるデータベース接続の最大数。この制限はスーパーユーザーには適用されません。同時接続の最大数を許可するには、UNLIMITED キーワードを使用します。ユーザーごとの接続数の制限が適用される場合もあります。詳細については、「[CREATE USER](r_CREATE_USER.md)」を参照してください。デフォルトは UNLIMITED です。現在の接続を確認するには、[STV\$1SESSIONS](r_STV_SESSIONS.md)システムビューに対してクエリを実行します。
ユーザーとデータベースの両方の接続制限が適用される場合は、ユーザーが接続しようとしたときに、両方の制限内に未使用の接続スロットがなければなりません。
COLLATE \$1 CASE\$1SENSITIVE \$1 CS \$1 CASE\$1INSENSITIVE \$1 CI \$1
文字列の検索または比較において、大文字と小文字を区別するか、区別しないかを指定する句。デフォルトでは、大文字と小文字が区別されます。
データ共有からデータベースを作成する場合、COLLATE はサポートされません。
CASE\$1SENSITIVE と CS は互換性があり、同じ結果が得られます。同様に、CASE\$1INSENSITIVE と CI は互換性があり、同じ結果が得られます。
ISOLATION LEVEL \$1 SNAPSHOT \$1 SERIALIZABLE \$1
データベースに対してクエリを実行するときに使用される分離レベルを指定する句。分離レベルの詳細については、「[Amazon Redshift の分離レベル](c_serial_isolation.md)」を参照してください。
+ SNAPSHOT 分離 – 更新および削除の競合に対する保護機能を備えた分離レベルを提供します。これは、プロビジョニングされたクラスターまたはサーバーレス名前空間で作成されたデフォルトのデータベースです。
+ SERIALIZABLE 分離 – 同時実行トランザクションの完全な直列化機能を提供します。
FROM ARN ''
データベースの作成に使用する AWS Glue データベース ARN。
\$1 WITH DATA CATALOG SCHEMA '' \$1 WITH NO DATA CATALOG SCHEMA \$1
このパラメータは、CREATE DATABASE コマンドで FROM ARN パラメータも使用する場合にのみ適用されます。
AWS Glue Data Catalog でオブジェクトにアクセスしやすくするためにスキーマを使用してデータベースを作成するかどうかを指定します。
IAM\$1ROLE \$1 default \$1 'SESSION' \$1 'arn:aws:iam::**:role/**' \$1
このパラメータは、CREATE DATABASE コマンドで FROM ARN パラメータも使用する場合にのみ適用されます。
CREATE DATABASE コマンドの実行時にクラスターに関連付けられた IAM ロールを指定すると、Amazon Redshift はデータベースに対してクエリを実行するときにロールの認証情報を使用します。
`default` キーワードを指定することは、デフォルトとして設定されてクラスターに関連付けられている IAM ロールを使用することを意味します。
フェデレーション ID を使用して Amazon Redshift クラスターに接続し、このコマンドを使用して作成された外部スキーマからテーブルにアクセスする場合は、`'SESSION'` を使用します。フェデレーション ID の使用例については、フェデレーション ID の設定方法を説明している「[フェデレーション ID を使用して、ローカルリソースと Amazon Redshift Spectrum の外部テーブルへの Amazon Redshift アクセスを管理する](https://docs.aws.amazon.com/redshift/latest/mgmt/authorization-fas-spectrum.html)」を参照してください。
クラスターが認証と認可に使用する IAM ロールの Amazon リソースネーム (ARN) を使用します。少なくとも、IAM ロールには、Amazon S3 バケットで LIST オペレーションを実行してアクセスを受ける許可と、バケットに含まれる Amazon S3 オブジェクトで GET オペレーションを実行する許可が必要です。データベース用の AWS Glue Data Catalog を使用してデータベースを作成するときに IAM\$1ROLE を使用する方法の詳細については、「[コンシューマーとして Lake Formation 管理のデータ共有を使用する](https://docs.aws.amazon.com/redshift/latest/dg/lake-formation-getting-started-consumer.html)」を参照してください。
以下に ARN が 1 つの場合の IAM\$1ROLE パラメータ文字列の構文を示します。
```
IAM_ROLE 'arn:aws:iam:::role/'
```
ロールを連鎖することで、クラスターは別のアカウントに属している可能性がある別の IAM ロールを引き受けることができます。最大10 個までのロールを連鎖できます。詳細については、「[Amazon Redshift Spectrum での IAM ロールの連鎖](c-spectrum-iam-policies.md#c-spectrum-chaining-roles)」を参照してください。
この IAM ロールに次のような IAM アクセス許可ポリシーをアタッチします。
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AccessSecret",
"Effect": "Allow",
"Action": [
"secretsmanager:GetResourcePolicy",
"secretsmanager:GetSecretValue",
"secretsmanager:DescribeSecret",
"secretsmanager:ListSecretVersionIds"
],
"Resource": "arn:aws:secretsmanager:us-west-2:123456789012:secret:my-rds-secret-VNenFy"
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": [
"secretsmanager:GetRandomPassword",
"secretsmanager:ListSecrets"
],
"Resource": "*"
}
]
}
```
フェデレーションクエリで使用する IAM ロールを作成するステップについては、「[フェデレーテッドクエリを使用するためのシークレットと IAM ロールの作成](federated-create-secret-iam-role.md)」を参照してください。
連鎖したロールのリストには空白を含めないでください。
以下に連鎖された 3 つのロールの構文を示します。
```
IAM_ROLE 'arn:aws:iam:::role/,arn:aws:iam:::role/,arn:aws:iam:::role/'
```
## データ共有で CREATE DATABASE を使用するための構文
次の構文で、同じ AWS アカウント内のデータ共有からデータベースを作成するために使用される、CREATE DATABASE コマンドについて確認できます。
```
CREATE DATABASE database_name
[ [ WITH PERMISSIONS ] FROM DATASHARE datashare_name OF [ ACCOUNT account_id ] NAMESPACE namespace_guid
```
次の構文で、AWSアカウント間のデータ共有からデータベースを作成するために使用される,CREATE DATABASE コマンドについて確認できます。
```
CREATE DATABASE database_name
[ [ WITH PERMISSIONS ] FROM DATASHARE datashare_name OF ACCOUNT account_id NAMESPACE namespace_guid
```
### データ共有で CREATE DATABASE を使用するためのパラメータ
FROM DATASHARE
データ共有の場所を示すキーワード。
*datashare\$1name*
コンシューマーデータベースが作成されるデータ共有の名前。
WITH PERMISSIONS
データ共有から作成されたデータベースに、個々のデータベースオブジェクトにアクセスするためのオブジェクトレベルの許可が必要であることを指定します。この句を指定しないと、データベースに対する USAGE アクセス許可を付与されたユーザーまたはロールは、データベース内のすべてのデータベースオブジェクトに自動的にアクセスできるようになります。
NAMESPACE *namespace\$1guid*
データ共有が属しているプロデユーサ名前空間を指定する値。
ACCOUNT *account\$1id*
データ共有が属しているプロデユーサアカウントを指定する値。
## データ共有のための CREATE DATABASE の使用上の注意
データベーススーパーユーザーとして、CREATE DATABASE を使用して AWS アカウント内のデータ共有からデータベースを作成する場合は、NAMESPACE オプションを指定します。ACCOUNT オプションは省略可能です。CREATE DATABASE を使用して AWS アカウント間のデータ共有からデータベースを作成する場合は、プロデューサーで ACCOUNT と NAMESPACE の両方を指定します。
コンシューマークラスター上の 1 つのデータ共有に対して、作成できるコンシューマデータベースは 1 つだけです。同じデータ共有を参照する、複数のコンシューマーデータベースを作成することはできません。
## AWS Glue Data Catalog の CREATE DATABASE
AWS Glue データベース ARN を使用してデータベースを作成するには、CREATE DATABASE で ARN を指定します。
```
CREATE DATABASE sampledb FROM ARN WITH NO DATA CATALOG SCHEMA;
```
オプションで、IAM\$1ROLE パラメータに値を指定することもできます。パラメータおよび許容される値の詳細については、「[パラメータ](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATABASE.html#r_CREATE_DATABASE-parameters)」を参照してください。
IAM ロールを使用して ARN からデータベースを作成する方法を示す例は、以下のとおりです。
```
CREATE DATABASE sampledb FROM ARN WITH NO DATA CATALOG SCHEMA IAM_ROLE
```
```
CREATE DATABASE sampledb FROM ARN WITH NO DATA CATALOG SCHEMA IAM_ROLE default;
```
DATA CATALOG SCHEMA を使用してデータベースを作成することもできます。
```
CREATE DATABASE sampledb FROM ARN WITH DATA CATALOG SCHEMA IAM_ROLE default;
```
## ゼロ ETL 統合の結果を受け取るデータベースを作成する
ゼロ ETL 統合 ID を使用してデータベースを作成するには、CREATE DATABASE コマンドで `integration_id` を指定します。
```
CREATE DATABASE destination_db_name FROM INTEGRATION 'integration_id';
```
例えば、まず SVV\$1INTEGRATION から統合 ID を取得します。
```
SELECT integration_id FROM SVV_INTEGRATION;
```
次に、取得した統合 ID のいずれかを使用して、ゼロ ETL 統合を受け取るデータベースを作成します。
```
CREATE DATABASE sampledb FROM INTEGRATION 'a1b2c3d4-5678-90ab-cdef-EXAMPLE11111';
```
ゼロ ETL 統合のソースデータベースが必要な場合は、例えば以下のように指定します。
```
CREATE DATABASE sampledb FROM INTEGRATION 'a1b2c3d4-5678-90ab-cdef-EXAMPLE11111' DATABASE sourcedb;
```
データベースの更新間隔を設定することもできます。例えば、ゼロ ETL 統合のソースからのデータの更新間隔を 7,200 秒にするには以下のように設定します。
```
CREATE DATABASE myacct_mysql FROM INTEGRATION 'a1b2c3d4-5678-90ab-cdef-EXAMPLE11111' SET REFRESH_INTERVAL 7200;
```
SVV\$1INTEGRATION カタログビューに、integration\$1id、target\$1database、source、refresh\$1interval などのゼロ ETL 統合に関する情報がないかクエリします。
```
SELECT * FROM svv_integration;
```
次の例では、履歴モードがオンになっている統合からデータベースを作成しています。
```
CREATE DATABASE sample_integration_db FROM INTEGRATION 'a1b2c3d4-5678-90ab-cdef-EXAMPLE11111' SET HISTORY_MODE = true;
```
## CREATE DATABASE の制限
Amazon Redshift は、データベースに次の制限を適用します。
+ クラスターごとのユーザー定義データベースは最大 60 個です。
+ データベース名は最大 127 バイトです。
+ データベース名を予約語にすることはできません。
## データベースの照合
照合とは、データベースエンジンが SQL の文字型データを比較およびソートする方法を定義するための一連の規則です。大文字と小文字が区別されない照合は、最もよく使用されます。Amazon Redshift では、大文字と小文字を区別しない照合を使用して、他のデータウェアハウスシステムからの移行を容易にしています。大文字と小文字を区別しない照合のネイティブサポートにより、Amazon Redshift は、分散キー、ソートキー、範囲が制限されたスキャンなど、重要な調整法や最適化の方法を引き継ぐことができます。
COLLATE 句により、データベース内のすべての CHAR および VARCHAR 列に対する、デフォルトの照合手段を指定します。CASE\$1INSENSITIVE が指定されている場合、すべての CHAR または VARCHAR 列では、大文字と小文字を区別しない照合が使用されます。照合の詳細については、「[照合順序](c_collation_sequences.md)」を参照してください。
大文字と小文字を区別しない列に挿入または取り込んだデータは、元の大文字と小文字を維持します。ただし、ソートやグループ化など、すべての比較ベースの文字列操作は、大文字と小文字を区別しません。LIKE 述語、および正規表現関数などのパターンマッチング操作でも、大文字と小文字を区別しません。
次の SQL オペレーションでは、適切な照合セマンティクスをサポートします。
+ 比較演算子:=、<>、<、<=、>、>=
+ LIKE 演算子
+ ORDER BY 句
+ GROUP BY 句
+ MIN、MAX、LISTAGG など、文字列比較を使用する集計関数
+ PARTITION BY 句や ORDER BY 句などのウィンドウ関数
+ スカラー関数: greatest() 、least()、STRPOS()、REGEXP\$1COUNT()、REGEXP\$1REPLACE()、REGEXP\$1INSTR()、REGEXP\$1SUBSTR()
+ Distinct 句
+ UNION、INTERSECT、および EXCEPT
+ IN LIST
Amazon Redshift Spectrum および Aurora PostgreSQL のフェデレーティッドクエリを含む外部クエリの場合、VARCHAR または CHAR 列の照合は、現行のデータベースレベルの照合と同じです。
次の例では、Amazon Redshift Spectrum テーブルをクエリしています。
```
SELECT ci_varchar FROM spectrum.test_collation
WHERE ci_varchar = 'AMAZON';
ci_varchar
----------
amazon
Amazon
AMAZON
AmaZon
(4 rows)
```
データベースの照合を使用してテーブルを作成する方法については、「[CREATE TABLE](r_CREATE_TABLE_NEW.md)」を参照してください。
COLLATE 関数の詳細については、「[COLLATE 関数](r_COLLATE.md)」を参照してください。
### データベース照合の制限
Amazon Redshift でデータベース照合を使用する場合、以下の制限事項があります。
+ PG カタログテーブルや Amazon Redshift システムテーブルなど、すべてのシステムテーブルまたはビューでは、大文字と小文字が区別されます。
+ コンシューマデータベースとプロデューサデータベースに異なるデータベースレベルの照合順序がある場合、Amazon Redshift はデータベース間クエリとクラスター間クエリをサポートしません。
+ Amazon Redshift は、リーダーノードのみのクエリで大文字と小文字を区別しない照合をサポートしていません。
以下に、サポートされていない大文字と小文字を区別しないクエリと、Amazon Redshift から送信されるエラーの例を示します。
```
SELECT collate(usename, 'case_insensitive') FROM pg_user;
ERROR: Case insensitive collation is not supported in leader node only query.
```
+ Amazon Redshift は、比較、関数、結合、設定オペレーションなど、大文字と小文字を区別する列と区別しない列間でのやり取りはサポートしていません。
次に、大文字と小文字を区別する列と区別しない列の間で、やり取りした際に発生するエラーの例を示します。
```
CREATE TABLE test
(ci_col varchar(10) COLLATE case_insensitive,
cs_col varchar(10) COLLATE case_sensitive,
cint int,
cbigint bigint);
```
```
SELECT ci_col = cs_col FROM test;
ERROR: Query with different collations is not supported yet.
```
```
SELECT concat(ci_col, cs_col) FROM test;
ERROR: Query with different collations is not supported yet.
```
```
SELECT ci_col FROM test UNION SELECT cs_col FROM test;
ERROR: Query with different collations is not supported yet.
```
```
SELECT * FROM test a, test b WHERE a.ci_col = b.cs_col;
ERROR: Query with different collations is not supported yet.
```
```
Select Coalesce(ci_col, cs_col) from test;
ERROR: Query with different collations is not supported yet.
```
```
Select case when cint > 0 then ci_col else cs_col end from test;
ERROR: Query with different collations is not supported yet.
```
これらのクエリを機能させるには、COLLATE 関数を使用して、ある列に対する照合を、別の列と一致するように変換します。詳細については、「[COLLATE 関数](r_COLLATE.md)」を参照してください。
## 例
**データベースを作成する**
次の例では、TICKIT という名前のデータベースを作成し、その所有権を DWUSER というユーザーに与えます。
```
create database tickit
with owner dwuser;
```
データベースに関する詳細を表示するために、PG\$1DATABASE\$1INFO カタログテーブルに対しクエリを実行しています。
```
select datname, datdba, datconnlimit
from pg_database_info
where datdba > 1;
datname | datdba | datconnlimit
-------------+--------+-------------
admin | 100 | UNLIMITED
reports | 100 | 100
tickit | 100 | 100
```
次の例では、スナップショット分離レベルを使用して **sampledb** という名前のデータベースを作成します。
```
CREATE DATABASE sampledb ISOLATION LEVEL SNAPSHOT;
```
次の例では、データ共有 salesshare からデータベース sales\$1db を作成しています。
```
CREATE DATABASE sales_db FROM DATASHARE salesshare OF NAMESPACE '13b8833d-17c6-4f16-8fe4-1a018f5ed00d';
```
### データベース照合の例
**大文字と小文字を区別しないデータベースの作成**
次の例では、データベース `sampledb` 、およびテーブル `T1` を作成し、そのテーブル `T1` にデータを挿入します。
```
create database sampledb collate case_insensitive;
```
SQL クライアントを使用して、先ほど作成した新しいデータベースに接続します。Amazon Redshift クエリエディタ v2 を使用している場合は、**エディタ**で `sampledb` を選択します。RSQL を使用している場合は、次のようなコマンドを使用します。
```
\connect sampledb;
```
```
CREATE TABLE T1 (
col1 Varchar(20) distkey sortkey
);
```
```
INSERT INTO T1 VALUES ('bob'), ('john'), ('Mary'), ('JOHN'), ('Bob');
```
その後、クエリが `John` を含む結果を検索します。
```
SELECT * FROM T1 WHERE col1 = 'John';
col1
------
john
JOHN
(2 row)
```
**大文字と小文字を区別しない規則での順序付け**
次の例は、テーブル T1 での、大文字と小文字を区別しない順序付けを示しています。大文字と小文字を区別しない列では、*Bob* と *bob* や *John* と *john* は同一に扱われるので、その順序は確定しません。
```
SELECT * FROM T1 ORDER BY 1;
col1
------
bob
Bob
JOHN
john
Mary
(5 rows)
```
同様に次の例では、GROUP BY 句に対する、大文字と小文字を区別しない順序付けを示しています。*Bob* と *Bob* は等し認識されるので、同じグループに属します。どちらが結果に表示されるかは非決定的です。
```
SELECT col1, count(*) FROM T1 GROUP BY 1;
col1 | count
-----+------
Mary | 1
bob | 2
JOHN | 2
(3 rows)
```
**大文字と小文字を区別しない列でウィンドウ関数を使用してクエリを実行する**
次の例では、大文字と小文字を区別しない列に対し、ウィンドウ関数によるクエリを実行します。
```
SELECT col1, rank() over (ORDER BY col1) FROM T1;
col1 | rank
-----+------
bob | 1
Bob | 1
john | 3
JOHN | 3
Mary | 5
(5 rows)
```
**DISTINCT キーワードを使用したクエリ**
次の例に、DISTINCT キーワードを使用しながら、`T1`テーブルに対しクエリを実行します。
```
SELECT DISTINCT col1 FROM T1;
col1
------
bob
Mary
john
(3 rows)
```
**UNION 句を使用したクエリ**
次の例に、テーブル `T1` および `T2` に対し UNIONN 句を使用した場合の結果を示します。
```
CREATE TABLE T2 AS SELECT * FROM T1;
```
```
SELECT col1 FROM T1 UNION SELECT col1 FROM T2;
col1
------
john
bob
Mary
(3 rows)
```
# CREATE DATASHARE
現在のデータベースに新しいデータ共有を作成します。このデータ共有の所有者は CREATE DATASHARE コマンドの発行者です。
Amazon Redshift は、各データ共有を単一の Amazon Redshift データベースに関連付けます。関連付けられたデータベースからデータ共有にのみオブジェクトを追加できます。同じ Amazon Redshift データベースに複数のデータ共有を作成できます。
データ共有の詳細については、[Amazon Redshift でのデータの共有](datashare-overview.md)を参照してください。
データ共有に関する情報を表示するには、[SHOW DATASHARES](r_SHOW_DATASHARES.md) を使用します。
## 必要な権限
以下に、CREATE DATASHARE に必要な権限を示します。
+ スーパーユーザー
+ CREATE DATASHARE の権限を持つユーザー
+ データベースの所有者
## 構文
```
CREATE DATASHARE datashare_name
[[SET] PUBLICACCESSIBLE [=] TRUE | FALSE ];
```
## パラメータ
*datashare\$1name*
データ共有の名前。データ共有名は、クラスター名前空間内で一意である必要があります。
[[SET] PUBLICACCESSIBLE]
公開でアクセス可能なクラスターとデータ共有を共有できるかどうかを指定する句。
`SET PUBLICACCESSIBLE` のデフォルト値は `FALSE` です。
## 使用に関する注意事項
デフォルトでは、データ共有の所有者は共有のみを所有し、共有内のオブジェクトは所有しません。
スーパーユーザーとデータベース所有者のみが CREATE DATASHARE を使用して、ALTER 権限を他のユーザーまたはグループに委任できます。
## 例
次の例では、データ共有 `salesshare` を作成します。
```
CREATE DATASHARE salesshare;
```
次の例では、AWS Data Exchangeが管理するデータ共有 `demoshare` を作成します。
```
CREATE DATASHARE demoshare SET PUBLICACCESSIBLE TRUE, MANAGEDBY ADX;
```
# CREATE EXTERNAL FUNCTION
Amazon Redshift 用の AWS Lambda に基づいてスカラーユーザー定義関数 (UDF) を作成します。Lambda のユーザー定義関数の詳細については、[スカラー Lambda UDF](udf-creating-a-lambda-sql-udf.md)を参照してください。
## 必要な権限
以下に、CREATE EXTERNAL FUNCTION に必要な権限を示します。
+ スーパーユーザー
+ CREATE [もしくは REPLACE ] EXTERNAL FUNCTION の権限を持つユーザー
## 構文
```
CREATE [ OR REPLACE ] EXTERNAL FUNCTION external_fn_name ( [data_type] [, ...] )
RETURNS data_type
{ VOLATILE | STABLE }
LAMBDA 'lambda_fn_name'
IAM_ROLE { default | ‘arn:aws:iam:::role/’
RETRY_TIMEOUT milliseconds
MAX_BATCH_ROWS count
MAX_BATCH_SIZE size [ KB | MB ];
```
## パラメータ
OR REPLACE
その関数の名前、入力引数のデータ型、あるいは*署名*が既存の関数と同じである場合に既存の関数を置き換えることを指定する句。同一のデータタイプセットを定義する新しい関数によってのみ既存の関数を置き換えることができます。関数の置き換えは、スーパーユーザーのみが行うことができます。
すでに存在するの関数と同じ名前と入力引数のデータタイプで、異なる署名の関数を定義する場合は、新しい関数を作成することになります。つまり、関数名はオーバーロードされます。詳細については、「[関数名の多重定義](udf-naming-udfs.md#udf-naming-overloading-function-names)」を参照してください。
*external\$1fn\$1name*
外部関数の名前。スキーマ名を指定すると (myschema.myfunction など)、指定したスキーマを使用して関数が作成されます。指定しない場合、現在のスキーマに関数が作成されます。有効な名前の詳細については、「[名前と識別子](r_names.md)」を参照してください。
すべての UDF 名の前に `f_` を付けることをお勧めします。Amazon Redshift は、UDF 名の `f_` プレフィックスを予約します。`f_` プレフィックスを使用することで、UDF 名が現在または将来の Amazon Redshift の組み込み SQL 関数名と競合しないようにすることができます。詳細については、「[UDF 名の競合の回避](udf-naming-udfs.md)」を参照してください。
*data\$1type*
入力引数のデータタイプ。詳細については、「[スカラー Python UDF](udf-creating-a-scalar-udf.md)」および「[スカラー Lambda UDF](udf-creating-a-lambda-sql-udf.md)」を参照してください。
RETURNS *data\$1type*
関数によって返される値のデータ型。RETURNS データ型には、Amazon Redshift のすべての標準データ型を使用できます。詳細については、「[スカラー Python UDF](udf-creating-a-scalar-udf.md)」および「[スカラー Lambda UDF](udf-creating-a-lambda-sql-udf.md)」を参照してください。
VOLATILE \$1 STABLE
関数の変動率についてのクエリオプティマイザを報告します。
関数の最適な変動率の分類を厳正に設定してラベルを付けることで、最高の最適化が得られます。厳正度の順に、低度の厳正度から変動率を分類すると、以下のようになります。
+ VOLATILE
+ STABLE
VOLATILE
同じ引数が入っている場合、単一のステートメントに含まれる行であっても、関数は連続の呼び出しに異なる結果を返すことがあります。クエリオプティマイザは、変動的な関数の動作について想定することはできません。変動的な関数を使用するクエリは、入力ごとに関数を再評価する必要があります。
STABLE
引数が同じである場合、単一のステートメント内で処理される連続的な呼び出しに対して関数が同じ結果を返すことが保証されます。異なるステートメントから呼び出された場合、関数が異なる結果を返すことがあります。このカテゴリにより、オプティマイザは 1 つのステートメント内で関数が呼び出される回数を減らすことができます。
選択した厳密さが関数に対して有効でない場合、オプティマイザは、この厳密さに基づく一部の呼び出しをスキップするリスクがあることに注意してください。そのため、結果セットが不正確になる場合があります。
IMMUTABLE 句は、現在 Lambda UDF ではサポートされていません。
LAMBDA *'lambda\$1fn\$1name'*
Amazon Redshift が呼び出す関数の名前。
AWS Lambda 関数を作成する手順については、*AWS Lambdaデベロッパーガイド*の「[コンソールで Lambda 関数を作成する](https://docs.aws.amazon.com/lambda/latest/dg/getting-started-create-function.html)」を参照してください。
Lambda 関数に必要なアクセス許可の詳細については、*AWS Lambdaデベロッパーガイド*の「[AWS Lambda アクセス許可](https://docs.aws.amazon.com/lambda/latest/dg/lambda-permissions.html)」を参照してください。
IAM\$1ROLE \$1 default \$1 ‘arn:aws:iam::**:role/**’
デフォルトキーワードを使用して、CREATE EXTERNAL FUNCTION コマンドの実行時にデフォルトとして設定され、クラスターに関連付けられた IAM ロールの使用を、Amazon Redshift に指示します。
クラスターが認証と認可に使用する IAM ロールの Amazon リソースネーム (ARN) を使用します。CREATE EXTERNAL FUNCTION コマンドは、この IAM ロールを介して Lambda 関数を呼び出すことが許可されています。クラスターに Lambda 関数を呼び出す権限を持つ既存の IAM ロールがある場合は、ロールの ARN に置き換えることができます。詳細については、「[Lambda UDF の認可パラメータの設定](udf-creating-a-lambda-sql-udf.md#udf-lambda-authorization)」を参照してください。
以下に、IAM\$1ROLE パラメータの構文を示します。
```
IAM_ROLE 'arn:aws:iam::aws-account-id:role/role-name'
```
RETRY\$1TIMEOUT *milliseconds*
再試行バックオフの遅延に対して Amazon Redshift が使用する合計時間 (ミリ秒)。
失敗したクエリをすぐに再試行する代わりに、Amazon Redshift はバックオフを実行し、再試行の間に一定の時間待機します。その後、Amazon Redshift は、すべての遅延の合計が指定した RETRY\$1TIMEOUT 値以上になるまで、失敗したクエリを再実行するためのリクエストを再試行します。デフォルト値は 20,000 ミリ秒です。
Lambda 関数が呼び出されると、Amazon Redshift は、`TooManyRequestsException`、`EC2ThrottledException`、`ServiceException` などのエラーを受け取ったクエリを再試行します。
RETRY\$1TIMEOUT パラメータを 0 ミリ秒に設定して、Lambda UDF の再試行を防ぐことができます。
MAX\$1BATCH\$1ROWS *count*
Amazon Redshift が 1 回の Lambda 呼び出しに対して 1 回のバッチリクエストで送信する最大行数。
このパラメータの最小値は 1 です。最大値は INT\$1MAX または 2,147,483,647 です。
このパラメータはオプションです。デフォルト値は INT \$1MAX または 2,147,483,647 です。
MAX\$1BATCH\$1SIZE *size* [ KB \$1 MB ]
Amazon Redshift が 1 回の Lambda 呼び出しに対して 1 回のバッチリクエストで送信するデータペイロードの最大サイズ。
このパラメータの最小値は 1 KB です。最大値は 5 MB です。
このパラメータのデフォルト値は 5 MB です。
KB と MB はオプションです。測定単位を設定しない場合、Amazon Redshift はデフォルトで KB を使用します。
## 使用に関する注意事項
Lambda UDF を作成するときは、次の点を考慮してください。
+ 入力引数に対する Lambda 関数呼び出しの順序は、固定も保証もされていません。クラスター設定によっては、クエリを実行するインスタンス間で順序が異なる場合があります。
+ 関数が入力引数ごとに 1 回だけ適用されるという保証はありません。Amazon Redshift と AWS Lambda とのやり取りにより、同じ入力に対して呼び出しが繰り返される可能性があります。
## 例
以下は、スカラー Lambda ユーザー定義関数 (UDF) の使用例を示します。
### Node.js Lambda 関数を使用したスカラー Lambda UDF の例
次の例では、入力引数として 2 つの整数を受け取る `exfunc_sum` という外部関数を作成します。この関数は、合計を整数出力として返します。呼び出される Lambda 関数の名前は `lambda_sum` です。この Lambda 関数に使用される言語は Node.js 12.x です。IAM ロールを必ず指定してください。この例では、IAM ロールとして `'arn:aws:iam::123456789012:user/johndoe'` を使用しています。
```
CREATE EXTERNAL FUNCTION exfunc_sum(INT,INT)
RETURNS INT
VOLATILE
LAMBDA 'lambda_sum'
IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test';
```
Lambda 関数はリクエストペイロードを受け取り、各行を繰り返して処理します。単一の行ですべての値が加算されて、その行の合計が計算され、応答配列に保存されます。結果配列の行数は、リクエストペイロードで受信した行数と似ています。
JSON 応答ペイロードは、外部関数によって認識されるために、['results' (結果)] フィールドに結果データを持っている必要があります。Lambda 関数に送信されるリクエストの引数フィールドには、データペイロードが含まれます。バッチリクエストの場合、データペイロードに複数の行が存在する可能性があります。次の Lambda 関数は、リクエストデータペイロードのすべての行を繰り返し処理します。また、単一の行内のすべての値を個別に繰り返します。
```
exports.handler = async (event) => {
// The 'arguments' field in the request sent to the Lambda function contains the data payload.
var t1 = event['arguments'];
// 'len(t1)' represents the number of rows in the request payload.
// The number of results in the response payload should be the same as the number of rows received.
const resp = new Array(t1.length);
// Iterating over all the rows in the request payload.
for (const [i, x] of t1.entries())
{
var sum = 0;
// Iterating over all the values in a single row.
for (const y of x) {
sum = sum + y;
}
resp[i] = sum;
}
// The 'results' field should contain the results of the lambda call.
const response = {
results: resp
};
return JSON.stringify(response);
};
```
次の例では、リテラル値を使用して外部関数を呼び出します。
```
select exfunc_sum(1,2);
exfunc_sum
------------
3
(1 row)
```
次の例では、整数データ型の 2 つの列 c1 と c2 を持つ t\$1sum というテーブルを作成し、2 行のデータを挿入します。次に、このテーブルの列名を渡すことにより、外部の関数が呼び出されます。2 つのテーブル行は、リクエストペイロードのバッチリクエストで単一の Lambda 呼び出しとして送信されます。
```
CREATE TABLE t_sum(c1 int, c2 int);
INSERT INTO t_sum VALUES (4,5), (6,7);
SELECT exfunc_sum(c1,c2) FROM t_sum;
exfunc_sum
---------------
9
13
(2 rows)
```
### RETRY\$1TIMEOUT 属性を使用したスカラー Lambda UDF の例
次のセクションでは、Lambda UDF で RETRY\$1TIMEOUT 属性を使用する方法の例を見つけることができます。
AWS Lambda 関数には、関数ごとに設定する同時実行数についての制限があります。同時実行数の制限に関する詳細については、「*AWS Lambda デベロッパーガイド*」の「[Lambda 関数の同時実行の管理](https://docs.aws.amazon.com/lambda/latest/dg/configuration-concurrency.html)」と、AWS コンピューティングブログの記事「[AWS Lambda 関数の同時実行の管理](https://aws.amazon.com/blogs/compute/managing-aws-lambda-function-concurrency)」を参照してください。
Lambda UDF によって処理されるリクエストの数が同時実行制限を超えると、新しいリクエストは `TooManyRequestsException` エラーを受け取ります。Lambda UDF は、Lambda 関数に送信されるリクエスト間のすべての遅延の合計が、設定した RETRY\$1TIMEOUT 値以上になるまで、このエラーを再試行します。デフォルトの RETRY\$1TIMEOUT 値は 20,000 ミリ秒です。
次の例では、`exfunc_sleep_3` という名前の Lambda 関数を使用します。この関数は、リクエストペイロードを取り込み、各行を繰り返し処理し、入力を大文字に変換します。その後、3 秒間スリープし、結果を返します。この Lambda 関数に使用される言語は Python 3.8 です。
結果配列の行数は、リクエストペイロードで受信した行数と似ています。JSON 応答ペイロードは、外部関数によって認識されるために、`results` フィールドに結果データを持っている必要があります。Lambda 関数に送信されるリクエストの `arguments` フィールドには、データペイロードが含まれています。バッチリクエストの場合、データペイロードに複数の行が表示されることがあります。
この関数の同時実行制限は、RETRY\$1TIMEOUT 属性の使用法を示すために、予約済み同時実行で特に 1 に設定されています。属性が 1 に設定されている場合、Lambda 関数は一度に 1 つのリクエストしか処理できません。
```
import json
import time
def lambda_handler(event, context):
t1 = event['arguments']
# 'len(t1)' represents the number of rows in the request payload.
# The number of results in the response payload should be the same as the number of rows received.
resp = [None]*len(t1)
# Iterating over all rows in the request payload.
for i, x in enumerate(t1):
# Iterating over all the values in a single row.
for j, y in enumerate(x):
resp[i] = y.upper()
time.sleep(3)
ret = dict()
ret['results'] = resp
ret_json = json.dumps(ret)
return ret_json
```
次に、RETRY\$1TIMEOUT 属性の追加例を 2 つ示します。それぞれ単一の Lambda UDF を呼び出します。Lambda UDF を呼び出す間、各例は同じ SQL クエリを実行して、2 つの同時実行データベースセッションから同時に Lambda UDF を呼び出します。Lambda UDF を呼び出す最初のクエリが UDF によって処理されている場合、2 番目のクエリは `TooManyRequestsException` エラーを受け取ります。この結果は、UDF で予約された同時実行を特別に 1 に設定したために発生します。Lambda 関数の予約済み同時実行を設定する方法については、[予約済み同時実行数の設定](https://docs.aws.amazon.com/lambda/latest/dg/configuration-concurrency.html#configuration-concurrency-reservedconfiguration-concurrency-reserved)を参照してください。
次の最初の例では、Lambda UDF の RETRY\$1TIMEOUT 属性を 0 ミリ秒に設定します。Lambda リクエストが Lambda 関数から例外を受け取った場合、Amazon Redshift は再試行を行いません。この結果は、RETRY\$1TIMEOUT 属性が 0 に設定されているために発生します。
```
CREATE OR REPLACE EXTERNAL FUNCTION exfunc_upper(varchar)
RETURNS varchar
VOLATILE
LAMBDA 'exfunc_sleep_3'
IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'
RETRY_TIMEOUT 0;
```
RETRY\$1TIMEOUT を 0 に設定すると、別々のデータベースセッションから次の 2 つのクエリを実行して、異なる結果を確認できます。
Lambda UDF を使用する最初の SQL クエリが正常に実行されます。
```
select exfunc_upper('Varchar');
exfunc_upper
--------------
VARCHAR
(1 row)
```
別のデータベースセッションから同時に実行される 2 番目のクエリは、`TooManyRequestsException` エラーを受け取ります。
```
select exfunc_upper('Varchar');
ERROR: Rate Exceeded.; Exception: TooManyRequestsException; ShouldRetry: 1
DETAIL:
-----------------------------------------------
error: Rate Exceeded.; Exception: TooManyRequestsException; ShouldRetry: 1
code: 32103
context:query: 0
location: exfunc_client.cpp:102
process: padbmaster [pid=26384]
-----------------------------------------------
```
次の 2 番目の例では、Lambda UDF の RETRY\$1TIMEOUT 属性を 3,000 ミリ秒に設定します。2 番目のクエリが同時に実行された場合でも、Lambda UDF は遅延の合計が 3,000 ミリ秒になるまで再試行します。したがって、両方のクエリが正常に実行されます。
```
CREATE OR REPLACE EXTERNAL FUNCTION exfunc_upper(varchar)
RETURNS varchar
VOLATILE
LAMBDA 'exfunc_sleep_3'
IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'
RETRY_TIMEOUT 3000;
```
RETRY\$1TIMEOUT を 3,000 ミリ秒に設定すると、別々のデータベースセッションから次の 2 つのクエリを実行して、同じ結果を確認できます。
Lambda UDF を実行する最初の SQL クエリが正常に実行されます。
```
select exfunc_upper('Varchar');
exfunc_upper
--------------
VARCHAR
(1 row)
```
2 番目のクエリは同時に実行され、Lambda UDF は遅延の合計が 3,000 ミリ秒になるまで再試行します。
```
select exfunc_upper('Varchar');
exfunc_upper
--------------
VARCHAR
(1 row)
```
### Python Lambda 関数を使用したスカラー Lambda UDF の例
次の例では、`exfunc_multiplication` という名前の外部関数を作成します。この関数は、数値を乗算して整数を返します。この例では、Lambda 応答に success フィールドと `error_msg` フィールドが組み込まれています。乗算結果に整数オーバーフローがあり、`error_msg` メッセージが `Integer multiplication overflow` に設定されている場合、成功フィールドは false に設定されます。`exfunc_multiplication` 関数は、入力引数として 3 つの整数を取り、その合計を整数出力として返します。
呼び出される Lambda 関数の名前は `lambda_multiplication` です。この Lambda 関数に使用される言語は Python 3.8 です。IAM ロールを必ず指定してください。
```
CREATE EXTERNAL FUNCTION exfunc_multiplication(int, int, int)
RETURNS INT
VOLATILE
LAMBDA 'lambda_multiplication'
IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test';
```
Lambda 関数はリクエストペイロードを受け取り、各行を繰り返して処理します。1 つの行ですべての値が乗算され、その行の結果が計算されます。この結果は、応答リストに保存されます。この例では、デフォルトで true に設定されているブールの成功値を使用します。行の乗算結果に整数オーバーフローがある場合、成功値は false に設定されます。その後、反復ループが中断されます。
応答ペイロードの作成中に、成功値が false の場合、次の Lambda 関数がペイロードに `error_msg` フィールドを追加します。また、エラーメッセージを `Integer multiplication overflow` に設定します。成功値が true の場合、結果データが結果フィールドに追加されます。結果配列の行数は、存在する場合、リクエストペイロードで受信した行数と似ています。
Lambda 関数に送信されるリクエストの引数フィールドには、データペイロードが含まれます。バッチリクエストの場合、データペイロードに複数の行が存在する可能性があります。次の Lambda 関数は、リクエストデータペイロードのすべての行を繰り返し処理し、1 つの行内のすべての値を個別に繰り返し処理します。
```
import json
def lambda_handler(event, context):
t1 = event['arguments']
# 'len(t1)' represents the number of rows in the request payload.
# The number of results in the response payload should be the same as the number of rows received.
resp = [None]*len(t1)
# By default success is set to 'True'.
success = True
# Iterating over all rows in the request payload.
for i, x in enumerate(t1):
mul = 1
# Iterating over all the values in a single row.
for j, y in enumerate(x):
mul = mul*y
# Check integer overflow.
if (mul >= 9223372036854775807 or mul <= -9223372036854775808):
success = False
break
else:
resp[i] = mul
ret = dict()
ret['success'] = success
if not success:
ret['error_msg'] = "Integer multiplication overflow"
else:
ret['results'] = resp
ret_json = json.dumps(ret)
return ret_json
```
次の例では、リテラル値を使用して外部関数を呼び出します。
```
SELECT exfunc_multiplication(8, 9, 2);
exfunc_multiplication
---------------------------
144
(1 row)
```
次の例では、整数データ型の 3 つの列 c1、c2、および c3 を持つ t\$1multi という名前のテーブルを作成します。外部関数は、このテーブルの列名を渡すことによって呼び出されます。データは、エラーがどのように伝播されるかを示す整数オーバーフローを引き起こすような方法で挿入されます。
```
CREATE TABLE t_multi (c1 int, c2 int, c3 int);
INSERT INTO t_multi VALUES (2147483647, 2147483647, 4);
SELECT exfunc_multiplication(c1, c2, c3) FROM t_multi;
DETAIL:
-----------------------------------------------
error: Integer multiplication overflow
code: 32004context:
context:
query: 38
location: exfunc_data.cpp:276
process: query2_16_38 [pid=30494]
-----------------------------------------------
```
# CREATE EXTERNAL MODEL
**Topics**
+ [CREATE EXTERNAL MODEL の前提条件](#r_create_external_model_prereqs)
+ [必要な権限](#r_simple_create_model-privileges)
+ [コスト管理](#r_create_model_cost)
+ [CREATE EXTERNAL MODEL 構文](#r_create_external_model_syntax)
+ [CREATE EXTERNAL MODEL のパラメータと設定](#r_create_external_model_parameters_settings)
+ [CREATE EXTERNAL MODEL 推論関数パラメータ](#r_create_external_model_if_parameters)
## CREATE EXTERNAL MODEL の前提条件
CREATE EXTERNAL MODEL ステートメントを使用する前に、[Amazon Redshift ML を使用するためのクラスターの設定](getting-started-machine-learning.md#cluster-setup) の前提条件を満たしてください。前提条件の概要は次のとおりです。
+ AWS マネジメントコンソールまたは AWS Command Line Interface (AWS CLI) を使用して、Amazon Redshift クラスターを作成します。
+ クラスターの作成中に AWS Identity and Access Management (IAM) ポリシーをアタッチします。
+ Amazon Redshift と Amazon Bedrock が、他のサービスとやり取りするロールを引き受けることを許可するには、IAM ロールに適切な信頼ポリシーを追加します。
+ Amazon Bedrock コンソールから、使用対象の特定の LLM へのアクセスを有効にします。
+ (オプション) データが少量にもかかわらず Amazon Bedrock によるスロットリング例外 (`Too many requests, please wait before trying again` など) が発生する場合は、Amazon Bedrock アカウントの **[サービスクォータ]** でクォータを確認します。適用されているアカウントレベルのクォータが、使用しているモデルに対する **InvokeModel** リクエストの AWS デフォルトクォータ値と少なくとも同じであることを確認してください。
IAM ロール、信頼ポリシー、およびその他の前提条件の詳細については、「[Amazon Redshift ML を使用するためのクラスターの設定](getting-started-machine-learning.md#cluster-setup)」を参照してください。
## 必要な権限
CREATE EXTERNAL MODEL に必要な権限を以下に示します。
+ スーパーユーザー
+ CREATE MODEL の権限を持つユーザー
+ GRANT CREATE MODEL の権限を持つロール
## コスト管理
Amazon Redshift 機械学習は既存のクラスターリソースを使用して予測モデルを作成するため、追加料金は発生しません。ただし、選択したモデルに基づいて Amazon Bedrock を使用する場合は AWS 料金が発生します。詳細については、「[Amazon Redshift 機械学習を使用するためのコスト](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)」を参照してください。
## CREATE EXTERNAL MODEL 構文
以下は、CREATE EXTERNAL MODEL ステートメントの完全な構文です。
```
CREATE EXTERNAL MODEL model_name
FUNCTION function_name
IAM_ROLE {default/'arn:aws:iam:::role/'}
MODEL_TYPE BEDROCK
SETTINGS (
MODEL_ID model_id
[, PROMPT 'prompt prefix']
[, SUFFIX 'prompt suffix']
[, REQUEST_TYPE {RAW|UNIFIED}]
[, RESPONSE_TYPE {VARCHAR|SUPER}]
);
```
`CREATE EXTERNAL MODEL` コマンドは、コンテンツの生成に使用する推論関数を作成します。
以下は、`RAW` の `REQUEST_TYPE` を使用して `CREATE EXTERNAL MODEL` が作成する推論関数の構文です。
```
SELECT inference_function_name(request_super)
[FROM table];
```
以下は、`UNIFIED` の `REQUEST_TYPE` を使用して `CREATE EXTERNAL MODEL` が作成する推論関数の構文です。
```
SELECT inference_function_name(input_text, [, inference_config [, additional_model_request_fields]])
[FROM table];
```
推論関数の使用方法については、「[Amazon Redshift ML と Amazon Bedrock の統合用の外部モデルの使用](machine-learning-br.md#machine-learning-br-use)」を参照してください。
## CREATE EXTERNAL MODEL のパラメータと設定
このセクションでは、 `CREATE EXTERNAL MODEL` コマンドのパラメータと設定について説明します。
**Topics**
+ [CREATE EXTERNAL MODEL のパラメータ](#r_create_external_model_parameters)
+ [CREATE EXTERNAL MODEL の設定](#r_create_external_model_settings)
### CREATE EXTERNAL MODEL のパラメータ
model\$1name
外部モデルの名前。スキーマ内のモデル名は一意でなければなりません。
FUNCTION *function\$1name (data\$1type [,...] )*
`CREATE EXTERNAL MODEL` が作成する推論関数の名前。推論関数を使用して Amazon Bedrock にリクエストを送信し、ML 生成テキストを取得できます。
IAM\$1ROLE * \$1 default \$1 'arn:aws:iam:::role/' \$1*
Amazon Redshift が Amazon Bedrock へのアクセスに使用する IAM ロール。IAM ロールに関する詳細は、「[Amazon Redshift ML と Amazon Bedrock の統合のための IAM ロールの作成または更新](machine-learning-br.md#machine-learning-br-iam)」を参照してください。
MODEL\$1TYPE BEDROCK
モデルタイプを指定します。唯一の有効な値は `BEDROCK` です。
SETTINGS ( MODEL\$1ID model\$1id [,...] )
外部モデルの設定を指定します。詳細については、以下のセクションを参照してください。
### CREATE EXTERNAL MODEL の設定
MODEL\$1ID model\$1id
外部モデルの識別子 (例: `anthropic.claude-v2`)。Amazon Bedrock モデルの ID については、「[Amazon Bedrock model IDs](https://docs.aws.amazon.com/bedrock/latest/userguide/model-ids.html)」を参照してください。
PROMPT 'prompt prefix'
Amazon Redshift がすべての推論リクエストの先頭に追加する静的プロンプトを指定します。`UNIFIED` の `REQUEST_TYPE` でのみサポートされます。
SUFFIX 'prompt suffix'
Amazon Redshift がすべての推論リクエストの末尾に追加する静的プロンプトを指定します。`UNIFIED` の `REQUEST_TYPE` でのみサポートされます。
REQUEST\$1TYPE \$1 RAW \$1 UNIFIED \$1
Amazon Bedrock に送信されるリクエストの形式を指定します。有効な値には次のようなものがあります。
+ **RAW**: 推論関数は入力を単一の SUPER 値として受け取り、常に SUPER 値を返します。SUPER 値の形式は、選択した Amazon Bedrock モデルに固有です。SUPER は、複数のアルゴリズムを組み合わせて、より優れた単一の予測を生成する予測モデルです。
+ **UNIFIED**: 推論関数は統合 API を使用します。すべてのモデルに Amazon Bedrock との統一された一貫したインターフェイスがあります。これは、メッセージをサポートするすべてのモデルで機能します。この値はデフォルト値です。
詳細については、「Amazon Bedrock API ドキュメント」の「[Converse API documentation](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html)」を参照してください。**
RESPONSE\$1TYPE \$1 VARCHAR \$1 SUPER \$1
レスポンスの形式を指定します。`REQUEST_TYPE` が `RAW` の場合、`RESPONSE_TYPE` は必須であり、有効な値は `SUPER` のみです。他のすべての `REQUEST TYPE` 値では、デフォルト値は `VARCHAR` で、`RESPONSE_TYPE` はオプションです。有効な値には次のようなものがあります。
+ **VARCHAR**: Amazon Redshift は、モデルによって生成されたテキストレスポンスのみを返します。
+ **SUPER**: Amazon Redshift は、モデルによって生成されたレスポンス JSON 全体を SUPER として返します。これには、テキストレスポンス、停止理由、モデル入出力トークンの使用状況などの情報が含まれます。SUPER は、複数のアルゴリズムを組み合わせて、より優れた単一の予測を生成する予測モデルです。
## CREATE EXTERNAL MODEL 推論関数パラメータ
このセクションでは、`CREATE EXTERNAL MODEL` コマンドが作成する推論関数の有効なパラメータについて説明します。
### `RAW` の `REQUEST_TYPE` 用の CREATE EXTERNAL MODEL 推論関数パラメータ
`RAW` の `REQUEST_TYPE` で作成された推論関数には 1 つの SUPER 入力引数があり、常に SUPER データ型を返します。入力 SUPER の構文は、Amazon Bedrock から選択された特定のモデルのリクエストの構文に従います。
### `UNIFIED` の `REQUEST_TYPE` 用の CREATE EXTERNAL MODEL 推論関数パラメータ
input\$1text
Amazon Redshift が Amazon Bedrock に送信するテキスト。
inference\$1config
Amazon Redshift が Amazon Bedrock に送信するオプションのパラメータを含む SUPER 値。これには以下が含まれます。
+ maxTokens
+ stopSequences
+ 温度
+ topP
これらのパラメータはすべてオプションであり、すべて大文字と小文字が区別されます。これらのパラメータの詳細については、「Amazon Bedrock API リファレンス」の「[InferenceConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InferenceConfiguration.html)」を参照してください。**
# CREATE EXTERNAL SCHEMA
現在のデータベースに新しい外部スキーマを作成します。この外部スキーマを使用して、Amazon RDS for PostgreSQL または Amazon Aurora PostgreSQL 互換エディションデータベースに接続できます。また、AWS Glueや Athena などの外部データカタログ内のデータベース、あるいは Amazon EMR などの Apache Hive メタストアにあるデータベースを参照する、外部スキーマを作成することもできます。
このスキーマの所有者は CREATE EXTERNAL SCHEMA コマンドの発行者です。外部スキーマの所有者を移行するには、「[ALTER SCHEMA](r_ALTER_SCHEMA.md)」を使用して所有者を変更します。スキーマに他のユーザーやグループへのアクセス権を付与するには、[GRANT](r_GRANT.md)コマンドを使用します。
外部テーブルのアクセス権限に対して、GRANT または REVOKE コマンドを使用することはできません。代わりに、外部スキーマに対するアクセス権限の付与または取り消しを実行します。
**注記**
現在、Amazon Athena データカタログに Redshift Spectrum の外部テーブルがある場合は、AWS Glue Data Catalogに Athena データカタログを移行することが可能です。Redshift Spectrum で AWS Glue データカタログを使用するには、AWS Identity and Access Management(IAM) ポリシーの変更が必要になる場合があります。詳細については、*Athena ユーザーガイド*の「[AWS Glue データカタログへのアップグレード](https://docs.aws.amazon.com/athena/latest/ug/glue-athena.html#glue-upgrade)」を参照してください。
外部スキーマの詳細を表示するには、[SVV\$1EXTERNAL\$1SCHEMAS](r_SVV_EXTERNAL_SCHEMAS.md)システムビューにクエリを実行します。
## 構文
次の構文は、外部データカタログを使用してデータを参照するために使用する CREATE EXTERNAL SCHEMA コマンドを示しています。詳細については、「[Amazon Redshift Spectrum](c-using-spectrum.md)」を参照してください。
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] local_schema_name
FROM [ [ DATA CATALOG ] | HIVE METASTORE | POSTGRES | MYSQL | KINESIS | MSK | REDSHIFT | KAFKA ]
[ DATABASE 'database_name' ]
[ SCHEMA 'schema_name' ]
[ REGION 'aws-region' ]
[ IAM_ROLE [ default | 'SESSION' | 'arn:aws:iam:::role/' ] ]
[ AUTHENTICATION [ none | iam | mtls] ]
[ AUTHENTICATION_ARN 'acm-certificate-arn' | SECRET_ARN 'ssm-secret- arn' ]
[ URI ['hive_metastore_uri' [ PORT port_number ] | 'hostname' [ PORT port_number ] | 'Kafka bootstrap URL'] ]
[ CLUSTER_ARN 'arn:aws:kafka:::cluster/msk/' ]
[ CATALOG_ROLE [ 'SESSION' | 'catalog-role-arn-string' ] ]
[ CREATE EXTERNAL DATABASE IF NOT EXISTS ]
[ CATALOG_ID 'Amazon Web Services account ID containing Glue or Lake Formation database' ]
```
次の構文は、RDS POSTGRES または Aurora PostgreSQL への横串検索を使用してデータを参照するために使用する CREATE EXTERNAL SCHEMA コマンドを示しています。作成した外部スキーマで、Kinesis Data Streams などのストリーミングソースを参照することもできます。詳細については、「[Amazon Redshift での横串検索を使用したデータのクエリの実行](federated-overview.md)」を参照してください。
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] local_schema_name
FROM POSTGRES
DATABASE 'federated_database_name' [SCHEMA 'schema_name']
URI 'hostname' [ PORT port_number ]
IAM_ROLE [ default | 'arn:aws:iam:::role/' ]
SECRET_ARN 'ssm-secret-arn'
```
次の構文は、RDS MySQL または Aurora MySQL への横串検索を使用してデータを参照するために使用する CREATE EXTERNAL SCHEMA コマンドを示しています。詳細については、「[Amazon Redshift での横串検索を使用したデータのクエリの実行](federated-overview.md)」を参照してください。
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] local_schema_name
FROM MYSQL
DATABASE 'federated_database_name'
URI 'hostname' [ PORT port_number ]
IAM_ROLE [ default | 'arn:aws:iam:::role/' ]
SECRET_ARN 'ssm-secret-arn'
```
次に、Kinesis のストリームデータの参照に使用する、CREATE EXTERNAL SCHEMA コマンドでの構文記述を示します。詳細については、「[マテリアライズドビューへのストリーミング取り込み](materialized-view-streaming-ingestion.md)」を参照してください。
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] schema_name
FROM KINESIS
IAM_ROLE [ default | 'arn:aws:iam:::role/' ]
```
次の構文は、Amazon Managed Streaming for Apache Kafka または Confluent Cloud クラスターとそのトピックを参照し、そこからデータを取り込むために使用する CREATE EXTERNAL SCHEMA コマンドを示しています。接続するには、ブローカー URI を指定します。詳細については、「[マテリアライズドビューへのストリーミング取り込み](materialized-view-streaming-ingestion.md)」を参照してください。
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] schema_name
FROM KAFKA
[ IAM_ROLE [ default | 'arn:aws:iam:::role/' ] ]
URI 'Kafka bootstrap URI'
AUTHENTICATION [ none | iam | mtls ]
[ AUTHENTICATION_ARN 'acm-certificate-arn' | SECRET_ARN 'ssm-secret- arn' ];
```
次の構文は、クロスデータベースクエリを使用してデータを参照するために使用する CREATE EXTERNAL SCHEMA コマンドを示しています。
```
CREATE EXTERNAL SCHEMA local_schema_name
FROM REDSHIFT
DATABASE 'redshift_database_name' SCHEMA 'redshift_schema_name'
```
## パラメータ
IF NOT EXISTS
指定されたスキーマが既に存在する場合、コマンドはエラーで終了するのではなく、何も変更しないで、スキーマが存在するというメッセージを返すことを示す句。この句は、CREATE EXTERNAL SCHEMA で既存のスキーマを作成しようとしてもスクリプトが失敗しないため、スクリプトを作成する際に便利です。
local\$1schema\$1name
新しい外部スキーマの名前。有効な名前の詳細については、「[名前と識別子](r_names.md)」を参照してください。
FROM [ DATA CATALOG ] \$1 HIVE METASTORE \$1 POSTGRES \$1 MYSQL \$1 KINESIS \$1 MSK \$1 REDSHIFT
外部データベースの場所を示すキーワード。
DATA CATALOG は、外部データベースが Athena データカタログまたは AWS Glue Data Catalog 内で定義されていることを示します。
外部データベースが別の AWS リージョンにある外部データカタログで定義されている場合は、REGION パラメータが必要です。DATA CATALOG はデフォルトです。
HIVE METASTORE は、外部データベースが Apache Hive メタストアで定義されていることを示します。HIVE METASTORE が指定されている場合は、URI が必要です。
POSTGRES は、外部データベースが RDS PostgreSQL または Aurora PostgreSQL で定義されていることを示します。
MYSQL は、外部データベースが RDS MySQL または Aurora MySQL で定義されていることを示します。
KINESIS は、データソースが Kinesis Data Streams からのストリームであることを示します。
MSK は、データソースが Amazon MSK でプロビジョニングされたクラスターまたはサーバーレスクラスターであることを示します。
KAFKA は、データソースが Kafka クラスターであることを示しています。このキーワードは、Amazon MSK と Confluent Cloud の両方で使用できます。
FROM REDSHIFT
データベースが Amazon Redshift にあることを示すキーワード。
DATABASE '*redshift\$1database\$1name*' SCHEMA '*redshift\$1schema\$1name*'
Amazon Redshift データベースの名前。
*redshift\$1schema\$1name* は、Amazon Redshift のスキーマを示します。デフォルトの *redshift\$1schema\$1name* は `public` です。
DATABASE '*federated\$1database\$1name*'
サポートされている PostgreSQL または MySQL データベースエンジンの外部データベースの名前を示すキーワード。
[SCHEMA '*schema\$1name*']
*schema\$1name* は、サポートされている PostgreSQL データベースエンジンのスキーマを示します。デフォルトの *schema\$1name* は `public` です。
サポートされている MySQL データベースエンジンへの横串検索を設定する場合、SCHEMA を指定することはできません。
REGION '*aws-region*'
外部データベースが Athena データカタログまたは AWS Glue Data Catalog 内で定義されている場合の、データベースが存在する AWS リージョン。このパラメータは、データベースが外部データカタログで定義されている場合に必要です。
URI [ 'hive\$1metastore\$1uri' [ PORT port\$1number ] \$1 'hostname' [ PORT port\$1number ] \$1 'Kafka bootstrap URI' ]
サポートされている PostgreSQL または MySQL データベースエンジンのホスト名 URI と port\$1number。*hostname* は、レプリカセットのヘッドノードです。エンドポイントは、Amazon Redshift クラスターから到達可能 (ルーティング可能) である必要があります。PostgreSQL のデフォルトの port\$1number は 5432 です。MySQL のデフォルトの port\$1number は 3306 です。
サポートされている PostgreSQL または MySQL データベースエンジンは、Amazon Redshift クラスターと同じ VPC 内にあり、Amazon Redshift と RDS の url-rsPostgreSQL または Aurora PostgreSQL をリンクするセキュリティグループが必要です。さらに、拡張 VPC ルーティングを使用して、クロス VPC ユースケースを設定できます。詳細については、「[RedShift マネージド VPC エンドポイント](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-cluster-cross-vpc.html)」を参照してください。
**Hive メタストア URI の指定**
データベースが Hive メタストアにある場合は、URI を指定し、オプションでメタストアのポート番号を指定します。デフォルトのポート番号は 9083 です。
URI にはプロトコル仕様 ("http://") が含まれていません。有効な URI の例: `uri '172.10.10.10'`。
**ストリーミング取り込み用のブローカー URI の指定**
ブートストラップブローカーの URI を指定すると、Amazon MSK または Confluent Cloud クラスターに接続してストリーミングデータを受信できます。詳細と例については、「[Amazon Managed Streaming for Apache Kafka からのストリーミング取り込みを開始する](https://docs.aws.amazon.com/redshift/latest/dg/materialized-view-streaming-ingestion-getting-started-MSK.html)」を参照してください。
IAM\$1ROLE [ default \$1 'SESSION' \$1 'arn:aws:iam::**:role/**' ]
デフォルトキーワードを使用して、CREATE EXTERNAL SCHEMA コマンドの実行時にデフォルトとして設定され、クラスターに関連付けられた IAM ロールの使用を、Amazon Redshift に指示します。
フェデレーション ID を使用して Amazon Redshift クラスターに接続し、このコマンドを使用して作成された外部スキーマからテーブルにアクセスする場合は、`'SESSION'` を使用します。詳細については、フェデレーション ID の設定方法を説明している「[フェデレーション ID を使用してローカルリソースへの Amazon Redshift アクセスおよび Amazon Redshift Spectrum 外部テーブルを管理する](https://docs.aws.amazon.com/redshift/latest/mgmt/authorization-fas-spectrum.html)」を参照してください。ARN の代わりに `'SESSION'` を使用するこの設定は、`DATA CATALOG` を使用してスキーマを作成した場合にのみ使用できることに注意してください。
クラスターが認証と認可に使用する IAM ロールの Amazon リソースネーム (ARN) を使用します。少なくとも、IAM ロールには、Amazon S3 バケットで LIST オペレーションを実行してアクセスを受ける許可と、バケットに含まれる Amazon S3 オブジェクトで GET オペレーションを実行する許可が必要です。
以下に ARN が 1 つの場合の IAM\$1ROLE パラメータ文字列の構文を示します。
```
IAM_ROLE 'arn:aws:iam:::role/'
```
ロールを連鎖することで、クラスターは別のアカウントに属している可能性がある別の IAM ロールを引き受けることができます。最大 10 個までのロールを連鎖できます。ロールの連鎖の例については、「[Amazon Redshift Spectrum での IAM ロールの連鎖](c-spectrum-iam-policies.md#c-spectrum-chaining-roles)」を参照してください。
この IAM ロールに次のような IAM アクセス許可ポリシーをアタッチします。
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AccessSecret",
"Effect": "Allow",
"Action": [
"secretsmanager:GetResourcePolicy",
"secretsmanager:GetSecretValue",
"secretsmanager:DescribeSecret",
"secretsmanager:ListSecretVersionIds"
],
"Resource": "arn:aws:secretsmanager:us-west-2:123456789012:secret:my-rds-secret-VNenFy"
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": [
"secretsmanager:GetRandomPassword",
"secretsmanager:ListSecrets"
],
"Resource": "*"
}
]
}
```
フェデレーションクエリで使用する IAM ロールを作成するステップについては、「[フェデレーテッドクエリを使用するためのシークレットと IAM ロールの作成](federated-create-secret-iam-role.md)」を参照してください。
連鎖したロールのリストには空白を含めないでください。
以下に連鎖された 3 つのロールの構文を示します。
```
IAM_ROLE 'arn:aws:iam:::role/,arn:aws:iam:::role/,arn:aws:iam:::role/'
```
SECRET\$1ARN '*ssm-secret-arn*'
AWS Secrets Manager を使用して作成された、(サポート対象の) PostgreSQL または MySQL データベースエンジンシークレットの、Amazon リソースネーム (ARN)。シークレットの ARN を作成および取得する方法については、「*AWS Secrets Manager User Guide*」の「[Manage secrets with AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html)」および「[Amazon Redshift でのシークレットの Amazon リソースネーム (ARN) の取得](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-secrets-manager-integration-retrieving-secret.html)」を参照してください。
CATALOG\$1ROLE [ 'SESSION' \$1 *catalog-role-arn-string*]
データカタログの認証と認可のためにフェデレーション ID を使用して Amazon Redshift クラスターに接続する場合は、`'SESSION'` を使用します。フェデレーション ID のステップを完了するための詳細については、「[フェデレーション ID を使用してローカルリソースへの Amazon Redshift アクセスおよび Amazon Redshift Spectrum 外部テーブルを管理する](https://docs.aws.amazon.com/redshift/latest/mgmt/authorization-fas-spectrum.html)」を参照してください。この `'SESSION'` ロールは、DATA CATALOG でスキーマを作成した場合にのみ使用できることに注意してください。
クラスターによってデータカタログの認証と認可に使用される IAM ロールの Amazon リソースネーム (ARN) を使用します。
CATALOG\$1ROLE は Amazon Redshift を指定せず、指定された IAM\$1ROLE を使用します。カタログロールには、AWS Glueあるいは Athena のデータカタログへのアクセス許可が必要です。詳細については、「[Amazon Redshift Spectrum 用の IAM ポリシー](c-spectrum-iam-policies.md)」を参照してください。
以下に ARN が 1 つの場合の CATALOG\$1ROLE パラメータ文字列の構文を示します。
```
CATALOG_ROLE 'arn:aws:iam:::role/'
```
ロールを連鎖することで、クラスターは別のアカウントに属している可能性がある別の IAM ロールを引き受けることができます。最大10 個までのロールを連鎖できます。詳細については、「[Amazon Redshift Spectrum での IAM ロールの連鎖](c-spectrum-iam-policies.md#c-spectrum-chaining-roles)」を参照してください。
連鎖したロールのリストは、空白を含むことができません。
以下に連鎖された 3 つのロールの構文を示します。
```
CATALOG_ROLE 'arn:aws:iam:::role/,arn:aws:iam:::role/,arn:aws:iam:::role/'
```
CREATE EXTERNAL DATABASE IF NOT EXISTS
指定の外部データベースが存在しない場合に、DATABASE 引数で指定された名前で外部データベースを作成する句。指定の外部データベースが存在する場合、コマンドは変更を加えません。この場合、コマンドは、エラーで終了せず、外部データが存在することを示すメッセージを返します。
CREATE EXTERNAL DATABASE IF NOT EXISTS を HIVE METASTORE と併用することはできません。
AWS Lake Formation が有効になっているデータカタログで、CREATE EXTERNAL DATABASE IF NOT EXISTS を使用するには、データカタログに対し `CREATE_DATABASE` を実行する許可が必要です。
CATALOG\$1ID '*Glue または Lake Formation データベースに含まれるアマゾン ウェブ サービスのアカウント ID *'
データカタログデータベースが保存されているアカウント ID。
`CATALOG_ID` は、次のいずれかを設定することで、データカタログの認証と認可にフェデレーション ID を使用して Amazon Redshift クラスターまたは Amazon Redshift Serverless に接続する予定の場合に限り指定できます。
+ `CATALOG_ROLE`～`'SESSION'`
+ `IAM_ROLE`、`'SESSION'`、`'CATALOG_ROLE'` をデフォルトに設定する
フェデレーション ID のステップを完了するための詳細については、「[フェデレーション ID を使用して、ローカルリソースと Amazon Redshift Spectrum の外部テーブルへの Amazon Redshift アクセスを管理する](https://docs.aws.amazon.com/redshift/latest/mgmt/authorization-fas-spectrum.html)」を参照してください。
AUTHENTICATION
ストリーミング取り込み用に定義された認証タイプ。認証タイプによるストリーミング取り込みは、Amazon Managed Streaming for Apache Kafka と連携します。`AUTHENTICATION` タイプには以下のものがあります。
+ **none** — 必要な認証がないことを指定します。これは、MSK の場合は非認証アクセス、Apache Kafka の場合は TLS を使用したプレーンテキストに相当します。
+ **iam** — IAM 認証を指定します。これを選択するときは、IAM ロールに IAM 認証のアクセス許可があることを確認します。外部スキーマの定義の詳細については、「[Apache Kafka ソースからのストリーミング取り込みの開始方法](materialized-view-streaming-ingestion-getting-started-MSK.md)」を参照してください。
+ **mtls** – クライアントとサーバー間の認証を行うことで、相互 Transport Layer Security が安全な通信を提供することを指定します。この場合、クライアントは Redshift で、サーバーは Amazon MSK です。mTLS によるストリーミング取り込みの設定の詳細については、「[Apache Kafka ソースからの Redshift ストリーミング取り込みにおける mTLS による認証](materialized-view-streaming-ingestion-mtls.md)」を参照してください。
AUTHENTICATION\$1ARN
Amazon Redshift が Amazon MSK による mtls 認証に使用する AWS Certificate Manager 証明書の ARN。ARN は、発行された証明書を選択する際に ACM コンソールで利用できます。
CLUSTER\$1ARN
ストリーミング取り込みの場合、CLUSTER\$1ARN は、ストリーミング元の Amazon Managed Streaming for Apache Kafka クラスターのクラスター識別子です。CLUSTER\$1ARN を使用する場合は、`kafka:GetBootstrapBrokers` アクセス許可を含む IAM ロールポリシーが必要です。このオプションは、下位互換性のために用意されています。現在、ブートストラップブローカー URI オプションを使用して Amazon Managed Streaming for Apache Kafka クラスターに接続することをお勧めします。詳細については、「[ストリーミングの取り込み](https://docs.aws.amazon.com/redshift/latest/dg/materialized-view-streaming-ingestion.html)」を参照してください。
## 使用に関する注意事項
Athena データカタログを使用する場合の制限については、「AWS 全般のリファレンス」の「[Athena の制限](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html#amazon-athena-limits)」を参照してください。
AWS Glue Data Catalog を使用する場合の制限については、「AWS 全般のリファレンス」の「[AWS Glue の制限](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html#limits_glue)」を参照してください。
これらの制限は、Hive メタストアには適用されません。
スキーマの数は 1 つのデータベースにつき最大 9,900 個です。詳細については、*Amazon Redshift 管理ガイド*の「[クォータと制限](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html)」を参照してください。
スキーマの登録を解除するには、[DROP SCHEMA](r_DROP_SCHEMA.md)コマンドを使用します。
外部スキーマの詳細を表示するには、システムビューにクエリを実行します。
+ [SVV\$1EXTERNAL\$1SCHEMAS](r_SVV_EXTERNAL_SCHEMAS.md)
+ [SVV\$1EXTERNAL\$1TABLES](r_SVV_EXTERNAL_TABLES.md)
+ [SVV\$1EXTERNAL\$1COLUMNS](r_SVV_EXTERNAL_COLUMNS.md)
## 例
次の例では、米国西部 (オレゴン) リージョンの `sampledb` という名前のデータカタログのデータベースを使用して外部スキーマを作成します。この例を Athena または AWS Glue データカタログで使用します。
```
create external schema spectrum_schema
from data catalog
database 'sampledb'
region 'us-west-2'
iam_role 'arn:aws:iam::123456789012:role/MySpectrumRole';
```
次の例は、外部スキーマを作成し、`spectrum_db`という名前で新しい外部データベースを作成します。
```
create external schema spectrum_schema
from data catalog
database 'spectrum_db'
iam_role 'arn:aws:iam::123456789012:role/MySpectrumRole'
create external database if not exists;
```
次の例では、`hive_db`という名前の Hive メタストアデータベースを使って外部スキーマを作成します。
```
create external schema hive_schema
from hive metastore
database 'hive_db'
uri '172.10.10.10' port 99
iam_role 'arn:aws:iam::123456789012:role/MySpectrumRole';
```
次の連鎖ロールの例では、Amazon S3 へのアクセスにロール `myS3Role` を使用し、データカタログへのアクセスには `myAthenaRole` を使用します。詳細については、「[Amazon Redshift Spectrum での IAM ロールの連鎖](c-spectrum-iam-policies.md#c-spectrum-chaining-roles)」を参照してください。
```
create external schema spectrum_schema
from data catalog
database 'spectrum_db'
iam_role 'arn:aws:iam::123456789012:role/myRedshiftRole,arn:aws:iam::123456789012:role/myS3Role'
catalog_role 'arn:aws:iam::123456789012:role/myAthenaRole'
create external database if not exists;
```
次の例では、Aurora PostgreSQL データベースを参照する外部スキーマを作成します。
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] myRedshiftSchema
FROM POSTGRES
DATABASE 'my_aurora_db' SCHEMA 'my_aurora_schema'
URI 'endpoint to aurora hostname' PORT 5432
IAM_ROLE 'arn:aws:iam::123456789012:role/MyAuroraRole'
SECRET_ARN 'arn:aws:secretsmanager:us-east-2:123456789012:secret:development/MyTestDatabase-AbCdEf'
```
次の例では、外部スキーマを作成し、コンシューマークラスターにインポートされた sales\$1db を参照しています。
```
CREATE EXTERNAL SCHEMA sales_schema FROM REDSHIFT DATABASE 'sales_db' SCHEMA 'public';
```
次の例では、Aurora MySQL データベースを参照する外部スキーマを作成します。
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] myRedshiftSchema
FROM MYSQL
DATABASE 'my_aurora_db'
URI 'endpoint to aurora hostname'
IAM_ROLE 'arn:aws:iam::123456789012:role/MyAuroraRole'
SECRET_ARN 'arn:aws:secretsmanager:us-east-2:123456789012:secret:development/MyTestDatabase-AbCdEf'
```
# CREATE EXTERNAL TABLE
指定のスキーマに新しい外部テーブルを作成します。外部テーブルはすべて、外部スキーマで作成されている必要があります。外部スキーマと外部テーブルは検索パスをサポートしていません。詳細については、「[CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md)」を参照してください。
Amazon Redshift では、CREATE EXTERNAL TABLE コマンドを使用して作成された外部テーブルに加えて、AWS Glueまたは AWS Lake Formation カタログ、あるいは Apache Hive メタストアで定義された外部テーブルの参照が可能です。[CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md) コマンドを使用して、外部カタログで定義された外部データベースを登録し、外部テーブルを Amazon Redshift で使用できるようにします。外部テーブルが AWS Glue または AWS Lake Formation カタログあるいは Hive メタストアに存在する場合は、CREATE EXTERNAL TABLE を使用してテーブルを作成する必要はありません。外部テーブルを表示するには、[SVV\$1EXTERNAL\$1TABLES](r_SVV_EXTERNAL_TABLES.md)システムビューに対してクエリを実行します。
CREATE EXTERNAL TABLE AS コマンドを実行することで、クエリからの列定義に基づいて外部テーブルを作成し、そのクエリの結果を Amazon S3 に書き込むことができます。結果は、Apache Parquet または区切りテキスト形式です。外部テーブルにパーティションキーがある場合、Amazon Redshift はそれらのパーティションキーに従って新しいファイルをパーティション分割し、新しいパーティションを外部カタログに自動的に登録します。CREATE EXTERNAL TABLE AS の詳細については、「[使用に関する注意事項](r_CREATE_EXTERNAL_TABLE_usage.md)」を参照してください。
他の Amazon Redshift テーブルで使用したものと同じ SELECT 構文で、外部テーブルにクエリを実行できます。INSERT 構文を使用して、Amazon S3 の外部テーブルの場所に新しいファイルを書き込むこともできます。詳細については、「[INSERT (外部テーブル)](r_INSERT_external_table.md)」を参照してください。
外部テーブルでビューを作成するには、[CREATE VIEW](r_CREATE_VIEW.md)ステートメントに WITH NO SCHEMA BINDING 句を含めます。
トランザクション内 (BEGIN… END) で CREATE EXTERNAL TABLE を実行することはできません。トランザクションの詳細については、「[Amazon Redshift の分離レベル](c_serial_isolation.md)」を参照してください。
## 必要な権限
外部テーブルを作成するには、外部スキーマの所有者またはスーパーユーザーである必要があります。外部スキーマの所有者を移行するには、「ALTER SCHEMA」を使用して所有者を変更します。外部テーブルへのアクセスは、外部スキーマへのアクセスによってコントロールされます。外部テーブルに対してアクセス権限の [GRANT](r_GRANT.md) または [REVOKE](r_REVOKE.md) を実行することはできません。代わりに、外部スキーマに対して USAGE の付与または削除を実行します。
[使用に関する注意事項](r_CREATE_EXTERNAL_TABLE_usage.md) には、外部テーブルに対する特定のアクセス許可に関する追加情報があります。
## 構文
```
CREATE EXTERNAL TABLE
external_schema.table_name
(column_name data_type [, …] )
[ PARTITIONED BY (col_name data_type [, … ] )]
[ { ROW FORMAT DELIMITED row_format |
ROW FORMAT SERDE 'serde_name'
[ WITH SERDEPROPERTIES ( 'property_name' = 'property_value' [, ...] ) ] } ]
STORED AS file_format
LOCATION { 's3://bucket/folder/' | 's3://bucket/manifest_file' }
[ TABLE PROPERTIES ( 'property_name'='property_value' [, ...] ) ]
```
以下に示しているのは、CREATE EXTERNAL TABLE AS の構文です。
```
CREATE EXTERNAL TABLE
external_schema.table_name
[ PARTITIONED BY (col_name [, … ] ) ]
[ ROW FORMAT DELIMITED row_format ]
STORED AS file_format
LOCATION { 's3://bucket/folder/' }
[ TABLE PROPERTIES ( 'property_name'='property_value' [, ...] ) ]
AS
{ select_statement }
```
## パラメータ
*external\$1schema.table\$1name*
作成され、外部スキーマ名で修飾されるテーブルの名前。外部テーブルは、外部スキーマで作成されている必要があります。詳細については、「[CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md)」を参照してください。
テーブル名の最大長は 127 バイトです。それより長い名前は 127 バイトまで切り詰められます。最大 4 バイトまで UTF-8 マルチバイト文字を使用できます。Amazon Redshift では、ユーザー定義の一時テーブルと、クエリ処理またはシステムメンテナンス中に Amazon Redshift によって作成された一時テーブルを含め、クラスターごとに 9,900 テーブルの制限を適用します。必要に応じて、データベース名でテーブル名を修飾することができます。次の例では、データベース名は `spectrum_db`、外部スキーマ名は `spectrum_schema`、テーブル名は `test` です。
```
create external table spectrum_db.spectrum_schema.test (c1 int)
stored as parquet
location 's3://amzn-s3-demo-bucket/myfolder/';
```
指定のデータベースまたはスキーマが存在せず、テーブルが作成されていない場合、このステートメントはエラーを返します。システムデータベース `template0`、`template1`、`padb_harvest`、または `sys:internal` にテーブルまたはビューを作成することはできません。
テーブル名は、指定のスキーマで一意の名前にする必要があります。
有効な名前の詳細については、「[名前と識別子](r_names.md)」を参照してください。
( *column\$1name* *data\$1type* )
作成される各列の名前とデータタイプ。
列名の最大長は 127 バイトです。それより長い名前は 127 バイトまで切り詰められます。最大 4 バイトまで UTF-8 マルチバイト文字を使用できます。列名 `"$path"` または `"$size"` は指定できません。有効な名前の詳細については、「[名前と識別子](r_names.md)」を参照してください。
デフォルトでは、Amazon Redshift は疑似列 (`$path` および `$size`) を使用して外部テーブルを作成します。セッションの疑似列の作成を無効にするには、`spectrum_enable_pseudo_columns`設定パラメータを `false` に設定します。詳細については、「[疑似列](r_CREATE_EXTERNAL_TABLE_usage.md#r_CREATE_EXTERNAL_TABLE_usage-pseudocolumns)」を参照してください。
擬似列が有効な場合、1 つのテーブルで定義できる列の最大数は 1,598 です。擬似列が有効でない場合、1 つのテーブルで定義できる列の最大数は 1,600 です。
「横長のテーブル」を作成する場合は、ロードとクエリ処理の結果が即時に表示されるように、列リストが行幅の限度を超えないことを確認します。詳細については、「[使用に関する注意事項](r_CREATE_TABLE_NEW.md#r_CREATE_TABLE_usage)」を参照してください。
CREATE EXTERNAL TABLE AS コマンドの場合、列はクエリから取得されるため、列リストは必要ありません。
*data\$1type*
次の [データ型](c_Supported_data_types.md)がサポートされています。
+ SMALLINT (INT2)
+ INTEGER (INT、INT4)
+ BIGINT (INT8)
+ DECIMAL (NUMERIC)
+ REAL (FLOAT4)
+ DOUBLE PRECISION (FLOAT8)
+ BOOLEAN (BOOL)
+ CHAR (CHARACTER)
+ VARCHAR (CHARACTER VARYING)
+ VARBYTE (CHARACTER VARYING) – Parquet および ORC データファイルで、パーティション化されていないテーブルでのみ使用できます。
+ DATE – テキスト、Parquet、または ORC データファイルでのみ使用できます。またはパーティション列としてのみ使用できます。
+ TIMESTAMP
DATE では、以下に示す形式を使用できます。数字を使用して表される月の値では、次の形式がサポートされています。
+ `mm-dd-yyyy` は、例えば、`05-01-2017` です。これがデフォルトです。
+ `yyyy-mm-dd`、ただし年は 2 桁以上で表します。例えば、`2017-05-01`。
3 文字の略語を使用して表される月の値では、次の形式がサポートされています。
+ `mmm-dd-yyyy` は、例えば、`may-01-2017` です。これがデフォルトです。
+ `dd-mmm-yyyy`、ただし年は 2 桁以上で表します。例えば、`01-may-2017`。
+ `yyyy-mmm-dd`、ただし年は 3 桁以上で表します。例えば、`2017-may-01`。
年の値が一貫して 100 未満の場合、年は次の方法で計算されます。
+ 年の値が 70 より小さい場合、年は 2000 を足した数として計算されます。例えば、`mm-dd-yyyy`形式での 05-01-17 という日付は `05-01-2017` に変換されます。
+ 年の値が 100 未満で 69 より大きい場合、年は 1900 を足した数として計算されます。例えば、`mm-dd-yyyy`形式での 05-01-89 という日付は `05-01-1989` に変換されます。
+ 2 桁で表される年の値については、先頭にゼロを追加した 4 桁として年を表します。
テキストファイルのタイムスタンプ値は、`yyyy-mm-dd HH:mm:ss.SSSSSS`形式であることが必要です。次のタイムスタンプ値は、`2017-05-01 11:30:59.000000`となっています。
VARCHAR 列の長さは、文字単位ではなくバイト単位で定義されます。例えば、VARCHAR(12) 列には、シングルバイト文字なら 12 個、2 バイト文字なら 6 個含めることができます。外部テーブルのクエリを実行すると、エラーが返されずに、定義された列サイズに合うように結果が切り捨てられます。詳細については、「[ストレージと範囲](r_Character_types.md#r_Character_types-storage-and-ranges)」を参照してください。
最高のパフォーマンスを得るために、データに合う最小の列サイズを指定することをお勧めします。列の値の最大サイズ (バイト単位) を調べるには、[OCTET\$1LENGTH](r_OCTET_LENGTH.md) 関数を使用します。次の例では、E メール列の値の最大サイズを返します。
```
select max(octet_length(email)) from users;
max
---
62
```
PARTITIONED BY (*col\$1name* *data\$1type* [, … ] )
1 つ以上のパーティション列でパーティション化されたテーブルを定義する句。指定の組み合わせごとに独立したデータディレクトリが使用されます。これにより、一部の状況でクエリパフォーマンスが向上します。パーティション化された列はテーブルデータ内には存在しません。テーブル列と同じ *col\$1name* の値を使用すると、エラーになります。
パーティションテーブルを作成した後、[ALTER TABLE](r_ALTER_TABLE.md)… ADD PARTITION ステートメントを使用してテーブルを変更し、新しいパーティションを外部カタログに登録します。パーティションを追加する際は、パーティションデータを含む で Amazon S3 サブフォルダの位置を定義します。
例えば、テーブル `spectrum.lineitem_part` が `PARTITIONED BY (l_shipdate date)` で定義されている場合は、以下の ALTER TABLE コマンドを実行してパーティションを追加します。
```
ALTER TABLE spectrum.lineitem_part ADD PARTITION (l_shipdate='1992-01-29')
LOCATION 's3://spectrum-public/lineitem_partition/l_shipdate=1992-01-29';
```
CREATE EXTERNAL TABLE AS を使用する場合、ALTER TABLE...ADD PARTITION を実行する必要はありません。Amazon Redshift は、新しいパーティションを外部カタログに自動的に登録します。また、Amazon Redshift は、テーブルに定義された 1 つまたは複数のパーティションキーに基づいて、対応するデータを Amazon S3 のパーティションに自動的に書き込みます。
パーティションを表示するには、[SVV\$1EXTERNAL\$1PARTITIONS](r_SVV_EXTERNAL_PARTITIONS.md)システムビューにクエリを実行します。
CREATE EXTERNAL TABLE AS コマンドの場合、この列はクエリから取得されるため、パーティション列のデータ型を指定する必要はありません。
ROW FORMAT DELIMITED *rowformat*
仮想データの型式を指定する句。以下に、*rowformat* で想定される値を示します。
+ LINES TERMINATED BY '*delimiter*'
+ FIELDS TERMINATED BY '*delimiter*'
'*区切り記号*'に 1 つの ASCII 文字を指定します｡ 印刷不能な ASCII 文字は、`'\`*`ddd`*`'` の形式を使用して指定できます。*`d`* は 8 進数 (0～7) で、最大値は「\$1177」です。次の例では、BEL (ベル) 文字を 8 進数で指定しています。
```
ROW FORMAT DELIMITED FIELDS TERMINATED BY '\007'
```
ROW FORMAT を省略した場合のデフォルト形式は DELIMITED FIELDS TERMINATED BY '\$1A' (ヘッダーの開始) と LINES TERMINATED BY '\$1n' (改行) です。
ROW FORMAT SERDE '*serde\$1name*'[WITH SERDEPROPERTIES ( '*property\$1name*' = '*property\$1value*' [, ...] ) ]
基盤となるデータの SERDE 形式を指定する句。
'*serde\$1name*'
SerDe 名。以下の形式を指定できます。
+ org.apache.hadoop.hive.serde2.RegexSerDe
+ com.amazonaws.glue.serde.GrokSerDe
+ org.apache.hadoop.hive.serde2.OpenCSVSerde
このパラメータは、OpenCSVSerde において、次の SerDe プロパティをサポートします。
```
'wholeFile' = 'true'
```
`wholeFile` プロパティに `true` を設定することで、OpenCSV リクエストの引用符で囲まれた文字列内の改行文字 (\$1 n) を、正しく解析することができます。
+ org.openx.data.jsonserde.JsonSerDe
+ JSON SERDE は Ion ファイルもサポートしています。
+ JSON は正しい形式になっている必要があります。
+ Ion および JSON 形式のタイムスタンプには、ISO8601 形式を使用する必要があります。
+ このパラメータでは、JsonSerDe のための、次の SerDe プロパティがサポートされています。
```
'strip.outer.array'='true'
```
配列内に複数の JSON レコードが含まれているかのように、大括弧で囲まれた 1 つの非常に大きな配列 ( [ … ] ) を含む Ion/JSON ファイルを処理します。
+ com.amazon.ionhiveserde.IonHiveSerDe
Amazon ION 形式では、データ型に加えて、テキスト形式とバイナリ形式を使用できます。ION 形式のデータを参照する外部テーブルの場合、外部テーブルの各列を、対応する ION 形式データの各要素にマッピングします。詳細については、「[Amazon Ion](https://amzn.github.io/ion-docs/)」を参照してください。また、入力形式と出力形式を指定する必要もあります。
WITH SERDEPROPERTIES ( '*property\$1name*' = '*property\$1value*' [, ...] ) ]
オプションで、プロパティ名と値をコンマで区切って指定します。
ROW FORMAT を省略した場合のデフォルト形式は DELIMITED FIELDS TERMINATED BY '\$1A' (ヘッダーの開始) と LINES TERMINATED BY '\$1n' (改行) です。
STORED AS *file\$1format*
外部データファイルのファイル形式。
有効な形式は次のとおりです。
+ PARQUET
+ RCFILE (LazyBinaryColumnarSerDe ではなく ColumnarSerD eのみを使用するデータ用)
+ SEQUENCEFILE
+ TEXTFILE (JSON ファイルを含むテキストファイル)。
+ ORC
+ AVRO
+ INPUTFORMAT '*input\$1format\$1classname*' OUTPUTFORMAT '*output\$1format\$1classname*'
CREATE EXTERNAL TABLE AS コマンドは、TEXTFILE と PARQUET の 2 つのファイル形式のみをサポートしています。
INPUTFORMAT と OUTPUTFORMAT では、以下の例に示すように、クラス名を指定します。
```
'org.apache.hadoop.mapred.TextInputFormat'
```
LOCATION \$1 's3://*bucket/folder*/' \$1 's3://*bucket/manifest\$1file*'\$1
データファイルを含む Amazon S3 バケットかフォルダ、または Amazon S3 オブジェクトパスのリストを含むマニフェストファイルへのパス。バケットは、Amazon Redshift クラスターと同じ AWS リージョン内に置かれている必要があります。サポートされている AWS リージョンの一覧は、「[Amazon Redshift Spectrum の制限事項](c-spectrum-considerations.md)」でご確認ください。
パスがバケットかフォルダを指定している場合 (`'s3://amzn-s3-demo-bucket/custdata/'` など)、Redshift Spectrum は指定されたバケットかフォルダ、およびサブフォルダのファイルをスキャンします。Redshift Spectrum は、隠しファイルと、ファイル名がピリオドやアンダースコアで始まるファイルを無視します。
パスがマニフェストファイルを指定している場合、`'s3://bucket/manifest_file'`引数は 1 つのファイル (たとえば `'s3://amzn-s3-demo-bucket/manifest.txt'` など) を明示的に参照する必要があります。キープレフィックスを参照することはできません。
マニフェストは、JSON 形式のテキストファイルであり、Amazon S3 からロードする各ファイルの URL とファイルサイズ (バイト単位) を示します。URL にはバケット名およびファイルの完全オブジェクトパスが含まれます。マニフェストで指定するファイルの場所は異なるバケットでもかまいませんが、すべてのバケットは Amazon Redshift クラスターと同じ AWS リージョンに置かれている必要があります。ファイルが 2 回リストされている場合、ファイルは 2 回ロードされます。次の例は、3 つのファイルをロードするマニフェストの JSON を示しています。
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket1/custdata.1", "meta": { "content_length": 5956875 } },
{"url":"s3://amzn-s3-demo-bucket1/custdata.2", "meta": { "content_length": 5997091 } },
{"url":"s3://amzn-s3-demo-bucket2/custdata.1", "meta": { "content_length": 5978675 } }
]
}
```
特定のファイルを含めることを必須にすることができます。これを行うには、マニフェストのファイルレベルで `mandatory` オプションを含めます。欠落している必須ファイルを使用して外部テーブルをクエリすると、SELECT ステートメントは失敗します。外部テーブルの定義に含まれるすべてのファイルが存在することを確認します。これらがすべて存在しない場合は、最初の必須ファイルが見つかりませんというエラーが表示されます。次の例では、`mandatory`オプションを `true` に設定したマニフェストの JSON を説明します。
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket1/custdata.1", "mandatory":true, "meta": { "content_length": 5956875 } },
{"url":"s3://amzn-s3-demo-bucket1/custdata.2", "mandatory":false, "meta": { "content_length": 5997091 } },
{"url":"s3://amzn-s3-demo-bucket2/custdata.1", "meta": { "content_length": 5978675 } }
]
}
```
UNLOAD を使用して作成したファイルを参照する場合は、[UNLOAD](r_UNLOAD.md)で MANIFEST パラメータを使用して作成したマニフェストを使用できます。マニフェストファイルは、「[Amazon S3 からの COPY](copy-parameters-data-source-s3.md)」でのマニフェストファイルと互換性がありますが、使用するキーが異なります。使用しないキーは無視されます。
TABLE PROPERTIES ( '*property\$1name*'='*property\$1value*' [, ...] )
テーブルプロパティのテーブル定義を設定する句。
テーブルのプロパティでは、大文字と小文字が区別されます。
'compression\$1type'='*value*'
ファイル名に拡張子が含まれていない場合に使用する圧縮タイプを設定するプロパティ。ファイル拡張子があるときに、このプロパティを設定すると、拡張子は無視されて、プロパティで設定された値が使用されます。圧縮タイプの有効値は次のとおりです。
+ bzip2
+ gzip
+ なし
+ snappy
'data\$1cleansing\$1enabled'='true / false’
このプロパティは、テーブルのデータ処理が有効かどうかを設定します。'data\$1cleansing\$1enabled' が true に設定されている場合は、テーブルのデータ処理が有効です。'data\$1cleansing\$1enabled' が false に設定されている場合、テーブルのデータ処理は無効です。以下は、このプロパティが制御するテーブルレベルでのデータ処理プロパティのリストです。
+ column\$1count\$1mismatch\$1handling
+ invalid\$1char\$1handling
+ overflow\$1handling
+ replacement\$1char
+ surplus\$1char\$1handling
例については、「[データ処理の例](r_CREATE_EXTERNAL_TABLE_examples.md#r_CREATE_EXTERNAL_TABLE_examples-data-handling)」を参照してください。
'invalid\$1char\$1handling'='*value*'
クエリ結果に無効な UTF-8 文字値が含まれている場合に実行するアクションを指定します。以下のアクションを指定できます。
DISABLED
無効な文字の処理を実行しません。
FAIL
無効な UTF-8 値が含まれたデータを返すクエリをキャンセルします。
SET\$1TO\$1NULL
無効な UTF-8 値を null に置き換えます。
DROP\$1ROW
行内の各値を null に置き換えます。
REPLACE
`replacement_char` を使用して無効な文字を指定した置換文字に置き換えます。
'replacement\$1char'='*character*’
`invalid_char_handling` を `REPLACE` に設定するときに使用する置換文字を指定します。
'numeric\$1overflow\$1handling'='value’
ORC データに列定義 (例えば SMALLINT や int16) よりも大きい整数 (例えば BIGINT や int64) が含まれているときに実行するアクションを指定します。以下のアクションを指定できます。
DISABLED
無効な文字の処理が無効化されています。
FAIL
データに無効な文字が含まれているときにクエリをキャンセルします。
SET\$1TO\$1NULL
無効な文字を null に設定します。
DROP\$1ROW
行内の各値を null に設定します。
'surplus\$1bytes\$1handling'='*value*'
ロードされているデータで、VARBYTE データが含まれる列に定義されたデータ型の長さを超えるデータの処理方法を指定します。Redshift Spectrum はデフォルトで、列の幅を超えるデータの値を null に設定します。
クエリがデータ型の長さを超えるデータを返すときに実行する以下のアクションを指定できます。
SET\$1TO\$1NULL
列幅を超えるデータを null に置き換えます。
無効
余剰バイトの処理を実行しません。
FAIL
列幅を超えるデータを返すクエリをキャンセルします。
DROP\$1ROW
列幅を超えるデータを含むすべての行を削除します。
TRUNCATE
列に定義された最大文字数を超える文字を削除します。
'surplus\$1char\$1handling'='*value*'
ロードされているデータで、VARCHAR、CHAR、または文字列データが含まれる列に定義されたデータ型の長さを超えるデータの処理方法を指定します。Redshift Spectrum はデフォルトで、列の幅を超えるデータの値を null に設定します。
クエリが列幅を超えるデータを返すときに実行する以下のアクションを指定できます。
SET\$1TO\$1NULL
列幅を超えるデータを null に置き換えます。
無効
余剰文字の処理を実行しません。
FAIL
列幅を超えるデータを返すクエリをキャンセルします。
DROP\$1ROW
行内の各値を null に置き換えます。
TRUNCATE
列に定義された最大文字数を超える文字を削除します。
'column\$1count\$1mismatch\$1handling'='value'
ファイルに含まれる行の値が、外部テーブル定義で指定された列数よりも少ないか多いかを識別します。このプロパティは、非圧縮テキストファイル形式でのみ使用できます。以下のアクションを指定できます。
DISABLED
列数の不一致処理が無効化されています。
FAIL
列数の不一致が検出された場合、クエリは失敗します。
SET\$1TO\$1NULL
欠落した値を NULL で埋め、各行の追加の値を無視します。
DROP\$1ROW
列数の不一致エラーを含むすべての行をスキャンからドロップします。
'numRows'='*row\$1count*'
テーブル定義の numRows 値を設定するプロパティ。外部テーブルの統計を明示的に更新するには、テーブルのサイズを示す numRows プロパティを設定します。Amazon Redshift は、外部テーブルを分析して、クエリオプティマイザがクエリプランを生成するために使用するテーブル統計を生成することはありません。外部テーブルに対してテーブル統計が設定されていない場合、Amazon Redshift は、外部テーブルが大きなテーブルであり、ローカルテーブルが小さいテーブルであるという前提に基づいてクエリ実行プランを生成します。
'skip.header.line.count'='*line\$1count*'
各ソースファイルの最初に省略する行数を設定するプロパティ。
'serialization.null.format'=' '
範囲を示すプロパティは、フィールドで指定されたテキストに完全に一致するものがある場合に、値 `NULL` を返します。
'orc.schema.resolution'='mapping\$1type'
ORC データ形式を使用するテーブルの列マッピングタイプを設定するプロパティ。このプロパティは、他のデータ形式では無視されます。
列マッピングタイプの有効値は次のとおりです。
+ name
+ position
*orc.schema.resolution* プロパティが省略されている場合、列はデフォルトで、名前を基準としてマップされます。*orc.schema.resolution* が *'name'* または *'position'* 以外の値に設定されている場合、列は位置を基準としてマップされます。列マッピングの詳細については、「[外部テーブル列を ORC 列にマッピングする](c-spectrum-external-tables.md#c-spectrum-column-mapping-orc)」を参照してください。
COPY コマンドは、位置のみを基準として ORC データファイルにマップします。*orc.schema.resolution* テーブルプロパティは、COPY コマンドの動作には影響しません。
'write.parallel'='on / off'
CREATE EXTERNAL TABLE AS がデータを並列で書き込む必要があるかどうかを設定するプロパティ。デフォルトでは、CREATE EXTERNAL TABLE AS は、クラスター内のスライスの数に応じて、データを複数のファイルに並列で書き込みます。デフォルトのオプションは on です。'write.parallel' が off に設定されている場合、CREATE EXTERNAL TABLE AS は 1 つ以上のデータファイルを Amazon S3 に順次に書き込みます。このテーブルプロパティは、同じ外部テーブルへの後続の INSERT ステートメントにも適用されます。
'write.maxfilesize.mb'='size'
CREATE EXTERNAL TABLE AS によって Amazon S3 に書き込まれる各ファイルの最大サイズ (MB 単位) を設定するプロパティ。サイズは 5 〜 6200 の有効な整数であることが必要です。デフォルトの最大ファイルサイズは 6,200 MB です。このテーブルプロパティは、同じ外部テーブルへの後続の INSERT ステートメントにも適用されます。
‘write.kms.key.id’=‘*value*’
Amazon S3 オブジェクトのサーバー側の暗号化 (SSE) を有効にする AWS Key Management Service キーを指定できます。この *value* は、以下のいずれかになります。
+ Amazon S3 バケットに保存されたデフォルトの AWS KMS キーを使用するための `auto`。
+ データを暗号化するために指定する *kms-key*。
*select\$1statement*
クエリを定義して 1 つ以上の行を外部テーブルに挿入するステートメント。クエリによって生成されるすべての行は、テーブル定義に基づいて、テキストまたは Parquet 形式で Amazon S3 に書き込まれます。
## 例
例のコレクションは、[例](r_CREATE_EXTERNAL_TABLE_examples.md) にあります。
# 使用に関する注意事項
このトピックには、[CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md) の使用上の注意事項が含まれています。[PG\$1TABLE\$1DEF](r_PG_TABLE_DEF.md)、[STV\$1TBL\$1PERM](r_STV_TBL_PERM.md)、PG\$1CLASS、または information\$1schema など、標準の Amazon Redshift テーブルに使用したものと同じリソースを使用して Amazon Redshift Spectrum テーブルの詳細を表示することはできません。ビジネスインテリジェンスまたは分析ツールが Redshift Spectrum 外部テーブルを認識しない場合は、[SVV\$1EXTERNAL\$1TABLES](r_SVV_EXTERNAL_TABLES.md)および [SVV\$1EXTERNAL\$1COLUMNS](r_SVV_EXTERNAL_COLUMNS.md) にクエリを実行するようにアプリケーションを設定します。
## CREATE EXTERNAL TABLE AS
一部のケースでは、AWS Glueデータカタログ、AWS Lake Formation外部カタログ、または Apache Hive メタストアに対して、CREATE EXTERNAL TABLE AS コマンドを実行します。このような場合は、AWS Identity and Access Management(IAM) ロールを使用して外部スキーマを作成します。この IAM ロールには、Amazon S3 に対する読み込みと書き込みの両方のアクセス許可が必要です。
Lake Formation カタログを使用する場合、IAM ロールにはカタログにテーブルを作成するアクセス許可が必要です。この場合、ターゲット Amazon S3 パスに対するデータレイクの場所のアクセス許可が必要です。この IAM ロールは新しい AWS Lake Formation テーブルの所有者になります。
ファイル名が必ず一意になるように、Amazon Redshift ではデフォルトで、Amazon S3 にアップロードされる各ファイルの名前に以下の形式が使用されます。
`_