翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。

# ビルトインモジュール
<a name="built-in-modules-js"></a>

モジュールは `APPSYNC_JS` ランタイムの一部であり、JavaScript リゾルバーと関数の作成に役立つユーティリティを提供します。サンプルと例については、[aws-appsync-resolver-samples](https://github.com/aws-samples/aws-appsync-resolver-samples) GitHub リポジトリを参照してください。

## DynamoDB モジュール関数
<a name="built-in-ddb-modules"></a>

DynamoDB モジュール関数を使用すると、DynamoDB データソースを操作する際のエクスペリエンスが向上します。タイプマッピングを追加しなくても、関数を使用して DynamoDB データソースに対してリクエストを行うことができます。

モジュールは `@aws-appsync/utils/dynamodb` を使用してインポートされます。

```
// Modules are imported using @aws-appsync/utils/dynamodb
import * as ddb from '@aws-appsync/utils/dynamodb';
```

### 関数
<a name="built-in-ddb-modules-functions"></a>

#### 関数のリスト
<a name="built-in-ddb-modules-functions-list"></a>

 **` get<T>(payload: GetInput): DynamoDBGetItemRequest`**  
GetInput については、「[入力](#built-in-ddb-modules-inputs)」を参照してください。
DynamoDB に [GetItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-getitem) リクエストを行うための `DynamoDBGetItemRequest` オブジェクトを生成します。  

```
import { get } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	return get({ key: { id: ctx.args.id } });
}
```

 **`put<T>(payload): DynamoDBPutItemRequest`**  
DynamoDB に [PutItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem) リクエストを行うための `DynamoDBPutItemRequest` オブジェクトを生成します。  

```
import * as ddb from '@aws-appsync/utils/dynamodb'

export function request(ctx) {
	return ddb.put({ key: { id: util.autoId() }, item: ctx.args });
}
```

**`remove<T>(payload): DynamoDBDeleteItemRequest`**  
DynamoDB に [DeleteItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-deleteitem) リクエストを行うための `DynamoDBDeleteItemRequest` オブジェクトを生成します。  

```
import * as ddb from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	return ddb.remove({ key: { id: ctx.args.id } });
}
```

**`scan<T>(payload): DynamoDBScanRequest`**  
DynamoDB に [Scan](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan) リクエストを行うための`DynamoDBScanRequest`を生成します。  

```
import * as ddb from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const { limit = 10, nextToken } = ctx.args;
	return ddb.scan({ limit, nextToken });
}
```

**`sync<T>(payload): DynamoDBSyncRequest`**  
[Sync](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-sync) リクエストを行う `DynamoDBSyncRequest` オブジェクトを生成します。リクエストは、前回のクエリ (デルタ更新) 以降に変更されたデータのみを受け取ります。リクエストは、バージョン管理された DynamoDB データソースに対してのみ行うことができます。  

```
import * as ddb from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const { limit = 10, nextToken, lastSync } = ctx.args;
	return ddb.sync({ limit, nextToken, lastSync });
}
```

**`update<T>(payload): DynamoDBUpdateItemRequest`**  
DynamoDB に [UpdateItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-updateitem) リクエストを行うための `DynamoDBUpdateItemRequest` オブジェクトを生成します。

### オペレーション
<a name="built-in-ddb-modules-operations"></a>

オペレーションヘルパーを使用すると、更新中にデータの一部に対して特定のアクションを実行できます。はじめに、`@aws-appsync/utils/dynamodb` から `operations` をインポートしてください。

```
// Modules are imported using operations
import {operations} from '@aws-appsync/utils/dynamodb';
```

#### オペレーションリスト
<a name="built-in-ddb-modules-operations-list"></a>

 **`add<T>(payload)`**  
DynamoDB を更新するときに新しい属性項目を追加するヘルパー関数。  
**例**  
ID 値を使用して既存の DynamoDB 項目に住所 (番地、市区町村、郵便番号) を追加するには  

```
import { update, operations } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const updateObj = {
		address: operations.add({
			street1: '123 Main St',
			city: 'New York',
			zip: '10001',
		}),
	};
	return update({ key: { id: 1 }, update: updateObj });
}
```

**`append <T>(payload)`**  
DynamoDB の既存のリストにペイロードを追加するヘルパー関数。  
**例**  
更新中に新しく追加されたフレンド ID (`newFriendIds`) を既存のフレンドリスト (`friendsIds`) に追加するには  

```
import { update, operations } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const newFriendIds = [101, 104, 111];
	const updateObj = {
		friendsIds: operations.append(newFriendIds),
	};
	return update({ key: { id: 1 }, update: updateObj });
}
```

**`decrement (by?)`**  
DynamoDB を更新するときに項目内の既存の属性値をデクリメントするヘルパー関数。  
**例**  
フレンドカウンター (`friendsCount`) を 10 ずつ減らすには  

```
import { update, operations } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const updateObj = {
		friendsCount: operations.decrement(10),
	};
	return update({ key: { id: 1 }, update: updateObj });
}
```

**`increment (by?)`**  
DynamoDB を更新するときに項目内の既存の属性値をインクリメントするヘルパー関数。  
**例**  
フレンドカウンター (`friendsCount`) を 10 ずつ増やすには:  

```
import { update, operations } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const updateObj = {
		friendsCount: operations.increment(10),
	};
	return update({ key: { id: 1 }, update: updateObj });
}
```

**`prepend <T>(payload)`**  
DynamoDB の既存のリストの前に追加するヘルパー関数。  
**例**  
更新時に、新しく追加されたフレンド ID (`newFriendIds`) を既存のフレンドリスト (`friendsIds`) の先頭に追加するには  

```
import { update, operations } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const newFriendIds = [101, 104, 111];
	const updateObj = {
		friendsIds: operations.prepend(newFriendIds),
	};
	return update({ key: { id: 1 }, update: updateObj });
}
```

**`replace <T>(payload)`**  
DynamoDB の項目を更新するときに既存の属性を置き換えるヘルパー関数。これは、ペイロードのキーだけでなく、属性のオブジェクトまたはサブオブジェクト全体を更新したい場合に便利です。  
**例**  
`info` オブジェクト内の住所 (番地、市区町村、郵便番号) を置き換えるには  

```
import { update, operations } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const updateObj = {
		info: {
			address: operations.replace({
				street1: '123 Main St',
				city: 'New York',
				zip: '10001',
			}),
		},
	};
	return update({ key: { id: 1 }, update: updateObj });
}
```

**`updateListItem <T>(payload, index)`**  
リスト内の項目を置き換えるヘルパー関数。  
**例**  
更新 (`newFriendIds`) のスコープで、この例では `friendsIds` を使用してリスト (`updateListItem`) の 2 番目の項目 (index: `1`、new ID:`102`) と 3 番目の項目 (index: `2`、new ID:`112`) の ID 値を更新しました。  

```
import { update, operations as ops } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const newFriendIds = [
		ops.updateListItem('102', 1), ops.updateListItem('112', 2)
	];
	const updateObj = { friendsIds: newFriendIds };
	return update({ key: { id: 1 }, update: updateObj });
}
```

### 入力
<a name="built-in-ddb-modules-inputs"></a>

#### 入力リスト
<a name="built-in-ddb-modules-inputs-list"></a>

 **`Type GetInput<T>`**  

```
GetInput<T>: { 
    consistentRead?: boolean; 
    key: DynamoDBKey<T>; 
}
```
**タイプ宣言**  
+ `consistentRead?: boolean` (オプション)

  DynamoDB で強力な整合性のある読み込みを実行するかどうかを指定するオプションのブール値。
+ `key: DynamoDBKey<T>` (必須)

  DynamoDB の項目のキーを指定する必須パラメータ。DynamoDB の項目には、単一のハッシュキーとソートキーが含まれています。

**`Type PutInput<T>`**  

```
PutInput<T>: { 
    _version?: number; 
    condition?: DynamoDBFilterObject<T> | null; 
    customPartitionKey?: string; 
    item: Partial<T>; 
    key: DynamoDBKey<T>; 
    populateIndexFields?: boolean; 
}
```
**タイプ宣言**  
+ `_version?: number` (オプション)
+ `condition?: DynamoDBFilterObject<T> | null` (オプション)

  DynamoDB テーブルにオブジェクトを格納する際、オプションで条件式を指定することができます。この条件式は、操作を実行する前にすでに DynamoDB に格納されているオブジェクトの状態に基づいて、リクエストを成功させるかどうかを制御します。
+ `customPartitionKey?: string` (オプション)

  有効にすると、この文字列値によって、バージョニングが有効になっているときにデルタ同期テーブルが使用する `ds_sk` および `ds_pk` レコードの形式が変更されます。有効にすると、`populateIndexFields` エントリの処理も有効になります。
+ `item: Partial<T>` (必須)

  DynamoDB に配置される項目の残りの属性です。
+ `key: DynamoDBKey<T>` (必須)

  Put が実行される DynamoDB 内の項目のキーを指定する必須パラメータ。DynamoDB の項目には、単一のハッシュキーとソートキーが含まれています。
+ `populateIndexFields?: boolean` (オプション)

  ブール値で、`customPartitionKey` と一緒に有効にすると、差分同期テーブル、具体的には `gsi_ds_pk` と `gsi_ds_sk` 列のレコードごとに新しいエントリが作成されます。詳細については、**「AWS AppSync デベロッパーガイド」の「[構成項目の配信](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html)」を参照してください。

**`Type QueryInput<T>`**  

```
QueryInput<T>: ScanInput<T> & { 
    query: DynamoDBKeyCondition<Required<T>>; 
}
```
**タイプ宣言**  
+ `query: DynamoDBKeyCondition<Required<T>>` (必須)

  クエリする項目を記述するキー条件を指定します。特定のインデックスでは、パーティションキーの条件は等しく、ソートキーは比較または `beginsWith` (文字列の場合) でなければなりません。パーティションキーとソートキーでは、数値型と文字列型のみがサポートされています。

  **例**

  以下の `User` タイプを考えてみてください。

  ```
  type User = {
    id: string;
    name: string;
    age: number;
    isVerified: boolean;
    friendsIds: string[] 
  }
  ```

  このクエリには`id`、`name`、`age` のフィールドのみを含めることができます。

  ```
  const query: QueryInput<User> = {
      name: { eq: 'John' },
      age: { gt: 20 },
  }
  ```

**`Type RemoveInput<T>`**  

```
RemoveInput<T>: { 
    _version?: number; 
    condition?: DynamoDBFilterObject<T>; 
    customPartitionKey?: string; 
    key: DynamoDBKey<T>; 
    populateIndexFields?: boolean; 
}
```
**タイプ宣言**  
+ `_version?: number` (オプション)
+ `condition?: DynamoDBFilterObject<T>` (オプション)

  DynamoDB テーブルにオブジェクトを格納する際、オプションで条件式を指定することができます。この条件式は、操作を実行する前にすでに DynamoDB に格納されているオブジェクトの状態に基づいて、リクエストを成功させるかどうかを制御します。

  **例**

  次の例は、ドキュメントの所有者がリクエストを行ったユーザーと一致する場合にのみ操作が成功することを許可する条件を含む `DeleteItem` 式です。

  ```
  type Task = {
    id: string;
    title: string;
    description: string;
    owner: string;
    isComplete: boolean;
  }
  const condition: DynamoDBFilterObject<Task> = {
    owner: { eq: 'XXXXXXXXXXXXXXXX' },
  }
  
  remove<Task>({
     key: {
       id: 'XXXXXXXXXXXXXXXX',
    },
    condition,
  });
  ```
+ `customPartitionKey?: string` (オプション)

  有効にすると、`customPartitionKey` 値によって、バージョニングが有効になっているときにデルタ同期テーブルが使用する `ds_sk` および `ds_pk` レコードの形式が変更されます。有効にすると、`populateIndexFields` エントリの処理も有効になります。
+ `key: DynamoDBKey<T>` (必須)

  削除する DynamoDB 内の項目のキーを指定する必須パラメータ。DynamoDB の項目には、単一のハッシュキーとソートキーが含まれています。

  **例**

  `User` がユーザー `id` のハッシュキーしか持っていない場合、キーは次のようになります。

  ```
  type User = {
  	id: number
  	name: string
  	age: number
  	isVerified: boolean
  }
  const key: DynamoDBKey<User> = {
  	id: 1,
  }
  ```

  テーブルユーザーがハッシュキー (`id`) とソートキー (`name`) を持っている場合、キーは以下のようになります。

  ```
  type User = {
  	id: number
  	name: string
  	age: number
  	isVerified: boolean
  	friendsIds: string[]
  }
  
  const key: DynamoDBKey<User> = {
  	id: 1,
  	name: 'XXXXXXXXXX',
  }
  ```
+ `populateIndexFields?: boolean` (オプション)

  ブール値で、`customPartitionKey` と一緒に有効にすると、差分同期テーブル、具体的には `gsi_ds_pk` と `gsi_ds_sk` 列のレコードごとに新しいエントリが作成されます。

**`Type ScanInput<T>`**  

```
ScanInput<T>: { 
    consistentRead?: boolean | null; 
    filter?: DynamoDBFilterObject<T> | null; 
    index?: string | null; 
    limit?: number | null; 
    nextToken?: string | null; 
    scanIndexForward?: boolean | null; 
    segment?: number; 
    select?: DynamoDBSelectAttributes; 
    totalSegments?: number; 
}
```
**タイプ宣言**  
+ `consistentRead?: boolean | null` (オプション)

  DynamoDB のクエリ時に一貫性のあるリードを示すオプションのブール値。デフォルト値は `false` です。
+ `filter?: DynamoDBFilterObject<T> | null` (オプション)

  テーブルから結果を取得した後に結果に適用するオプションのフィルター。
+ `index?: string | null` (オプション)

  スキャンするインデックスの名前。
+ `limit?: number | null` (オプション)

  返される結果の最大数。
+ `nextToken?: string | null` (オプション)

  前のクエリを継続するためのオプションのページ分割トークンです。これは前のクエリから取得されます。
+ `scanIndexForward?: boolean | null` (オプション)

  クエリを昇順にするか、降順にするかを示すオプションのブール値。デフォルトではこの値は `true` に設定されます。
+ `segment?: number` (オプション)
+ `select?: DynamoDBSelectAttributes` (オプション)

  DynamoDB から返される属性。デフォルトでは、 AWS AppSync DynamoDB リゾルバーはインデックスに射影された属性のみを返します。サポートされている値には以下があります。
  + `ALL_ATTRIBUTES`

    指定されたテーブルまたはインデックスのすべての項目の属性を返します。ローカルセカンダリインデックスに対してクエリを実行する場合、DynamoDB は、親のテーブルからインデックスの項目に一致したすべての項目をフェッチします。インデックスがすべての項目の属性を射影するように設定されている場合、すべてのデータはローカルセカンダリインデックスから取得されるため、フェッチは必要ありません。
  + `ALL_PROJECTED_ATTRIBUTES`

    インデックスにプロジェクションされたすべての属性を取得します。インデックスがすべての属性を投射するように設定されている場合、この返り値は `ALL_ATTRIBUTES` を指定した場合と同等になります。
  + `SPECIFIC_ATTRIBUTES`

    `ProjectionExpression` にリストされている属性のみを返します。この戻り値は、`AttributesToGet` の値を指定せずに `ProjectionExpression` を指定することと同じです。
+ `totalSegments?: number` (オプション)

**`Type DynamoDBSyncInput<T>`**  

```
DynamoDBSyncInput<T>: { 
    basePartitionKey?: string; 
    deltaIndexName?: string; 
    filter?: DynamoDBFilterObject<T> | null; 
    lastSync?: number; 
    limit?: number | null; 
    nextToken?: string | null; 
}
```
**タイプ宣言**  
+ `basePartitionKey?: string` (オプション)

  Sync 操作を実行するときに使用するベーステーブルのパーティションキー。このフィールドにより、テーブルがカスタムパーティションキーを使用している場合に Sync 操作を実行できます。
+ `deltaIndexName?: string` (オプション)

  Sync 操作に使用されるインデックス。このインデックスは、テーブルがカスタムパーティションキーを使用する場合に、デルタストアテーブル全体で Sync 操作を有効にするために必要です。Sync オペレーションは GSI (`gsi_ds_pk` と `gsi_ds_sk` で作成) で実行されます。
+ `filter?: DynamoDBFilterObject<T> | null` (オプション)

  テーブルから結果を取得した後に結果に適用するオプションのフィルター。
+ `lastSync?: number` (オプション)

  最後に成功した Sync オペレーションが開始されたエポックミリ秒単位の時刻。指定すると、`lastSync` 以降に変更された項目のみが返されます。このフィールドはオプションです。最初の Sync オペレーションからすべてのページを取得した後にのみ入力する必要があります。省略すると、ベーステーブルの結果が返されます。それ以外の場合は、差分テーブルの結果が返されます。
+ `limit?: number | null` (オプション)

  一度に評価する項目の最大数です。省略した場合、デフォルトの制限は `100` 項目に設定されます。このフィールドの最大値は `1000` 項目です。
+ `nextToken?: string | null` (オプション)

**`Type DynamoDBUpdateInput<T>`**  

```
DynamoDBUpdateInput<T>: { 
    _version?: number; 
    condition?: DynamoDBFilterObject<T>; 
    customPartitionKey?: string; 
    key: DynamoDBKey<T>; 
    populateIndexFields?: boolean; 
    update: DynamoDBUpdateObject<T>; 
}
```
**タイプ宣言**  
+ `_version?: number` (オプション)
+ `condition?: DynamoDBFilterObject<T>` (オプション)

  DynamoDB でオブジェクトを更新する場合、オプションで条件式を指定することができます。この条件式は、操作を実行する前にすでに DynamoDB にあるオブジェクトの状態に基づいて、リクエストを成功させるかどうかを制御します。
+ `customPartitionKey?: string` (オプション)

  有効にすると、`customPartitionKey` 値によって、バージョニングが有効になっているときにデルタ同期テーブルが使用する `ds_sk` および `ds_pk` レコードの形式が変更されます。有効にすると、`populateIndexFields` エントリの処理も有効になります。
+ `key: DynamoDBKey<T>` (必須)

  更新中の DynamoDB 内の項目のキーを指定する必須パラメータ。DynamoDB の項目には、単一のハッシュキーとソートキーが含まれています。
+ `populateIndexFields?: boolean` (オプション)

  ブール値で、`customPartitionKey` と一緒に有効にすると、差分同期テーブル、具体的には `gsi_ds_pk` と `gsi_ds_sk` 列のレコードごとに新しいエントリが作成されます。
+ `update: DynamoDBUpdateObject<T>`

  更新する属性とその新しい値を指定するオブジェクト。更新オブジェクトは `add`、`remove`、`replace`、`increment`、`decrement`、`append`、`prepend`、`updateListItem` と共に使用できます。

## Amazon RDS モジュール関数
<a name="built-in-rds-modules"></a>

Amazon RDS モジュール関数を使用すると、Amazon RDS Data API で設定されたデータベースを操作する際のエクスペリエンスが向上します。モジュールは `@aws-appsync/utils/rds` を使用してインポートされます。

```
import * as rds from '@aws-appsync/utils/rds';
```

関数は個別にインポートすることもできます。例えば、以下のインポートでは `sql` を使用します。

```
import { sql } from '@aws-appsync/utils/rds';
```

### 関数
<a name="built-in-rds-modules-functions"></a>

 AWS AppSync RDS モジュールのユーティリティヘルパーを使用して、データベースとやり取りできます。

#### Select
<a name="built-in-rds-modules-functions-select"></a>

`select` ユーティリティは、リレーショナルデータベースにクエリを実行する `SELECT` ステートメントを作成します。

**基本的な使用法**

基本的な形式では、クエリを実行するテーブルを指定できます。

```
import { select, createPgStatement } from '@aws-appsync/utils/rds';

export function request(ctx) {

    // Generates statement: 
    // "SELECT * FROM "persons"
    return createPgStatement(select({table: 'persons'}));
}
```

なお、テーブル識別子でスキーマを指定することもできます。

```
import { select, createPgStatement } from '@aws-appsync/utils/rds';

export function request(ctx) {

    // Generates statement:
    // SELECT * FROM "private"."persons"
    return createPgStatement(select({table: 'private.persons'}));
}
```

**列の指定**

`columns` プロパティで列を指定できます。これを値に設定しない場合、デフォルトでは `*` になります。

```
export function request(ctx) {

    // Generates statement:
    // SELECT "id", "name"
    // FROM "persons"
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'name']
    }));
}
```

また、列のテーブルも指定できます。

```
export function request(ctx) {

    // Generates statement: 
    // SELECT "id", "persons"."name"
    // FROM "persons"
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'persons.name']
    }));
}
```

**LIMIT と OFFSET**

`limit` と `offset` をクエリに適用できます。

```
export function request(ctx) {

    // Generates statement: 
    // SELECT "id", "name"
    // FROM "persons"
    // LIMIT :limit
    // OFFSET :offset
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'name'],
        limit: 10,
        offset: 40
    }));
}
```

**ORDER BY**

結果は `orderBy` プロパティを使用してソートできます。列とオプションの `dir` プロパティを指定するオブジェクトの配列を指定します。

```
export function request(ctx) {

    // Generates statement: 
    // SELECT "id", "name" FROM "persons"
    // ORDER BY "name", "id" DESC
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'name'],
        orderBy: [{column: 'name'}, {column: 'id', dir: 'DESC'}]
    }));
}
```

**フィルター**

特殊条件オブジェクトを使用してフィルターを構築できます。

```
export function request(ctx) {

    // Generates statement:
    // SELECT "id", "name"
    // FROM "persons"
    // WHERE "name" = :NAME
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'name'],
        where: {name: {eq: 'Stephane'}}
    }));
}
```

以下のフィルターを組み合わせることもできます。

```
export function request(ctx) {

    // Generates statement:
    // SELECT "id", "name"
    // FROM "persons"
    // WHERE "name" = :NAME and "id" > :ID
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'name'],
        where: {name: {eq: 'Stephane'}, id: {gt: 10}}
    }));
}
```

また、`OR` ステートメントも作成できます。

```
export function request(ctx) {

    // Generates statement:
    // SELECT "id", "name"
    // FROM "persons"
    // WHERE "name" = :NAME OR "id" > :ID
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'name'],
        where: { or: [
            { name: { eq: 'Stephane'} },
            { id: { gt: 10 } }
        ]}
    }));
}
```

`not` を使用して条件を無効にすることもできます。

```
export function request(ctx) {

    // Generates statement:
    // SELECT "id", "name"
    // FROM "persons"
    // WHERE NOT ("name" = :NAME AND "id" > :ID)
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'name'],
        where: { not: [
            { name: { eq: 'Stephane'} },
            { id: { gt: 10 } }
        ]}
    }));
}
```

以下の演算子を使用して、値を比較することもできます。


| 
| 
| 演算子 | 説明 | 可能な値型 | 
| --- |--- |--- |
| eq | Equal | number, string, boolean | 
| ne | Not equal | number, string, boolean | 
| le | Less than or equal | number, string | 
| lt | Less than | number, string | 
| ge | Greater than or equal | number, string | 
| gt | Greater than | number, string | 
| contains | Like | string | 
| notContains | Not like | string | 
| beginsWith | Starts with prefix | string | 
| between | Between two values | number, string | 
| attributeExists | The attribute is not null | number, string, boolean | 
| size | checks the length of the element | string | 

#### Insert
<a name="built-in-rds-modules-functions-insert"></a>

`insert` ユーティリティによって、`INSERT` オペレーションを使用してデータベースに単一行の項目を簡単に挿入できます。

**単一項目の挿入**

項目を挿入するには、テーブルを指定して、値のオブジェクトを渡します。オブジェクトキーはテーブルの列にマッピングされます。列名は自動的にエスケープされ、値は変数マップを使用してデータベースに送信されます。

```
import { insert, createMySQLStatement } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const { input: values } = ctx.args;
    const insertStatement = insert({ table: 'persons', values });
    
    // Generates statement:
    // INSERT INTO `persons`(`name`)
    // VALUES(:NAME)
    return createMySQLStatement(insertStatement)
}
```

**MySQL ユースケース**

`insert` の後に `select` を組み合わせて、挿入した行を取得できます。

```
import { insert, select, createMySQLStatement } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const { input: values } = ctx.args;
    const insertStatement = insert({  table: 'persons', values });
    const selectStatement = select({
        table: 'persons',
        columns: '*',
        where: { id: { eq: values.id } },
        limit: 1,
    });
    
    // Generates statement:
    // INSERT INTO `persons`(`name`)
    // VALUES(:NAME)
    // and
    // SELECT *
    // FROM `persons`
    // WHERE `id` = :ID
    return createMySQLStatement(insertStatement, selectStatement)
}
```

**Postgres のユースケース**

Postgres では、[https://www.postgresql.org/docs/current/dml-returning.html](https://www.postgresql.org/docs/current/dml-returning.html) を使用して、挿入した行からデータを取得できます。`*` または列名の配列が受け入れられます。

```
import { insert, createPgStatement } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const { input: values } = ctx.args;
    const insertStatement = insert({
        table: 'persons',
        values,
        returning: '*'
    });

    // Generates statement:
    // INSERT INTO "persons"("name")
    // VALUES(:NAME)
    // RETURNING *
    return createPgStatement(insertStatement)
}
```

#### 更新
<a name="built-in-rds-modules-functions-update"></a>

`update` ユーティリティでは、既存の行を更新できます。条件オブジェクトを使用すると、条件を満たすすべての行の指定された列に変更を適用できます。例えば、このミューテーションを可能にするスキーマがあるとします。`Person` の `name` を `3` の `id` 値で更新したいのですが、これは `2000` 年以降にそれら (`known_since`) がわかっている場合に限ります。

```
mutation Update {
    updatePerson(
        input: {id: 3, name: "Jon"},
        condition: {known_since: {ge: "2000"}}
    ) {
    id
    name
  }
}
```

更新リゾルバーは以下のようになります。

```
import { update, createPgStatement } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const { input: { id, ...values }, condition } = ctx.args;
    const where = {
        ...condition,
        id: { eq: id },
    };
    const updateStatement = update({
        table: 'persons',
        values,
        where,
        returning: ['id', 'name'],
    });

    // Generates statement:
    // UPDATE "persons"
    // SET "name" = :NAME, "birthday" = :BDAY, "country" = :COUNTRY
    // WHERE "id" = :ID
    // RETURNING "id", "name"
    return createPgStatement(updateStatement)
}
```

条件にチェックを追加して、`3` と等しいプライマリキー `id` を持つ行だけが更新されるようにすることができます。同様に、Postgres `inserts` の場合も、`returning` を使用して変更されたデータを返すことができます。

#### 削除
<a name="built-in-rds-modules-functions-remove"></a>

`remove` ユーティリティでは、既存の行を削除できます。条件オブジェクトは、条件を満たすすべての行で使用できます。なお、`delete` はJavaScriptの予約キーワードです。代わりに `remove` を使ってください。

```
import { remove, createPgStatement } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const { input: { id }, condition } = ctx.args;
    const where = { ...condition, id: { eq: id } };
    const deleteStatement = remove({
        table: 'persons',
        where,
        returning: ['id', 'name'],
    });

    // Generates statement:
    // DELETE "persons"
    // WHERE "id" = :ID
    // RETURNING "id", "name"
    return createPgStatement(updateStatement)
}
```

### キャスティング
<a name="built-in-rds-modules-casting"></a>

ステートメントで使用する正しいオブジェクト型に関して、さらに特異度が必要となる場合もあるでしょう。指定された型ヒントを使用してパラメータのタイプを指定できます。 は Data API [と同じ型ヒント](https://docs.aws.amazon.com//rdsdataservice/latest/APIReference/API_SqlParameter.html#rdsdtataservice-Type-SqlParameter-typeHint) AWS AppSync をサポートします。モジュールの `typeHint`関数を使用してパラメータを AWS AppSync `rds`キャストできます。

次の例では、JSON オブジェクトとしてキャストされた値として配列を送信できます。`->` 演算子を使用して JSON 配列内にある `index` `2` の要素を取得します。

```
import { sql, createPgStatement, toJsonObject, typeHint } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const arr = ctx.args.list_of_ids
    const statement = sql`select ${typeHint.JSON(arr)}->2 as value`
    return createPgStatement(statement)
}

export function response(ctx) {
    return toJsonObject(ctx.result)[0][0].value
}
```

キャスティングは、`DATE`、`TIME`、`TIMESTAMP` の処理や比較を行うときにも役立ちます。

```
import { select, createPgStatement, typeHint } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const when = ctx.args.when
    const statement = select({
        table: 'persons',
        where: { createdAt : { gt: typeHint.DATETIME(when) } }
    })
    return createPgStatement(statement)
}
```

現在の日付と時刻を送信する方法について別の例を以下に示します。

```
import { sql, createPgStatement, typeHint } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const now = util.time.nowFormatted('YYYY-MM-dd HH:mm:ss')
    return createPgStatement(sql`select ${typeHint.TIMESTAMP(now)}`)
}
```

**使用可能な型ヒント**
+ `typeHint.DATE` - 対応するパラメータが、`DATE` 型のオブジェクトとしてデータベースに送信されます。受け入れられる形式は `YYYY-MM-DD` です。
+ `typeHint.DECIMAL` - 対応するパラメータが、`DECIMAL` 型のオブジェクトとしてデータベースに送信されます。
+ `typeHint.JSON` - 対応するパラメータが、`JSON` 型のオブジェクトとしてデータベースに送信されます。
+ `typeHint.TIME` - 対応する文字列パラメータ値が、`TIME` 型のオブジェクトとしてデータベースに送信されます。受け入れられる形式は `HH:MM:SS[.FFF]` です。
+ `typeHint.TIMESTAMP` - 対応する文字列パラメータ値が、`TIMESTAMP` 型のオブジェクトとしてデータベースに送信されます。受け入れられる形式は `YYYY-MM-DD HH:MM:SS[.FFF]` です。
+ `typeHint.UUID` - 対応する文字列パラメータ値が、`UUID` 型のオブジェクトとしてデータベースに送信されます。