Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Moduli incorporati I moduli fanno parte del `APPSYNC_JS` runtime e forniscono utilità per aiutare a scrivere JavaScript resolver e funzioni. Per esempi ed esempi, consultate il repository. [aws-appsync-resolver-samples](https://github.com/aws-samples/aws-appsync-resolver-samples) GitHub ## Funzioni del modulo DynamoDB Le funzioni del modulo DynamoDB offrono un'esperienza migliorata durante l'interazione con le fonti di dati DynamoDB. È possibile effettuare richieste verso le sorgenti dati DynamoDB utilizzando le funzioni e senza aggiungere la mappatura dei tipi. I moduli vengono importati utilizzando: `@aws-appsync/utils/dynamodb` ``` // Modules are imported using @aws-appsync/utils/dynamodb import * as ddb from '@aws-appsync/utils/dynamodb'; ``` ### Funzioni #### Elenco delle funzioni **` get(payload: GetInput): DynamoDBGetItemRequest`** [Input](#built-in-ddb-modules-inputs)Per informazioni su, vedere GetInput. Genera un `DynamoDBGetItemRequest` oggetto per effettuare una [GetItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-getitem)richiesta a DynamoDB. ``` import { get } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { return get({ key: { id: ctx.args.id } }); } ``` **`put(payload): DynamoDBPutItemRequest`** Genera un `DynamoDBPutItemRequest` oggetto per effettuare una [PutItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem)richiesta a DynamoDB. ``` import * as ddb from '@aws-appsync/utils/dynamodb' export function request(ctx) { return ddb.put({ key: { id: util.autoId() }, item: ctx.args }); } ``` **`remove(payload): DynamoDBDeleteItemRequest`** Genera un `DynamoDBDeleteItemRequest` oggetto per effettuare una [DeleteItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-deleteitem)richiesta a DynamoDB. ``` import * as ddb from '@aws-appsync/utils/dynamodb'; export function request(ctx) { return ddb.remove({ key: { id: ctx.args.id } }); } ``` **`scan(payload): DynamoDBScanRequest`** Genera una richiesta `DynamoDBScanRequest` di [scansione](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan) per DynamoDB. ``` import * as ddb from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const { limit = 10, nextToken } = ctx.args; return ddb.scan({ limit, nextToken }); } ``` **`sync(payload): DynamoDBSyncRequest`** Genera un `DynamoDBSyncRequest` oggetto per effettuare una richiesta di [sincronizzazione](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-sync). La richiesta riceve solo i dati modificati dall'ultima query (delta updates). Le richieste possono essere effettuate solo a sorgenti dati DynamoDB con versione. ``` 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(payload): DynamoDBUpdateItemRequest`** Genera un `DynamoDBUpdateItemRequest` oggetto per effettuare una [UpdateItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-updateitem)richiesta a DynamoDB. ### Operazioni Gli assistenti operativi consentono di eseguire azioni specifiche su parti dei dati durante gli aggiornamenti. Per iniziare, importa `operations` da`@aws-appsync/utils/dynamodb`: ``` // Modules are imported using operations import {operations} from '@aws-appsync/utils/dynamodb'; ``` #### Elenco delle operazioni **`add(payload)`** Una funzione di supporto che aggiunge un nuovo elemento di attributo durante l'aggiornamento di DynamoDB. **Esempio** Per aggiungere un indirizzo (via, città e codice postale) a un elemento DynamoDB esistente utilizzando il valore ID: ``` 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 (payload)`** Una funzione di supporto che aggiunge un payload all'elenco esistente in DynamoDB. **Esempio** Per aggiungere friend IDs (`newFriendIds`) appena aggiunto a una lista di amici esistente () durante un aggiornamento: `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?)`** Una funzione di supporto che decrementa il valore dell'attributo esistente nell'elemento durante l'aggiornamento di DynamoDB. **Esempio** Per diminuire di 10 il contatore di un amico (): `friendsCount` ``` 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?)`** Una funzione di supporto che incrementa il valore dell'attributo esistente nell'elemento durante l'aggiornamento di DynamoDB. **Esempio** Per incrementare il contatore di amici () di 10: `friendsCount` ``` 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 (payload)`** Una funzione di supporto che si aggiunge all'elenco esistente in DynamoDB. **Esempio** Per aggiungere friend IDs (`newFriendIds`) appena aggiunto a un elenco di amici esistente () durante un aggiornamento: `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 (payload)`** Una funzione di supporto che sostituisce un attributo esistente durante l'aggiornamento di un elemento in DynamoDB. È utile quando si desidera aggiornare l'intero oggetto o sottooggetto nell'attributo e non solo le chiavi nel payload. **Esempio** Per sostituire un indirizzo (via, città e codice postale) in un oggetto: `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 (payload, index)`** Una funzione di supporto che sostituisce un elemento in un elenco. **Esempio** Nell'ambito di update (`newFriendIds`), questo esempio veniva utilizzato `updateListItem` per aggiornare i valori ID del secondo elemento (index:`1`, new ID:`102`) e del terzo elemento (index:`2`, new ID:`112`) in un elenco (`friendsIds`). ``` 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 }); } ``` ### Input #### Elenco degli input **`Type GetInput`** ``` GetInput: { consistentRead?: boolean; key: DynamoDBKey; } ``` **Dichiarazione del tipo** + `consistentRead?: boolean` (facoltativo) Un booleano opzionale per specificare se si desidera eseguire una lettura fortemente coerente con DynamoDB. + `key: DynamoDBKey`(obbligatorio) Un parametro obbligatorio che specifica la chiave dell'elemento in DynamoDB. Gli elementi DynamoDB possono avere una sola chiave hash o chiavi di hash e ordinamento. **`Type PutInput`** ``` PutInput: { _version?: number; condition?: DynamoDBFilterObject | null; customPartitionKey?: string; item: Partial; key: DynamoDBKey; populateIndexFields?: boolean; } ``` **Dichiarazione del tipo** + `_version?: number` (facoltativo) + `condition?: DynamoDBFilterObject | null` (facoltativo) Quando si inserisce un oggetto in una tabella DynamoDB, è possibile specificare facoltativamente un'espressione condizionale che controlli se la richiesta deve avere esito positivo o meno in base allo stato dell'oggetto già in DynamoDB prima dell'esecuzione dell'operazione. + `customPartitionKey?: string` (facoltativo) Se abilitato, questo valore di stringa modifica il formato dei `ds_pk` record `ds_sk` and utilizzati dalla tabella delta sync quando il controllo delle versioni è abilitato. Se abilitata, è abilitata anche l'elaborazione della `populateIndexFields` voce. + `item: Partial`(richiesto) Il resto degli attributi dell'elemento da inserire in DynamoDB. + `key: DynamoDBKey`(richiesto) Un parametro obbligatorio che specifica la chiave dell'elemento in DynamoDB su cui verrà eseguito il put. Gli elementi DynamoDB possono avere una sola chiave hash o chiavi di hash e ordinamento. + `populateIndexFields?: boolean` (facoltativo) Un valore booleano che, se abilitato insieme a`customPartitionKey`, crea nuove voci per ogni record nella tabella delta sync, in particolare nelle colonne and. `gsi_ds_pk` `gsi_ds_sk` Per ulteriori informazioni, consulta [Rilevamento e sincronizzazione dei conflitti](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) nella Guida per gli *AWS AppSync sviluppatori*. **`Type QueryInput`** ``` QueryInput: ScanInput & { query: DynamoDBKeyCondition>; } ``` **Dichiarazione del tipo** + `query: DynamoDBKeyCondition>`(richiesto) Specifica una condizione chiave che descrive gli elementi da interrogare. Per un determinato indice, la condizione per una chiave di partizione deve essere un'uguaglianza e la chiave di ordinamento un confronto o un `beginsWith` (quando è una stringa). Per le chiavi di partizione e ordinamento sono supportati solo i tipi di numeri e stringhe. **Esempio** Prendi il `User` tipo seguente: ``` type User = { id: string; name: string; age: number; isVerified: boolean; friendsIds: string[] } ``` La query può includere solo i seguenti campi: `id``name`, e`age`: ``` const query: QueryInput = { name: { eq: 'John' }, age: { gt: 20 }, } ``` **`Type RemoveInput`** ``` RemoveInput: { _version?: number; condition?: DynamoDBFilterObject; customPartitionKey?: string; key: DynamoDBKey; populateIndexFields?: boolean; } ``` **Dichiarazione di tipo** + `_version?: number` (facoltativo) + `condition?: DynamoDBFilterObject` (facoltativo) Quando rimuovi un oggetto in DynamoDB, puoi facoltativamente specificare un'espressione condizionale che controlli se la richiesta deve avere successo o meno in base allo stato dell'oggetto già in DynamoDB prima dell'esecuzione dell'operazione. **Esempio** L'esempio seguente è un'`DeleteItem`espressione contenente una condizione che consente l'esito positivo dell'operazione solo se il proprietario del documento corrisponde all'utente che effettua la richiesta. ``` type Task = { id: string; title: string; description: string; owner: string; isComplete: boolean; } const condition: DynamoDBFilterObject = { owner: { eq: 'XXXXXXXXXXXXXXXX' }, } remove({ key: { id: 'XXXXXXXXXXXXXXXX', }, condition, }); ``` + `customPartitionKey?: string` (facoltativo) Se abilitato, il `customPartitionKey` valore modifica il formato dei `ds_pk` record `ds_sk` and utilizzati dalla tabella delta sync quando il controllo delle versioni è abilitato. Se abilitata, è abilitata anche l'elaborazione della `populateIndexFields` voce. + `key: DynamoDBKey`(richiesto) Un parametro obbligatorio che specifica la chiave dell'elemento in DynamoDB che viene rimosso. Gli elementi DynamoDB possono avere una sola chiave hash o chiavi di hash e ordinamento. **Esempio** Se a ha la chiave hash `User` solo con un utente`id`, la chiave sarebbe simile a questa: ``` type User = { id: number name: string age: number isVerified: boolean } const key: DynamoDBKey = { id: 1, } ``` Se l'utente della tabella ha una chiave hash (`id`) e una chiave di ordinamento (`name`), la chiave sarebbe simile a questa: ``` type User = { id: number name: string age: number isVerified: boolean friendsIds: string[] } const key: DynamoDBKey = { id: 1, name: 'XXXXXXXXXX', } ``` + `populateIndexFields?: boolean` (facoltativo) Un valore booleano che, se abilitato insieme a`customPartitionKey`, crea nuove voci per ogni record nella tabella delta sync, in particolare nelle `gsi_ds_pk` colonne and. `gsi_ds_sk` **`Type ScanInput`** ``` ScanInput: { consistentRead?: boolean | null; filter?: DynamoDBFilterObject | null; index?: string | null; limit?: number | null; nextToken?: string | null; scanIndexForward?: boolean | null; segment?: number; select?: DynamoDBSelectAttributes; totalSegments?: number; } ``` **Dichiarazione del tipo** + `consistentRead?: boolean | null` (facoltativo) Un booleano opzionale per indicare letture coerenti quando si esegue una query su DynamoDB. Il valore predefinito è `false`. + `filter?: DynamoDBFilterObject | null` (facoltativo) Un filtro opzionale da applicare ai risultati dopo averlo recuperato dalla tabella. + `index?: string | null` (facoltativo) Un nome opzionale dell'indice da scansionare. + `limit?: number | null` (facoltativo) Un numero massimo opzionale di risultati da restituire. + `nextToken?: string | null` (facoltativo) Un token di impaginazione opzionale per continuare una query precedente. dalla quale deve essere ottenuto. + `scanIndexForward?: boolean | null` (facoltativo) Un booleano opzionale per indicare se la query viene eseguita in ordine crescente o decrescente. Per impostazione predefinita, questo valore è impostato su `true`. + `segment?: number` (facoltativo) + `select?: DynamoDBSelectAttributes` (facoltativo) Attributi da restituire da DynamoDB. Per impostazione predefinita, il AWS AppSync resolver DynamoDB restituisce solo gli attributi proiettati nell'indice. I valori supportati sono: + `ALL_ATTRIBUTES` Restituisce tutti gli attributi degli elementi dalla tabella o dall'indice specificato. Se si esegue una query su un indice secondario locale, DynamoDB recupera l'intero elemento dalla tabella principale per ogni elemento corrispondente nell'indice. Se l'indice è configurato per proiettare tutti gli attributi della voce, è possibile ottenere tutti i dati dall'indice secondario locale, senza necessità di recupero. + `ALL_PROJECTED_ATTRIBUTES` Restituisce tutti gli attributi che sono stati proiettati nell'indice. Se la configurazione dell'indice prevede che vi siano proiettati tutti gli attributi, il valore che restituisce è uguale a quello dato da `ALL_ATTRIBUTES`. + `SPECIFIC_ATTRIBUTES` Restituisce solo gli attributi elencati in`ProjectionExpression`. Questo valore restituito equivale a specificare `ProjectionExpression` senza specificare alcun valore per. `AttributesToGet` + `totalSegments?: number` (facoltativo) **`Type DynamoDBSyncInput`** ``` DynamoDBSyncInput: { basePartitionKey?: string; deltaIndexName?: string; filter?: DynamoDBFilterObject | null; lastSync?: number; limit?: number | null; nextToken?: string | null; } ``` **Dichiarazione del tipo** + `basePartitionKey?: string` (facoltativo) La chiave di partizione della tabella di base da utilizzare durante l'esecuzione di un'operazione di sincronizzazione. Questo campo consente di eseguire un'operazione di sincronizzazione quando la tabella utilizza una chiave di partizione personalizzata. + `deltaIndexName?: string` (facoltativo) L'indice utilizzato per l'operazione di sincronizzazione. Questo indice è necessario per abilitare un'operazione di sincronizzazione sull'intera tabella delta store quando la tabella utilizza una chiave di partizione personalizzata. L'operazione di sincronizzazione verrà eseguita sul GSI (creato su `gsi_ds_pk` and`gsi_ds_sk`). + `filter?: DynamoDBFilterObject | null` (facoltativo) Un filtro opzionale da applicare ai risultati dopo averlo recuperato dalla tabella. + `lastSync?: number` (facoltativo) Il momento, in millisecondi di epoca, in cui è iniziata l'ultima operazione di sincronizzazione riuscita. Se specificato, vengono restituiti solo gli elementi che sono stati modificati dopo `lastSync`. Questo campo deve essere compilato solo dopo aver recuperato tutte le pagine da un'operazione di sincronizzazione iniziale. Se omesso, verranno restituiti i risultati della tabella di base. In caso contrario, verranno restituiti i risultati della tabella delta. + `limit?: number | null` (facoltativo) Un numero massimo opzionale di elementi da valutare contemporaneamente. Se omesso, il limite predefinito sarà impostato su `100` elementi. Il valore massimo per questo campo è `1000` articoli. + `nextToken?: string | null` (facoltativo) **`Type DynamoDBUpdateInput`** ``` DynamoDBUpdateInput: { _version?: number; condition?: DynamoDBFilterObject; customPartitionKey?: string; key: DynamoDBKey; populateIndexFields?: boolean; update: DynamoDBUpdateObject; } ``` **Tipo di dichiarazione** + `_version?: number` (facoltativo) + `condition?: DynamoDBFilterObject` (facoltativo) Quando aggiorni un oggetto in DynamoDB, puoi facoltativamente specificare un'espressione condizionale che controlli se la richiesta deve avere successo o meno in base allo stato dell'oggetto già in DynamoDB prima dell'esecuzione dell'operazione. + `customPartitionKey?: string` (facoltativo) Se abilitato, il `customPartitionKey` valore modifica il formato dei `ds_pk` record `ds_sk` and utilizzati dalla tabella delta sync quando il controllo delle versioni è abilitato. Se abilitata, è abilitata anche l'elaborazione della `populateIndexFields` voce. + `key: DynamoDBKey`(richiesto) Un parametro obbligatorio che specifica la chiave dell'elemento in DynamoDB che viene aggiornato. Gli elementi DynamoDB possono avere una sola chiave hash o chiavi di hash e ordinamento. + `populateIndexFields?: boolean` (facoltativo) Un valore booleano che, se abilitato insieme a`customPartitionKey`, crea nuove voci per ogni record nella tabella delta sync, in particolare nelle colonne and. `gsi_ds_pk` `gsi_ds_sk` + `update: DynamoDBUpdateObject` Un oggetto che specifica gli attributi da aggiornare insieme ai relativi nuovi valori. L'oggetto di aggiornamento può essere utilizzato con`add`,`remove`,`replace`,`increment`,`decrement`, `append``prepend`,`updateListItem`. ## Funzioni del modulo Amazon RDS Le funzioni del modulo Amazon RDS offrono un'esperienza migliorata durante l'interazione con i database configurati con l'API Amazon RDS Data. Il modulo viene importato utilizzando: `@aws-appsync/utils/rds` ``` import * as rds from '@aws-appsync/utils/rds'; ``` Le funzioni possono essere importate anche singolarmente. Ad esempio, l'importazione seguente utilizza`sql`: ``` import { sql } from '@aws-appsync/utils/rds'; ``` ### Funzioni È possibile utilizzare gli assistenti di utilità del modulo AWS AppSync RDS per interagire con il database. #### Select L'`select`utilità crea un'`SELECT`istruzione per interrogare il database relazionale. **Uso di base** Nella sua forma base, puoi specificare la tabella su cui vuoi interrogare: ``` import { select, createPgStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { // Generates statement: // "SELECT * FROM "persons" return createPgStatement(select({table: 'persons'})); } ``` Nota che puoi anche specificare lo schema nell'identificatore della tabella: ``` import { select, createPgStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { // Generates statement: // SELECT * FROM "private"."persons" return createPgStatement(select({table: 'private.persons'})); } ``` **Specificare le colonne** È possibile specificare le colonne con la `columns` proprietà. Se non è impostato su un valore, il valore predefinito è: `*` ``` export function request(ctx) { // Generates statement: // SELECT "id", "name" // FROM "persons" return createPgStatement(select({ table: 'persons', columns: ['id', 'name'] })); } ``` Puoi anche specificare la tabella di una colonna: ``` export function request(ctx) { // Generates statement: // SELECT "id", "persons"."name" // FROM "persons" return createPgStatement(select({ table: 'persons', columns: ['id', 'persons.name'] })); } ``` **Limiti e offset** È possibile applicare `limit` e `offset` alla query: ``` 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 })); } ``` **Ordina per** Puoi ordinare i risultati in base alla `orderBy` proprietà. Fornisci una matrice di oggetti che specificano la colonna e una `dir` proprietà opzionale: ``` 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'}] })); } ``` **Filtri** È possibile creare filtri utilizzando l'oggetto di condizione speciale: ``` 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'}} })); } ``` Puoi anche combinare filtri: ``` 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}} })); } ``` Puoi anche creare `OR` dichiarazioni: ``` 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 } } ]} })); } ``` Puoi anche annullare una condizione con`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 } } ]} })); } ``` È inoltre possibile utilizzare i seguenti operatori per confrontare i valori: | | | Operatore | Description | Tipi di valori possibili | | --- |--- |--- | | eq | Uguale | numero, stringa, booleano | | uno | Non uguale | numero, stringa, booleano | | le | Minore di o uguale a | numero, stringa | | lt | Less than | numero, stringa | | età | Maggiore di o uguale a | numero, stringa | | gt | Greater than | numero, stringa | | contiene | Piace | stringa | | Non contiene | Non come | stringa | | Inizia con | Inizia con il prefisso | stringa | | tra | Tra due valori | numero, stringa | | L'attributo esiste | L'attributo non è nullo | numero, stringa, booleano | | formato | controlla la lunghezza dell'elemento | stringa | #### Insert L'`insert`utilità fornisce un modo semplice per inserire elementi a riga singola nel database con l'operazione. `INSERT` **Inserimenti di singoli elementi** Per inserire un elemento, specifica la tabella e poi inserisci i valori dell'oggetto. Le chiavi degli oggetti vengono mappate alle colonne della tabella. I nomi delle colonne vengono espulsi automaticamente e i valori vengono inviati al database utilizzando la mappa variabile: ``` 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) } ``` **Caso d'uso MySQL** Puoi combinare un `insert` seguito da a per `select` recuperare la riga inserita: ``` 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) } ``` **Caso d'uso Postgres** Con Postgres, è possibile utilizzare [https://www.postgresql.org/docs/current/dml-returning.html](https://www.postgresql.org/docs/current/dml-returning.html)per ottenere dati dalla riga inserita. Accetta `*` o una matrice di nomi di colonne: ``` 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) } ``` #### Aggiorna L'`update`utilità consente di aggiornare le righe esistenti. È possibile utilizzare l'oggetto condizione per applicare modifiche alle colonne specificate in tutte le righe che soddisfano la condizione. Ad esempio, supponiamo di avere uno schema che ci consente di effettuare questa mutazione. Vogliamo aggiornare the `name` of `Person` con il `id` valore di`3`, ma solo se li conosciamo (`known_since`) dall'anno`2000`: ``` mutation Update { updatePerson( input: {id: 3, name: "Jon"}, condition: {known_since: {ge: "2000"}} ) { id name } } ``` Il nostro risolutore di aggiornamenti ha il seguente aspetto: ``` 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) } ``` Possiamo aggiungere un segno di spunta alla nostra condizione per assicurarci che venga aggiornata solo la riga con la chiave primaria `id` uguale a`3`. Allo stesso modo, per Postgres`inserts`, è possibile utilizzare `returning` per restituire i dati modificati. #### Rimuovi L'`remove`utilità consente di eliminare le righe esistenti. È possibile utilizzare l'oggetto condizione su tutte le righe che soddisfano la condizione. Nota che `delete` è una parola chiave riservata in JavaScript. `remove`dovrebbe essere usato invece: ``` 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) } ``` ### Casting In alcuni casi, potresti volere una maggiore specificità sul tipo di oggetto corretto da utilizzare nella tua dichiarazione. È possibile utilizzare i suggerimenti di tipo forniti per specificare il tipo di parametri. AWS AppSync supporta lo [stesso tipo di suggerimenti](https://docs.aws.amazon.com//rdsdataservice/latest/APIReference/API_SqlParameter.html#rdsdtataservice-Type-SqlParameter-typeHint) della Data API. Puoi trasmettere i tuoi parametri utilizzando le `typeHint` funzioni del AWS AppSync `rds` modulo. L'esempio seguente consente di inviare un array come valore che viene trasmesso come oggetto JSON. Utilizziamo l'`->`operatore per recuperare l'elemento `index` `2` nell'array JSON: ``` 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 } ``` Il casting è utile anche per la gestione e il confronto `DATE` e`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) } ``` Ecco un altro esempio che mostra come inviare la data e l'ora correnti: ``` 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)}`) } ``` **Suggerimenti di tipo disponibili** + `typeHint.DATE`- Il parametro corrispondente viene inviato come oggetto del `DATE` tipo al database. Il formato accettato è `YYYY-MM-DD`. + `typeHint.DECIMAL`- Il parametro corrispondente viene inviato come oggetto del `DECIMAL` tipo al database. + `typeHint.JSON`- Il parametro corrispondente viene inviato come oggetto del `JSON` tipo al database. + `typeHint.TIME`- Il valore del parametro stringa corrispondente viene inviato come oggetto del `TIME` tipo al database. Il formato accettato è `HH:MM:SS[.FFF]`. + `typeHint.TIMESTAMP`- Il valore del parametro stringa corrispondente viene inviato come oggetto del `TIMESTAMP` tipo al database. Il formato accettato è `YYYY-MM-DD HH:MM:SS[.FFF]`. + `typeHint.UUID`- Il valore del parametro stringa corrispondente viene inviato come oggetto del `UUID` tipo al database.