Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Bedingungsausdrücke

Wenn Sie Objekte in DynamoDB mithilfe der Operationen, und DeleteItem DynamoDB ändern PutItemUpdateItem, können Sie optional einen Bedingungsausdruck angeben, der steuert, ob die Anforderung erfolgreich sein soll oder nicht, basierend auf dem Status des Objekts, das sich bereits in DynamoDB befindet, bevor der Vorgang ausgeführt wird.

Die AWS AppSync DynamoDB-Funktion ermöglicht die Angabe eines Bedingungsausdrucks in und DeleteItem Anforderungsobjekten sowie eine Strategie PutItemUpdateItem, die befolgt werden muss, wenn die Bedingung fehlschlägt und das Objekt nicht aktualisiert wurde.

Beispiel 1

Das folgende PutItem Anforderungsobjekt hat keinen Bedingungsausdruck. Daher fügt es ein Element in DynamoDB ein, auch wenn bereits ein Element mit demselben Schlüssel existiert, wodurch das vorhandene Element überschrieben wird.

import { util } from '@aws-appsync/utils';
export function request(ctx) {
  const { foo, bar, ...values} = ctx.args
  return {
    operation: 'PutItem',
    key: util.dynamodb.toMapValues({foo, bar}),
    attributeValues: util.dynamodb.toMapValues(values),
  };
}

Beispiel 2

Das folgende PutItem Objekt hat einen Bedingungsausdruck, der es ermöglicht, dass der Vorgang nur dann erfolgreich ist, wenn ein Element mit demselben Schlüssel in DynamoDB nicht existiert.

import { util } from '@aws-appsync/utils';
export function request(ctx) {
  const { foo, bar, ...values} = ctx.args
  return {
    operation: 'PutItem',
    key: util.dynamodb.toMapValues({foo, bar}),
    attributeValues: util.dynamodb.toMapValues(values),
    condition: { expression: "attribute_not_exists(id)" }
  };
}

Wenn die Bedingungsprüfung fehlschlägt, gibt die AWS AppSync DynamoDB-Funktion standardmäßig einen Fehler für die Mutation aus.

Die AWS AppSync DynamoDB-Funktion bietet jedoch einige zusätzliche Funktionen, um Entwicklern bei der Bewältigung einiger häufiger Randfälle zu helfen:

Diese werden im Abschnitt Behandlung eines Fehlers bei der Zustandsprüfung ausführlicher beschrieben.

Weitere Informationen zu DynamoDB-Bedingungsausdrücken finden Sie in der ConditionExpressions DynamoDB-Dokumentation.

Angabe einer Bedingung

Die Objekte PutItemUpdateItem,, und DeleteItem Request ermöglichen alle die Angabe eines optionalen condition Abschnitts. Wenn nicht angegeben, wird keine Bedingungsprüfung ausgeführt. Wenn angegeben, muss die Bedingung wahr sein, damit die Operation erfolgreich ausgeführt werden kann.

Ein condition-Abschnitt weist die folgende Struktur auf:

type ConditionCheckExpression = {
  expression: string;
  expressionNames?: { [key: string]: string};
  expressionValues?: { [key: string]: any};
  equalsIgnore?: string[];
  consistentRead?: boolean;
  conditionalCheckFailedHandler?: {
    strategy: 'Custom' | 'Reject';
    lambdaArn?: string;
  };
};

Die folgenden Felder geben die Bedingung an:

Die verbleibenden Felder teilen der AWS AppSync DynamoDB-Funktion mit, wie ein Fehler bei der Zustandsprüfung zu behandeln ist:

Behandlung eines Fehlers bei der Zustandsprüfung

Wenn eine Zustandsprüfung fehlschlägt, kann die AWS AppSync DynamoDB-Funktion den Fehler für die Mutation und den aktuellen Wert des Objekts mithilfe des util.appendError Dienstprogramms weitergeben. Die AWS AppSync DynamoDB-Funktion bietet jedoch einige zusätzliche Funktionen, um Entwicklern bei der Bewältigung einiger häufiger Randfälle zu helfen:

Das Flussdiagramm für diesen Prozess ist:

Auf der Suche nach dem gewünschten Ergebnis

Wenn die Zustandsprüfung fehlschlägt, führt die AWS AppSync DynamoDB-Funktion eine GetItem DynamoDB-Anforderung aus, um den aktuellen Wert des Elements von DynamoDB abzurufen. Standardmäßig wird ein Strongly Consistent-Lesevorgang verwendet, jedoch kann dies mit dem consistentRead-Feld im condition-Block konfiguriert werden, und mit dem erwarteten Ergebnis verglichen:

Wenn der aktuelle Status des Objekts in DynamoDB vom erwarteten Ergebnis abweicht, folgt die AWS AppSync DynamoDB-Funktion der konfigurierten Strategie, entweder die Mutation zurückzuweisen oder eine Lambda-Funktion aufzurufen, um zu bestimmen, was als Nächstes zu tun ist.

Folgt der Strategie „Ablehnen“

Wenn Sie der Reject Strategie folgen, gibt die AWS AppSync DynamoDB-Funktion einen Fehler für die Mutation zurück.

Angenommen, Sie haben folgende Mutationsanforderung:

mutation {
    updatePerson(id: 1, name: "Steve", expectedVersion: 1) {
        Name
        theVersion
    }
}

Wenn das von DynamoDB zurückgegebene Element wie folgt aussieht:

{
   "id" : { "S" : "1" },
   "name" : { "S" : "Steve" },
   "version" : { "N" : 8 }
}

Und der Antworthandler der Funktion sieht wie folgt aus:

import { util } from '@aws-appsync/utils';
export function response(ctx) {
  const { version, ...values } = ctx.result;
  const result = { ...values, theVersion: version };
  if (ctx.error) {
    if (error) {
      return util.appendError(error.message, error.type, result, null);
    }
  }
  return result
}

Die GraphQL-Antwort sieht wie folgt aus:

{
  "data": null,
  "errors": [
    {
      "message": "The conditional request failed (Service: AmazonDynamoDBv2; Status Code: 400; Error Code: ConditionalCheckFailedException; Request ID: ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ)"
      "errorType": "DynamoDB:ConditionalCheckFailedException",
      ...
    }
  ]
}

Beachten Sie auch, dass, wenn bei einer erfolgreichen Mutation alle Felder im zurückgegebenen Objekt von anderen Resolvern ausgefüllt werden, diese nicht auf den Resolver angewendet werden, wenn das Objekt im error-Abschnitt zurückgegeben wird.

Folgen Sie der „benutzerdefinierten“ Strategie

Wenn Sie der Custom Strategie folgen, ruft die AWS AppSync DynamoDB-Funktion eine Lambda-Funktion auf, um zu entscheiden, was als Nächstes zu tun ist. Die Lambda-Funktion wählt eine der folgenden Optionen aus:

Die Lambda-Aufrufanforderung

Die AWS AppSync DynamoDB-Funktion ruft die in der angegebene Lambda-Funktion auf. lambdaArn Er verwendet die gleiche service-role-arn-Konfiguration für die Datenquelle. Die Nutzlast des Aufrufs hat die folgende Struktur:

{
    "arguments": { ... },
    "requestMapping": {... },
    "currentValue": { ... },
    "resolver": { ... },
    "identity": { ... }
}

Die Felder sind wie folgt definiert:

Ein vollständiges Beispiel für die Nutzlast:

{
    "arguments": {
        "id": "1",
        "name": "Steve",
        "expectedVersion": 1
    },
    "requestMapping": {
        "version" : "2017-02-28",
        "operation" : "PutItem",
        "key" : {
           "id" : { "S" : "1" }
        },
        "attributeValues" : {
           "name" : { "S" : "Steve" },
           "version" : { "N" : 2 }
        },
        "condition" : {
           "expression" : "version = :expectedVersion",
           "expressionValues" : {
               ":expectedVersion" : { "N" : 1 }
           },
           "equalsIgnore": [ "version" ]
        }
    },
    "currentValue": {
        "id" : { "S" : "1" },
        "name" : { "S" : "Steve" },
        "version" : { "N" : 8 }
    },
    "resolver": {
        "tableName": "People",
        "awsRegion": "us-west-2",
        "parentType": "Mutation",
        "field": "updatePerson",
        "outputType": "Person"
    },
    "identity": {
        "accountId": "123456789012",
        "sourceIp": "x.x.x.x",
        "user": "AIDAAAAAAAAAAAAAAAAAA",
        "userArn": "arn:aws:iam::123456789012:user/appsync"
    }
}

Die Lambda-Aufrufantwort

Die Lambda-Funktion kann die Aufrufnutzlast überprüfen und jede Geschäftslogik anwenden, um zu entscheiden, wie die AWS AppSync DynamoDB-Funktion den Fehler behandeln soll. Es gibt drei Optionen für den Umgang mit dem Bedingungsprüfungsfehler:

Hier sehen Sie ein Beispiel für eine Lambda-Funktion zum Umgang mit einer fehlgeschlagenen PutItem-Anforderung. Die Geschäftslogik prüft, wer den Aufruf ausgeführt hat. Wenn sie von gestellt wurdejeffTheAdmin, wiederholt sie die Anforderung und aktualisiert dabei das version und expectedVersion aus dem Element, das sich derzeit in DynamoDB befindet. Andernfalls wird die Mutation ablehnt.

exports.handler = (event, context, callback) => {
    console.log("Event: "+ JSON.stringify(event));

    // Business logic goes here.

    var response;
    if ( event.identity.user == "jeffTheAdmin" ) {
        response = {
            "action" : "retry",
            "retryMapping" : {
                "attributeValues" : event.requestMapping.attributeValues,
                "condition" : {
                    "expression" : event.requestMapping.condition.expression,
                    "expressionValues" : event.requestMapping.condition.expressionValues
                }
            }
        }
        response.retryMapping.attributeValues.version = { "N" : event.currentValue.version.N + 1 }
        response.retryMapping.condition.expressionValues[':expectedVersion'] = event.currentValue.version

    } else {
        response = { "action" : "reject" }
    }

    console.log("Response: "+ JSON.stringify(response))
    callback(null, response)
};