Auxiliares de transformação em util.transform

util.transform contém métodos auxiliares que facilitam a execução de operações complexas em fontes de dados.

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

Converte uma string de entrada em uma expressão de filtro para o uso com o DynamoDB. Recomendamos o uso toDynamoDBFilterExpression com funções de módulo integradas.

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

Converte a entrada fornecida em sua expressão DSL de OpenSearch consulta equivalente, retornando-a como uma string JSON.

Exemplo de entrada:


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

Exemplos de resultado:


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

Presume-se que o operador padrão seja AND.

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

Converte um objeto de entrada Map em um objeto de expressão SubscriptionFilter. O método util.transform.toSubscriptionFilter é usado como entrada para a extensão extensions.setSubscriptionFilter(). Para obter mais informações, consulte Extensões.

nota

Os parâmetros e a declaração de retorno estão listados abaixo:

Parâmetros

objFilter: SubscriptionFilterObject

Um objeto de entrada Map que é convertido no objeto de expressão SubscriptionFilter.
ignoredFields: SubscriptionFilterExcludeKeysType (opcional)

Um List dos nomes de campo no primeiro objeto que serão ignorados.
rules: SubscriptionFilterRuleObject (opcional)

Um objeto Map de entrada com regras rígidas que é incluído quando você está criando o objeto de expressão SubscriptionFilter. Essas regras estritas são incluídas no objeto de expressão SubscriptionFilter de forma que pelo menos uma das regras seja satisfeita para passar pelo filtro de assinatura.

Resposta

Retorna um SubscriptionFilter.

util.transform.toSubscriptionFilter(Map, List)

O primeiro argumento é o objeto de entrada Map que é convertido no objeto de expressão SubscriptionFilter. O segundo argumento é uma List de nomes de campos que são ignorados no primeiro objeto de entrada Map durante a criação da estrutura do objeto de expressão SubscriptionFilter.

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

util.transform.toDynamoDBConditionExpression(conditionObject)

Cria uma expressão de condição do DynamoDB.

Argumentos do filtro de assinatura

A tabela a seguir explica como os argumentos dos seguintes utilitários são definidos:

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

Argument 1: Map

O argumento 1 é um objeto Map com os seguintes valores-chave:

nomes de campos
"and"
"or"

Para nomes de campos como chaves, as condições nas entradas desses campos estão no formato "operator" : "value".

O exemplo a seguir mostra como entradas podem ser adicionadas ao Map:


"field_name" : {
                    "operator1" : value             
               }

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

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

Quando um campo contém duas ou mais condições, todas essas condições são consideradas para usar a operação OR.

A entrada Map também pode ter "and" e "or" como chaves, o que implica que todas as entradas dentro dessas devem ser unidas usando a lógica AND ou OR dependendo da chave. Os valores-chave "and" e "or" esperam uma série de condições.


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

Observe que você pode aninhar "and" e "or". Ou seja, você pode ter aninhado "and"/"or" em outro bloco "and"/"or". No entanto, isso não funciona em campos simples.


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

O exemplo a seguir mostra uma entrada do argumento 1 usando util.transform.toSubscriptionFilter(Map) : Map.

Entrada(s)

Argumento 1: mapa:


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

Saída

O resultado é um 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

O argumento 2 contém uma List de nomes de campos que não devem ser considerados na entrada Map (argumento 1) durante a criação da estrutura do objeto de expressão SubscriptionFilter. A List também pode estar vazia.

O exemplo a seguir mostra uma entrada do argumento 1 e argumento 2 usando util.transform.toSubscriptionFilter(Map, List) : Map.

Entrada(s)

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

Saída

O resultado é um 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

O argumento 3 é um objeto Map que tem nomes de campo como valores-chave (não pode ter "and" ou "or"). Para nomes de campos como chaves, as condições nesses campos são entradas no formato "operator" : "value". Diferentemente do argumento 1, o argumento 3 não pode ter várias condições na mesma chave. Além disso, o argumento 3 não possui uma cláusula "and" ou "or"; portanto, também não há aninhamento envolvido.

O argumento 3 representa uma lista de regras estritas, que são adicionadas ao objeto de expressão SubscriptionFilter para que pelo menos uma dessas condições seja atendida para passar pelo filtro.


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

O exemplo a seguir mostra as entradas de argumento 1, argumento 2 e argumento 3 usando util.transform.toSubscriptionFilter(Map, List, Map) : Map.

Entrada(s)

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

Saída

O resultado é um 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"
        }
      ]
    }
  ]
}

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Auxiliares HTTP em util.http

Auxiliares de string em util.str