Aiutanti di trasformazione in util.transform

util.transformcontiene metodi di supporto che semplificano l'esecuzione di operazioni complesse sulle fonti di dati.

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

Converte una stringa di input in un'espressione di filtro da utilizzare con DynamoDB. Si consiglia di utilizzare toDynamoDBFilterExpression con le funzioni integrate del modulo.

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

Converte l'input dato nell'espressione OpenSearch Query DSL equivalente, restituendolo come stringa JSON.

Esempio di input:


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

Output di esempio:


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

Nota

Si presume che l'operatore predefinito sia AND.

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

Converte un oggetto Map di input in un oggetto di SubscriptionFilter espressione. Il util.transform.toSubscriptionFilter metodo viene utilizzato come input per l'extensions.setSubscriptionFilter()estensione. Per ulteriori informazioni, consulta Estensioni.

Nota

I parametri e la dichiarazione di ritorno sono elencati di seguito:

Parametri

objFilter: SubscriptionFilterObject

Un oggetto Map di input che viene convertito nell'oggetto SubscriptionFilter espressione.
ignoredFields: SubscriptionFilterExcludeKeysType (opzionale)

Una List serie di nomi di campo nel primo oggetto che verranno ignorati.
rules: SubscriptionFilterRuleObject (opzionale)

Un oggetto Map di input con regole rigide incluso nella costruzione dell'oggetto SubscriptionFilter espressione. Queste regole rigide verranno incluse nell'oggetto SubscriptionFilter espressione in modo che almeno una delle regole sia soddisfatta per il superamento del filtro di sottoscrizione.

Risposta

Restituisce una SubscriptionFilter.

util.transform.toSubscriptionFilter(Map, List)

Converte un oggetto Map di input in un oggetto SubscriptionFilter espressione. Il util.transform.toSubscriptionFilter metodo viene utilizzato come input per l'extensions.setSubscriptionFilter()estensione. Per ulteriori informazioni, consulta Estensioni.

Il primo argomento è l'oggetto Map di input che viene convertito nell'oggetto SubscriptionFilter espressione. Il secondo argomento è costituito da nomi List di campo che vengono ignorati nel primo oggetto Map di input durante la costruzione dell'oggetto SubscriptionFilter espressione.

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

Converte un oggetto di Map input in un oggetto di espressione. SubscriptionFilter Il util.transform.toSubscriptionFilter metodo viene utilizzato come input per l'extensions.setSubscriptionFilter()estensione. Per ulteriori informazioni, consulta Estensioni.

util.transform.toDynamoDBConditionExpression(conditionObject)

Crea un'espressione condizionale DynamoDB.

Argomenti del filtro di abbonamento

La tabella seguente spiega come vengono definiti gli argomenti delle seguenti utilità:

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

Argument 1: Map

L'argomento 1 è un Map oggetto con i seguenti valori chiave:

nomi dei campi
«e»
«o»

Per i nomi dei campi come chiavi, le condizioni relative alle voci di questi campi sono sotto forma di. "operator" : "value"

L'esempio seguente mostra come aggiungere delle voci a: Map


"field_name" : {
                    "operator1" : value             
               }

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

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

Quando un campo contiene due o più condizioni, si considera che tutte queste condizioni utilizzino l'operazione OR.

L'input Map può anche avere «and» e «or» come chiavi, il che implica che tutte le voci al suo interno devono essere unite usando la logica AND o OR a seconda della chiave. I valori chiave «and» e «or» prevedono una serie di condizioni.


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

Nota che puoi annidare «and» e «or». Ovvero, puoi aver annidato «and» /"or» all'interno di un altro blocco «and» /"or». Tuttavia, questo non funziona per i campi semplici.


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

L'esempio seguente mostra un input dell'argomento 1 utilizzandoutil.transform.toSubscriptionFilter(Map) : Map.

Ingresso/i

Argomento 1: Mappa:


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

Output

Il risultato è un Map oggetto:


{
  "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'argomento 2 contiene alcuni nomi List di campo che non devono essere considerati nell'input Map (argomento 1) durante la costruzione dell'oggetto SubscriptionFilter espressione. ListPuò anche essere vuoto.

L'esempio seguente mostra gli input dell'argomento 1 e dell'argomento 2 utilizzandoutil.transform.toSubscriptionFilter(Map, List) : Map.

Ingresso/i

Argomento 1: Mappa:


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

Argomento 2: Elenco:


["percentageUp", "author"]

Output

Il risultato è un Map oggetto:


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

Argument 3: Map

L'argomento 3 è un Map oggetto che ha i nomi dei campi come valori chiave (non può avere «and» o «or»). Per i nomi di campo come chiavi, le condizioni relative a questi campi sono immissioni sotto forma di"operator" : "value". A differenza dell'argomento 1, l'argomento 3 non può avere più condizioni nella stessa chiave. Inoltre, l'argomento 3 non contiene una clausola «and» o «or», quindi non è prevista nemmeno la nidificazione.

L'argomento 3 rappresenta un elenco di regole rigide, che vengono aggiunte all'oggetto SubscriptionFilter espressione in modo che almeno una di queste condizioni sia soddisfatta per passare il filtro.


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

L'esempio seguente mostra gli input dell'argomento 1, dell'argomento 2 e dell'argomento 3 utilizzandoutil.transform.toSubscriptionFilter(Map, List, Map) : Map.

Ingresso/i

Argomento 1: Mappa:


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

Argomento 2: Elenco:


["percentageUp", "author"]

Argomento 3: Mappa:


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

Output

Il risultato è un Map oggetto:


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

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Helper HTTP in util.http

String helper in util.str