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 intégrées du module.

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

Un objet Map d'entrée qui est converti en objet SubscriptionFilter d'expression.
ignoredFields: SubscriptionFilterExcludeKeysType (facultatif)

Un 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 lorsque vous créez l'objet SubscriptionFilter d'expression. Ces règles strictes seront incluses dans l'objet SubscriptionFilter d'expression afin qu'au moins 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 qui est converti en objet SubscriptionFilter d'expression. Le deuxième argument est un List des noms de champs qui sont ignorés 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 en tant que clés, les conditions des entrées de ces champs sont sous la forme de"operator" : "value".

L'exemple suivant montre comment ajouter des entré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 deux conditions ou plus, toutes ces conditions sont considérées comme utilisant l'opération OR.

L'entrée Map peut également avoir « et » et « ou » comme clés, ce qui implique que toutes les entrées de celles-ci doivent être jointes en utilisant la logique AND ou OR selon la clé. Les valeurs clés « et » et « ou » s'attendent à un ensemble de conditions.


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

Notez que vous pouvez imbriquer « et » et « ou ». Autrement dit, vous pouvez avoir imbriqué « et » /"or » dans un autre bloc « et » /"or ». Cependant, 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 un certain List nombre de noms 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 (ne peut pas avoir « et » ou « ou »). Pour les noms de champs en tant que clés, les conditions de 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 n'a pas de clause « et » ou « ou », il n'y a donc pas d'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înes dans util.str