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.

# Transformationshelfer in util.transform
<a name="transformation-helpers-in-utils-transform-js"></a>

`util.transform`enthält Hilfsmethoden, die es einfacher machen, komplexe Operationen mit Datenquellen durchzuführen.

## Liste der Transformationshelfer und Hilfsprogramme
<a name="transformation-helpers-in-utils-transform-js-list"></a>

**`util.transform.toDynamoDBFilterExpression(filterObject: DynamoDBFilterObject) : string`**  
Konvertiert eine Eingabezeichenfolge in einen Filterausdruck zur Verwendung mit DynamoDB. Wir empfehlen die Verwendung `toDynamoDBFilterExpression` mit [ integrierten Modulfunktionen. ](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-modules-js.html)

**`util.transform.toElasticsearchQueryDSL(object: OpenSearchQueryObject) : string`**  
Konvertiert die angegebene Eingabe in den entsprechenden OpenSearch Query-DSL-Ausdruck und gibt ihn als JSON-Zeichenfolge zurück.  
**Beispiel für eine Eingabe: **  

```
util.transform.toElasticsearchQueryDSL({
    "upvotes":{
        "ne":15,
        "range":[
            10,
            20
        ]
    },
    "title":{
        "eq":"hihihi",
        "wildcard":"h*i"
    }
  })
```
**Beispielausgabe:**  

```
{
    "bool":{
      "must":[
          {
            "bool":{
              "must":[
                  {
                    "bool":{
                      "must_not":{
                        "term":{
                          "upvotes":15
                        }
                      }
                    }
                  },
                  {
                    "range":{
                      "upvotes":{
                        "gte":10,
                        "lte":20
                      }
                    }
                  }
              ]
            }
          },
          {
            "bool":{
              "must":[
                  {
                    "term":{
                      "title":"hihihi"
                    }
                  },
                  {
                  "wildcard":{
                      "title":"h*i"
                    }
                  }
              ]
            }
          }
      ]
    }
}
```
Es wird davon ausgegangen, dass der Standardoperator AND ist.

**`util.transform.toSubscriptionFilter(objFilter, ignoredFields?, rules?): SubscriptionFilter`**  
Konvertiert ein `Map` Eingabeobjekt in ein `SubscriptionFilter` Ausdrucksobjekt. Die `util.transform.toSubscriptionFilter` Methode wird als Eingabe für die `extensions.setSubscriptionFilter()` Erweiterung verwendet. Weitere Informationen finden Sie unter [ Erweiterungen](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html).  
Die Parameter und die Rückgabeanweisung sind unten aufgeführt:  
*Parameter*  
+ `objFilter`: `SubscriptionFilterObject`

  Ein `Map` Eingabeobjekt, das in das `SubscriptionFilter` Ausdrucksobjekt konvertiert wird.
+ `ignoredFields`: `SubscriptionFilterExcludeKeysType` (optional)

  Eine `List` von Feldnamen im ersten Objekt, die ignoriert werden.
+ `rules`: `SubscriptionFilterRuleObject` (optional)

  Ein `Map` Eingabeobjekt mit strengen Regeln, das beim Erstellen des `SubscriptionFilter` Ausdrucksobjekts enthalten ist. Diese strengen Regeln werden in das `SubscriptionFilter` Ausdrucksobjekt aufgenommen, sodass mindestens eine der Regeln erfüllt ist, um den Abonnementfilter zu bestehen.
*Antwort*  
Gibt eine `[SubscriptionFilter](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html)` zurück.

**`util.transform.toSubscriptionFilter(Map, List)`**  
Konvertiert ein `Map` Eingabeobjekt in ein `SubscriptionFilter` Ausdrucksobjekt. Die `util.transform.toSubscriptionFilter` Methode wird als Eingabe für die `extensions.setSubscriptionFilter()` Erweiterung verwendet. Weitere Informationen finden Sie unter [ Erweiterungen](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html).  
Das erste Argument ist das `Map` Eingabeobjekt, das in das `SubscriptionFilter` Ausdrucksobjekt konvertiert wurde. Das zweite Argument besteht `List` aus Feldnamen, die im ersten `Map` Eingabeobjekt beim Erstellen des `SubscriptionFilter` Ausdrucksobjekts ignoriert werden.

**`util.transform.toSubscriptionFilter(Map, List, Map)`**  
Konvertiert ein `Map` Eingabeobjekt in ein `SubscriptionFilter` Ausdrucksobjekt. Die `util.transform.toSubscriptionFilter` Methode wird als Eingabe für die `extensions.setSubscriptionFilter()` Erweiterung verwendet. Weitere Informationen finden Sie unter [ Erweiterungen](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html). 

**`util.transform.toDynamoDBConditionExpression(conditionObject)`**  
Erstellt einen DynamoDB-Bedingungsausdruck.

## Argumente für den Abonnementfilter
<a name="subscription-filter-arguments-js"></a>

In der folgenden Tabelle wird erklärt, wie die Argumente der folgenden Dienstprogramme definiert sind:
+ `Util.transform.toSubscriptionFilter(objFilter, ignoredFields?, rules?): SubscriptionFilter`

------
#### [ Argument 1: Map ]

Argument 1 ist ein `Map` Objekt mit den folgenden Schlüsselwerten:
+ Feldnamen
+ „und“
+ „oder“

Bei Feldnamen als Schlüssel haben die Bedingungen für die Einträge dieser Felder die Form von`"operator" : "value"`. 

Das folgende Beispiel zeigt, wie Einträge zu folgenden Elementen hinzugefügt werden können: `Map`

```
"field_name" : {
                    "operator1" : value             
               }

## We can have multiple conditions for the same field_name: 

"field_name" : {
                    "operator1" : value             
                    "operator2" : value
                    .
                    .
                    .                  
               }
```

Wenn ein Feld zwei oder mehr Bedingungen enthält, wird davon ausgegangen, dass für alle diese Bedingungen die OR-Operation verwendet wird.

Die Eingabe `Map` kann auch „und“ und „Oder“ als Schlüssel haben, was bedeutet, dass alle darin enthaltenen Einträge je nach Schlüssel mithilfe der UND- oder OR-Logik verknüpft werden sollten. Die Schlüsselwerte „und“ und „oder“ erwarten eine Reihe von Bedingungen.

```
"and" : [
            
            {
                "field_name1" : {
                    "operator1" : value             
                }
             },
             
             {
                "field_name2" : {
                    "operator1" : value             
                }
             },
             .
             .
        ].
```

Beachten Sie, dass Sie „und“ und „oder“ verschachteln können. Das heißt, Sie können „und“ /"oder“ innerhalb eines anderen „und“ /"oder“ -Blocks verschachtelt haben. Dies funktioniert jedoch nicht für einfache Felder.

```
"and" : [
            
            {
                "field_name1" : {
                    "operator" : value             
                }
             },
             
             {
                "or" : [
                            {
                                "field_name2" : {
                                    "operator" : value             
                                }
                            },
                            
                            {
                                "field_name3" : {
                                    "operator" : value             
                                }
                            }
              
                        ].
```

Das folgende Beispiel zeigt eine Eingabe von * Argument 1 * mit`util.transform.toSubscriptionFilter(Map) : Map`.

**Eingabe (en) **

Argument 1: Karte:

```
{
  "percentageUp": {
    "lte": 50,
    "gte": 20
  },
  "and": [
    {
      "title": {
        "ne": "Book1"
      }
    },
    {
      "downvotes": {
        "gt": 2000
      }
    }
  ],
  "or": [
    {
      "author": {
        "eq": "Admin"
      }
    },
    {
      "isPublished": {
        "eq": false
      }
    }
  ]
}
```

**Ausgabe**

Das Ergebnis ist ein `Map` Objekt:

```
{
  "filterGroup": [
    {
      "filters": [
        {
          "fieldName": "percentageUp",
          "operator": "lte",
          "value": 50
        },
        {
          "fieldName": "title",
          "operator": "ne",
          "value": "Book1"
        },
        {
          "fieldName": "downvotes",
          "operator": "gt",
          "value": 2000
        },
        {
          "fieldName": "author",
          "operator": "eq",
          "value": "Admin"
        }
      ]
    },
    {
      "filters": [
        {
          "fieldName": "percentageUp",
          "operator": "lte",
          "value": 50
        },
        {
          "fieldName": "title",
          "operator": "ne",
          "value": "Book1"
        },
        {
          "fieldName": "downvotes",
          "operator": "gt",
          "value": 2000
        },
        {
          "fieldName": "isPublished",
          "operator": "eq",
          "value": false
        }
      ]
    },
    {
      "filters": [
        {
          "fieldName": "percentageUp",
          "operator": "gte",
          "value": 20
        },
        {
          "fieldName": "title",
          "operator": "ne",
          "value": "Book1"
        },
        {
          "fieldName": "downvotes",
          "operator": "gt",
          "value": 2000
        },
        {
          "fieldName": "author",
          "operator": "eq",
          "value": "Admin"
        }
      ]
    },
    {
      "filters": [
        {
          "fieldName": "percentageUp",
          "operator": "gte",
          "value": 20
        },
        {
          "fieldName": "title",
          "operator": "ne",
          "value": "Book1"
        },
        {
          "fieldName": "downvotes",
          "operator": "gt",
          "value": 2000
        },
        {
          "fieldName": "isPublished",
          "operator": "eq",
          "value": false
        }
      ]
    }
  ]
}
```

------
#### [ Argument 2: List ]

Argument 2 enthält eine Reihe `List` von Feldnamen, die bei der Erstellung des `SubscriptionFilter` Ausdrucksobjekts in der Eingabe `Map` (Argument 1) nicht berücksichtigt werden sollten. Das `List` kann auch leer sein.

Das folgende Beispiel zeigt die Eingaben von Argument 1 und Argument 2 unter Verwendung von`util.transform.toSubscriptionFilter(Map, List) : Map`.

**Eingabe (en) **

Argument 1: Karte:

```
{
  "percentageUp": {
    "lte": 50,
    "gte": 20
  },
  "and": [
    {
      "title": {
        "ne": "Book1"
      }
    },
    {
      "downvotes": {
        "gt": 20
      }
    }
  ],
  "or": [
    {
      "author": {
        "eq": "Admin"
      }
    },
    {
      "isPublished": {
        "eq": false
      }
    }
  ]
}
```

Argument 2: Liste:

```
["percentageUp", "author"]
```

**Ausgabe**

Das Ergebnis ist ein `Map` Objekt:

```
{
  "filterGroup": [
    {
      "filters": [
        {
          "fieldName": "title",
          "operator": "ne",
          "value": "Book1"
        },
        {
          "fieldName": "downvotes",
          "operator": "gt",
          "value": 20
        },
        {
          "fieldName": "isPublished",
          "operator": "eq",
          "value": false
        }
      ]
    }
  ]
}
```

------
#### [ Argument 3: Map ]

Argument 3 ist ein `Map` Objekt, das Feldnamen als Schlüsselwerte hat (kein „und“ oder „oder“). Bei Feldnamen als Schlüssel handelt es sich bei den Bedingungen in diesen Feldern um Einträge in der Form von`"operator" : "value"`. Im Gegensatz zu Argument 1 kann Argument 3 nicht mehrere Bedingungen im selben Schlüssel enthalten. Darüber hinaus hat Argument 3 keine „und“ - oder „oder“ -Klausel, sodass auch keine Verschachtelung erforderlich ist.

Argument 3 stellt eine Liste strenger Regeln dar, die dem `SubscriptionFilter` Ausdrucksobjekt hinzugefügt werden, sodass ** mindestens eine ** dieser Bedingungen erfüllt ist, um den Filter zu bestehen.

```
{
  "fieldname1": {
    "operator": value
  },
  "fieldname2": {
    "operator": value
  }
}
.
.
.
```

Das folgende Beispiel zeigt die Eingaben von * Argument 1*, * Argument 2 * und * Argument 3 * unter Verwendung von`util.transform.toSubscriptionFilter(Map, List, Map) : Map`.

**Eingabe (en) **

Argument 1: Karte:

```
{
  "percentageUp": {
    "lte": 50,
    "gte": 20
  },
  "and": [
    {
      "title": {
        "ne": "Book1"
      }
    },
    {
      "downvotes": {
        "lt": 20
      }
    }
  ],
  "or": [
    {
      "author": {
        "eq": "Admin"
      }
    },
    {
      "isPublished": {
        "eq": false
      }
    }
  ]
}
```

Argument 2: Liste:

```
["percentageUp", "author"]
```

Argument 3: Karte:

```
{
  "upvotes": {
    "gte": 250
  },
  "author": {
    "eq": "Person1"
  }
}
```

**Ausgabe**

Das Ergebnis ist ein `Map` Objekt:

```
{
  "filterGroup": [
    {
      "filters": [
        {
          "fieldName": "title",
          "operator": "ne",
          "value": "Book1"
        },
        {
          "fieldName": "downvotes",
          "operator": "gt",
          "value": 20
        },
        {
          "fieldName": "isPublished",
          "operator": "eq",
          "value": false
        },
        {
          "fieldName": "upvotes",
          "operator": "gte",
          "value": 250
        }
      ]
    },
    {
      "filters": [
        {
          "fieldName": "title",
          "operator": "ne",
          "value": "Book1"
        },
        {
          "fieldName": "downvotes",
          "operator": "gt",
          "value": 20
        },
        {
          "fieldName": "isPublished",
          "operator": "eq",
          "value": false
        },
        {
          "fieldName": "author",
          "operator": "eq",
          "value": "Person1"
        }
      ]
    }
  ]
}
```

------