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

# 기본 제공 모듈
<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)를 참조하세요.
`DynamoDBGetItemRequest` 객체를 생성하여 DynamoDB에 [GetItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-getitem) 요청을 보냅니다.  

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

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

 **`put<T>(payload): DynamoDBPutItemRequest`**  
`DynamoDBPutItemRequest` 객체를 생성하여 DynamoDB에 [PutItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem) 요청을 보냅니다.  

```
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`**  
`DynamoDBDeleteItemRequest` 객체를 생성하여 DynamoDB에 [DeleteItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-deleteitem) 요청을 보냅니다.  

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

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

**`scan<T>(payload): DynamoDBScanRequest`**  
`DynamoDBScanRequest`를 생성하여 DynamoDB에 [Scan](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan) 요청을 보냅니다.  

```
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`**  
`DynamoDBSyncRequest` 객체를 생성하여 [Sync](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-sync) 요청을 보냅니다. 요청은 마지막 쿼리(델타 업데이트) 이후 변경된 데이터만 수신합니다. 버전이 지정된 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`**  
`DynamoDBUpdateItemRequest` 객체를 생성하여 DynamoDB에 [UpdateItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-updateitem) 요청을 보냅니다.

### 운영
<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에서 항목을 업데이트할 때 기존 속성을 대체하는 도우미 함수입니다. 이는 페이로드의 키뿐만 아니라 속성의 전체 객체 또는 하위 객체를 업데이트하려는 경우에 유용합니다.  
**예제**  
객체의 주소(도로명, 구/군/시, 우편번호)를 바꾸려면 다음을 수행하세요.  

```
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`) 범위에서, 이 예에서는 `updateListItem`을 사용하여 목록(`friendsIds`)에 있는 두 번째 항목(인덱스: `1`, 새 ID: `102`)과 세 번째 항목(인덱스: `2`, 새 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>`(필수)

  입력이 수행되는 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` (선택 사항)

  동기화 작업을 수행할 때 사용되는 기본 테이블의 파티션 키입니다. 이 필드를 사용하면 테이블에서 사용자 지정 파티션 키를 활용할 때 동기화 작업을 수행할 수 있습니다.
+ `deltaIndexName?: string` (선택 사항)

  동기화 작업에 사용되는 인덱스입니다. 이 인덱스는 테이블에서 사용자 지정 파티션 키를 사용할 때 전체 델타 저장소 테이블에서 동기화 작업을 활성화하는 데 필요합니다. 동기화 작업은 GSI(`gsi_ds_pk` 및 `gsi_ds_sk`에서 생성)에서 수행됩니다.
+ `filter?: DynamoDBFilterObject<T> | null` (선택 사항)

  테이블에서 결과를 검색한 후 결과에 적용할 선택적 필터입니다.
+ `lastSync?: number` (선택 사항)

  마지막으로 성공한 동기화 작업이 시작되었던 시간(epoch 밀리초)입니다. 지정된 경우, `lastSync` 이후에 변경된 항목만 반환됩니다. 이 필드는 초기 동기화 작업에서 모든 페이지를 가져온 이후에만 채워져야 합니다. 생략하면 기본 테이블의 결과가 반환됩니다. 그렇지 않으면 델타 테이블의 결과가 반환됩니다.
+ `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 데이터 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`을 적용할 수 있습니다.

```
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
    }));
}
```

**순서 기준**

`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 사용 사례**

`select`가 뒤따르는 `insert`를 결합하여 삽입된 행을 검색할 수 있습니다.

```
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` 유틸리티를 사용하여 기존 행을 업데이트할 수 있습니다. 조건 객체를 사용하여 조건을 충족하는 모든 행의 지정된 열에 변경 내용을 적용할 수 있습니다. 예를 들어 이러한 변형을 만들 수 있는 스키마가 있다고 가정해 보겠습니다. 해당 `2000` 연도부터 인식(`known_since`)하게 된 경우에만 `Person`의`name`을 `3`의 `id` 값으로 업데이트하려고 합니다.

```
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>

올바른 객체 유형을 더 구체적으로 지정하여 문에 사용하려는 경우가 있을 수 있습니다. 제공된 유형 힌트를 사용하여 파라미터 유형을 지정할 수 있습니다.는 데이터 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` 유형의 객체로 데이터베이스에 전송됩니다.