Aides à la transformation dans util.transform

util.transformcontient des méthodes d'assistance qui facilitent l'exécution d'opérations complexes sur des sources de données.

util.transform.toDynamoDBFilterExpression(filterObject: DynamoDBFilterObject) : string

Convertit une chaîne d'entrée en une expression de filtre à utiliser avec DynamoDB. Nous vous recommandons de l'utiliser toDynamoDBFilterExpression avec les fonctions du module intégré.

util.transform.toElasticsearchQueryDSL(object: OpenSearchQueryObject) : string

Convertit l'entrée donnée en son expression OpenSearch Query DSL équivalente, en la renvoyant sous forme de chaîne JSON.

Exemple de saisie :


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

Exemple de sortie :


{
    "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"
                    }
                  }
              ]
            }
          }
      ]
    }
}

Note

L'opérateur par défaut est supposé être AND.

util.transform.toSubscriptionFilter(objFilter, ignoredFields?, rules?): SubscriptionFilter

Convertit un objet Map d'entrée en objet d'SubscriptionFilterexpression. La util.transform.toSubscriptionFilter méthode est utilisée comme entrée dans l'extensions.setSubscriptionFilter()extension. Pour plus d'informations, consultez la section Extensions.

Note

Les paramètres et l'instruction de retour sont répertoriés ci-dessous :

Paramètres

objFilter: SubscriptionFilterObject

Objet d'Mapentrée converti en objet d'SubscriptionFilterexpression.
ignoredFields: SubscriptionFilterExcludeKeysType (facultatif)

A List des noms de champs du premier objet qui seront ignorés.
rules: SubscriptionFilterRuleObject (facultatif)

Un objet Map d'entrée avec des règles strictes qui est inclus lors de la construction de l'objet SubscriptionFilter d'expression. Ces règles strictes seront incluses dans l'objet SubscriptionFilter d'expression afin qu'au moins l'une des règles soit satisfaite pour passer le filtre d'abonnement.

Réponse

Retourne un SubscriptionFilter.

util.transform.toSubscriptionFilter(Map, List)

Le premier argument est l'objet Map d'entrée converti en objet d'SubscriptionFilterexpression. Le deuxième argument est un nom List de champ qui est ignoré dans le premier objet Map d'entrée lors de la construction de l'objet SubscriptionFilter d'expression.

util.transform.toSubscriptionFilter(Map, List, Map)

util.transform.toDynamoDBConditionExpression(conditionObject)

Crée une expression de condition DynamoDB.

Arguments du filtre d'abonnement

Le tableau suivant explique comment les arguments des utilitaires suivants sont définis :

Util.transform.toSubscriptionFilter(objFilter, ignoredFields?, rules?): SubscriptionFilter

Argument 1: Map

L'argument 1 est un Map objet dont les valeurs clés sont les suivantes :

noms de champs
« et »
« ou »

Pour les noms de champs sous forme de clés, les conditions relatives aux entrées de ces champs sont sous la forme de"operator" : "value".

L'exemple suivant montre comment des entrées peuvent être ajoutées au Map :


"field_name" : {
                    "operator1" : value             
               }

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

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

Lorsqu'un champ comporte au moins deux conditions, toutes ces conditions sont considérées comme utilisant l'opération OR.

L'entrée Map peut également comporter des touches « et » et « ou », ce qui implique que toutes les entrées qu'elles contiennent doivent être jointes en utilisant la logique AND ou OR en fonction de la clé. Les valeurs clés « et » et « ou » supposent un ensemble de conditions.


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

Notez que vous pouvez imbriquer « et » et « ou ». C'est-à-dire que vous pouvez avoir imbriqué « et » /"ou » dans un autre bloc « et » /"ou ». Toutefois, cela ne fonctionne pas pour les champs simples.


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

L'exemple suivant montre une entrée de l'argument 1 utilisantutil.transform.toSubscriptionFilter(Map) : Map.

Entrée (s)

Argument 1 : Carte :


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

Sortie

Le résultat est un Map objet :


{
  "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

L'argument 2 contient des noms List de champs qui ne doivent pas être pris en compte dans l'entrée Map (argument 1) lors de la construction de l'objet SubscriptionFilter d'expression. Ils List peuvent également être vides.

L'exemple suivant montre les entrées de l'argument 1 et de l'argument 2 en utilisantutil.transform.toSubscriptionFilter(Map, List) : Map.

Entrée (s)

Argument 1 : Carte :


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

Argument 2 : Liste :


["percentageUp", "author"]

Sortie

Le résultat est un Map objet :


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

Argument 3: Map

L'argument 3 est un Map objet dont les noms de champs sont des valeurs clés (il ne peut pas y avoir « et » ou « ou »). Pour les noms de champs sous forme de clés, les conditions relatives à ces champs sont des entrées sous la forme de"operator" : "value". Contrairement à l'argument 1, l'argument 3 ne peut pas avoir plusieurs conditions dans la même clé. De plus, l'argument 3 ne contient pas de clause « et » ou « ou », il n'y a donc aucune imbrication non plus.

L'argument 3 représente une liste de règles strictes, qui sont ajoutées à l'objet SubscriptionFilter d'expression afin qu'au moins l'une de ces conditions soit remplie pour passer le filtre.


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

L'exemple suivant montre les entrées de l'argument 1, de l'argument 2 et de l'argument 3 en utilisantutil.transform.toSubscriptionFilter(Map, List, Map) : Map.

Entrée (s)

Argument 1 : Carte :


{
  "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 : Carte :


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

Sortie

Le résultat est un Map objet :


{
  "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"
        }
      ]
    }
  ]
}

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Assistants HTTP dans util.http

assistants de chaîne dans util.str