Aiutanti di trasformazione in util.transform

util.transformcontiene metodi di supporto che semplificano l'esecuzione di operazioni complesse su 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 l'utilizzo toDynamoDBFilterExpression con le funzioni integrate del modulo.

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

Converte l'input dato nella sua DSL espressione OpenSearch Query equivalente, restituendola come JSON stringa.

Esempio di input:


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

Esempio di output:


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

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

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.

Nota

I parametri e l'istruzione return sono elencati di seguito:

Parametri

objFilter: SubscriptionFilterObject

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

Uno List dei nomi di campo nel primo oggetto che verrà ignorato.
rules: SubscriptionFilterRuleObject (opzionale)

Un oggetto Map di input con regole rigorose che viene incluso durante la costruzione dell'oggetto SubscriptionFilter espressione. Queste regole rigorose verranno incluse nell'oggetto SubscriptionFilter espressione in modo che almeno una delle regole venga soddisfatta per passare il filtro di sottoscrizione.

Risposta

Restituisce una SubscriptionFilter.

util.transform.toSubscriptionFilter(Map, List)

Il primo argomento è l'oggetto Map di input che viene convertito nell'oggetto SubscriptionFilter espressione. Il secondo argomento riguarda i 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 Map di input in un SubscriptionFilter oggetto espressione. 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 di condizione 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 di campo
«e»
«o»

Per i nomi di campo come chiavi, le condizioni nelle voci di questi campi sono nel formato di. "operator" : "value"

L'esempio seguente mostra come aggiungere 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 «e» e «or» come chiavi, il che implica che tutte le voci al suo interno devono essere unite utilizzando la logica AND 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». Cioè, puoi aver annidato «e» /"or» all'interno di un altro blocco «e» /"or». Tuttavia, questo non funziona per 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 una List serie di nomi di campo che non devono essere considerati nell'input Map (argomento 1) durante la costruzione dell'oggetto SubscriptionFilter espressione. ListPossono anche essere vuoti.

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 nomi di campo come valori chiave (non può avere «and» o «or»). Per i nomi di campo come chiavi, le condizioni in questi campi sono voci nel formato 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 rigorose, che vengono aggiunte all'oggetto SubscriptionFilter espressione in modo che venga soddisfatta almeno una di queste condizioni 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

HTTPaiutanti in util.http

String helper in util.str