Aplicaciones auxiliares de transformación en util.transform

util.transform contiene métodos auxiliares que facilitan las operaciones complejas sobre orígenes de datos.

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

Convierte una cadena de entrada en una expresión de filtro que puede usarse en DynamoDB. Recomendamos usar toDynamoDBFilterExpression con las funciones del módulo integradas.

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

Convierte la entrada dada en su expresión DSL de OpenSearch consulta equivalente y la devuelve como una cadena JSON.

Ejemplo de entrada:


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

Ejemplo de salida:


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

Se entiende que el operador predeterminado es AND.

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

Convierte un objeto de entrada Map en un objeto de expresión SubscriptionFilter. El método util.transform.toSubscriptionFilter se utiliza como entrada a la extensión extensions.setSubscriptionFilter(). Para obtener más información, consulte el artículo sobre extensiones.

nota

Los parámetros y la instrucción return se indican a continuación:

Parámetros

objFilter: SubscriptionFilterObject

Objeto de entrada Map que se convierte en el objeto de expresión SubscriptionFilter.
ignoredFields: SubscriptionFilterExcludeKeysType (opcional)

List de nombres de campo en el primer objeto que se omitirán.
rules: SubscriptionFilterRuleObject (opcional)

Objeto de entrada Map con reglas estrictas que se incluye al construir el objeto de expresión SubscriptionFilter. Estas reglas estrictas se incluirán en el objeto de expresión SubscriptionFilter de tal forma que se cumpla al menos una de las reglas para pasar el filtro de suscripción.

Respuesta

Devuelve SubscriptionFilter.

util.transform.toSubscriptionFilter(Map, List)

El primer argumento es el objeto de entrada Map que se convierte en el objeto de expresión SubscriptionFilter. El segundo argumento es una List de nombres de campo que se omiten en el primer objeto de entrada Map al construir el objeto de expresión SubscriptionFilter.

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

util.transform.toDynamoDBConditionExpression(conditionObject)

Crea una expresión de condición de DynamoDB.

Argumentos de filtro de suscripción

En la siguiente tabla se explica cómo se definen los argumentos de las siguientes utilidades:

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

Argument 1: Map

El argumento 1 es un objeto Map con los siguientes valores clave:

nombres de los campos
"and"
"or"

En el caso de los nombres de campo como claves, las condiciones de las entradas de estos campos adoptan la forma de "operator" : "value".

En el siguiente ejemplo se muestra cómo se pueden añadir entradas a Map:


"field_name" : {
                    "operator1" : value             
               }

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

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

Cuando un campo tiene dos o más condiciones, se considera que todas estas condiciones utilizan la operación OR.

La entrada Map también puede tener "and" y "or" como claves, lo que implica que todas las entradas que incluyen deben unirse con la lógica AND u OR, según la clave. Los valores clave "and" y "or" esperan una matriz de condiciones.


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

Tenga en cuenta que puede anidar "and" y "or". Es decir, puede tener "and" y "or" anidados dentro de otro bloque "and" y "or". Sin embargo, no funciona para campos simples.


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

En el siguiente ejemplo se muestra una entrada de argumento 1 con util.transform.toSubscriptionFilter(Map) : Map.

Entradas

Argumento 1: mapa:


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

Salida

El resultado es un objeto Map:


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

El argumento 2 contiene una List de nombres de campo que no deberían tenerse en cuenta en la entrada Map (argumento 1) al construir el objeto de expresión SubscriptionFilter. List también puede estar vacía.

En el siguiente ejemplo se muestran las entradas de argumento 1 y argumento 2 con util.transform.toSubscriptionFilter(Map, List) : Map.

Entradas

Argumento 1: mapa:


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

Argumento 2: lista:


["percentageUp", "author"]

Salida

El resultado es un objeto Map:


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

Argument 3: Map

El argumento 3 es un objeto Map que tiene nombres de campo como valores clave (no puede tener "and" u "or"). En el caso de los nombres de campo como claves, las condiciones de estos campos son entradas en forma de "operator" : "value". A diferencia del argumento 1, el argumento 3 no puede tener varias condiciones en la misma clave. Además, el argumento 3 no tiene una cláusula "and" u "or", por lo que tampoco hay anidamiento involucrado.

El argumento 3 representa una lista de reglas estrictas, que se añaden al objeto de expresión SubscriptionFilter para que se cumpla al menos una de estas condiciones para pasar el filtro.


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

En el siguiente ejemplo se muestran las entradas de argumento 1, argumento 2 y argumento 3 con util.transform.toSubscriptionFilter(Map, List, Map) : Map.

Entradas

Argumento 1: mapa:


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

Argumento 2: lista:


["percentageUp", "author"]

Argumento 3: mapa:


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

Salida

El resultado es un objeto Map:


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

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Aplicaciones auxiliares para HTTP en util.http

Aplicaciones auxiliares de cadena en util.str