登录
当前位置： 首页 > 面试题库 >

如何检查嵌套类型elasticsearch对象中的缺失键？

郭通
2023-03-14
问题内容：

我有一种情况，我以键值对json格式doc收集一些常规信息和数据库信息（db2，oracle，sybase，informix）。

我还具有一些规则来检查上述文档是否满足特定规则，如果满意，则退还该特定文档以进行分析。

这是医生

PUT /twitter/tweet/1
{
    "name": "Athena",
    "version": 1,
    "db": {
        "@type": "Oracle Database 10g Enterprise Edition Release 10.2.0.4.0 64bit",
        "oracle_props": [
            {
                "@name": "open_cursors",
                "@value": 4000
            },
            {
                "@name": "USER_ROLE_PRIVS_COUNT",
                "@value": 1
            }
        ]
    }
}

这是它的映射

PUT /twitter/tweet/_mapping
{
   "properties": {
      "db": {
         "type": "object",
         "properties": {
            "@type": {
               "type": "string"
            },
            "oracle_props": {
               "type": "nested",
               "properties": {
                  "@name": {
                     "type": "string"
                  },
                  "@value": {
                     "type": "long"
                  }
               }
            }
         }
      }
   }
}

规则标准

列出文档，其中鸣叫与name Athena和Oracle database具有opencursors less than recommendaed value 4000或当opencursors is not present。

因此，/twitter/tweet/1仅当以下条件匹配时，以上文档才应返回结果。

  1. 如果（name ==“ Athena”）&&（db。@ type包含“ Oracle”关键字）
  2. 和（如果（（（“ open_cursors” @value <4000）或（“ open_cursors”在“ db.oracle_props。@ name”下找不到）

以下是与以上文档匹配但缺少最后一个条件的搜索查询 （即使在“ db.oracle_props。@ name”下缺少“
open_cursors”键，也显示文档“ / twitter / tweet / 1”）

GET /twitter/tweet/_search
{
   "query": {
      "bool": {
         "must": [
            {
               "match": {
                  "tweet.name": "Athena"
               }
            },
            {
               "match": {
                  "tweet.db.@type": "Oracle"
               }
            }
         ],
         "should": [
            {
               "nested": {
                  "path": "db.oracle_props",
                  "query": {
                     "bool": {
                        "must": [
                           {
                              "term": {
                                 "db.oracle_props.@name": "open_cursors"
                              }
                           },
                           {
                              "range": {
                                 "db.oracle_props.@value": {
                                    "lt": 4001
                                 }
                              }
                           }
                        ]
                     }
                  }
               }
            }
         ],
         "minimum_should_match": 1
      }
   }
}

问题答案：

如果我理解您的要求正确，那么我将设置一些示例文档，这些文档应与我的评论正确或不正确匹配：

// All good, should match
curl -XPUT 'http://localhost:9200/twitter/tweet/1' -d '{
    "name": "Athena",
    "version": 1,
    "db": {
        "@type": "Oracle Database 10g Enterprise Edition Release 10.2.0.4.0 64bit",
        "oracle_props": [
            {
                "@name": "open_cursors",
                "@value": 4000
            },
            {
                "@name": "USER_ROLE_PRIVS_COUNT",
                "@value": 1
            },
            {
                "@name": "CREATE_PERMISSION",
                "@value": "Y"
            }
        ]
    }
}'

// open cursors missing, should match
curl -XPUT 'http://localhost:9200/twitter/tweet/2' -d '{
    "name": "Athena",
    "version": 1,
    "db": {
        "@type": "Oracle Database 10g Enterprise Edition Release 10.2.0.4.0 64bit",
        "oracle_props": [
            {
                "@name": "USER_ROLE_PRIVS_COUNT",
                "@value": 2
            },
            {
                "@name": "CREATE_PERMISSION",
                "@value": "N"
            }
        ]
    }
}'

// open_cursors less than 4000, should match
curl -XPUT 'http://localhost:9200/twitter/tweet/3' -d '{
    "name": "Athena",
    "version": 1,
    "db": {
        "@type": "Oracle Database 10g Enterprise Edition Release 10.2.0.4.0 64bit",
        "oracle_props": [
            {
                "@name": "open_cursors",
                "@value": 2134
            },
            {
                "@name": "USER_ROLE_PRIVS_COUNT",
                "@value": 6
            },
            {
                "@name": "CREATE_PERMISSION",
                "@value": "N"
            }
        ]
    }
}'

// Different name, shouldn't match
curl -XPUT 'http://localhost:9200/twitter/tweet/4' -d '{
    "name": "Alexandroupolis",
    "version": 1,
    "db": {
        "@type": "Oracle Database 10g Enterprise Edition Release 10.2.0.4.0 64bit",
        "oracle_props": [
            {
                "@name": "open_cursors",
                "@value": 4000
            },
            {
                "@name": "USER_ROLE_PRIVS_COUNT",
                "@value": 1
            },
            {
                "@name": "CREATE_PERMISSION",
                "@value": "Y"
            }
        ]
    }
}'

// open_cursors more than 4000, shouldn't match
curl -XPUT 'http://localhost:9200/twitter/tweet/5' -d '{
    "name": "Athena",
    "version": 1,
    "db": {
        "@type": "Oracle Database 10g Enterprise Edition Release 10.2.0.4.0 64bit",
        "oracle_props": [
            {
                "@name": "open_cursors",
                "@value": 6500
            },
            {
                "@name": "USER_ROLE_PRIVS_COUNT",
                "@value": 1
            },
            {
                "@name": "CREATE_PERMISSION",
                "@value": "Y"
            }
        ]
    }
}'

因此，我们有3个文档（ID 1,2,3）应该返回。

我发现的解决方案似乎很复杂，也许其他人可以提供一种更简单的方法来解决此问题？

我已经设置了一个过滤查询，以便能够使用OR过滤器

curl -XGET 'http://localhost:9200/twitter/tweet/_search?pretty=true' -d '
{
    "query" : {
        "filtered" : {
            "filter" : {
                /* Set up two conditions */
                "or" : [
                    /* First */
                    {
                        /* Check for open_cursors AND value < 4000 */
                        "bool" : {
                            "must" : [
                                /* Same nested query as in other questions answer */
                                {
                                    "nested" : {
                                        "path" : "db.oracle_props",
                                        "filter" : {
                                            "bool" : {
                                                "must" : [
                                                    {
                                                    "term": {
                                                        "db.oracle_props.@name": "open_cursors"
                                                    }
                                                },
                                                {
                                                    "range": {
                                                        "db.oracle_props.@value": {
                                                            "lte": 4000
                                                        }
                                                    }
                                                }
                                                ]
                                            }
                                        }
                                    }
                                }
                            ]
                        }
                    },
                    /* OR */
                    {
                        "bool" : {
                            /* watch out: negation, this MUST NOT be found*/
                            "must_not" : [
                                {
                                    "nested" : {
                                        "path" : "db.oracle_props",
                                        "filter" : {
                                            "bool" : {
                                                /* We do not want open_cursors to be in the nested document */
                                                "must" : [
                                                    {
                                                    "term": {
                                                        "db.oracle_props.@name": "open_cursors"
                                                    }
                                                }
                                                ]
                                            }
                                        }
                                    }
                                }
                            ]
                        }
                    }
                ]
            },
            /* the query for the non-nested things */
            "query" : {
                "bool" : {
                    "must" : [
                        {
                            "match" : {"tweet.name" : "Athena"}
                        },
                        {
                            "match" : {"tweet.db.@type" : "Oracle"}
                        }
                    ]
                }
            }
        }
    }
}
'

退回文件1,2和3。

更新：这是一个更简单的解决方案，也应该起作用。谢谢@TuanHuynh

curl -XGET 'http://localhost:9200/twitter/tweet/_search?pretty=true' -d '
{
    "query" : {
        "filtered" : {
            "filter" : {
                /* Set up two conditions */
                "or" : [
                    /* First */
                    {
                        "nested" : {
                            "path" : "db.oracle_props",
                            "filter" : {
                                "bool" : {
                                    "must" : [
                                        {
                                        "term": {
                                            "db.oracle_props.@name": "open_cursors"
                                        }
                                    },
                                    {
                                        "range": {
                                            "db.oracle_props.@value": {
                                                "lte": 4000
                                            }
                                        }
                                    }
                                    ]
                                }
                            }
                        }
                    },
                    /* OR */
                    {
                        "nested" : {
                            "path" : "db.oracle_props",
                            "filter" : {
                                "bool" : {
                                    /* We do not want open_cursors to be in the nested document */
                                    "must" : [
                                        {
                                        "term": {
                                            "db.oracle_props.@name": "open_cursors"
                                        }
                                    }
                                    ]
                                }
                            }
                        }
                    }
                ]
            },
            /* the query for the non-nested things */
            "query" : {
                "bool" : {
                    "must" : [
                        {
                            "match" : {"tweet.name" : "Athena"}
                        },
                        {
                            "match" : {"tweet.db.@type" : "Oracle"}
                        }
                    ]
                }
            }
        }
    }
}
'


 类似资料：
  • Elasticsearch：查询嵌套对象

    尊敬的弹性搜索专家， 我在查询嵌套对象时遇到问题。允许使用以下简化映射： 并将一些文档放在索引中： 现在我想执行这样的查询： 因此，我想得到匹配的公司与数量匹配的文件。因此，上面的查询应该会告诉我： 以下查询： 应该给我所有公司分配到一个文件，其标题包含“GPU”与匹配的文件数量: 如果表现良好，是否有可能实现这一结果？我显然对匹配的文档不感兴趣，只对匹配文档和嵌套对象的数量感兴趣。 谢谢你的帮助

  • Elasticsearch：路径下的嵌套对象不是嵌套类型

    问题内容： 我一直在尝试搜索包含嵌套字段的文档。我创建了这样的嵌套映射： 我的搜索如下所示： 但是我收到此错误消息： 编辑 我仍然收到此错误。我正在通过Java执行此操作，因此这是我要创建的文档： 像这样创建索引： 我认为我可能对文档编制了错误的索引。 问题答案： TLDR：输入您的嵌套类型。 假设我们有一个普通类型，并且嵌套了另一个类型： 该行是分配给的嵌套查询所必需的，如下所示： 该行似乎仅在

  • 带有嵌套对象的elasticsearch嵌套查询

    问题内容： 这是我在elasticsearch中存储在索引上的数据类型。我必须找到包含主要成分牛肉（且重量小于1000）和成分-（辣椒粉且重量小于250），（橄榄油和重量小于300）以及所有其他成分类似的食谱。 索引的映射是 我的查询是 但这给了Null。有人可以帮我吗？我认为我没有正确使用嵌套查询 问题答案： 试试这个：

  • 带有嵌套对象查询的Elasticsearch

    我有一个带有嵌套映射的索引。我想预先形成一个查询，该查询将返回以下内容：给我搜索词中每个单词出现在一个或多个嵌套文档中的所有文档。 以下是索引： 以下是我尝试的最新查询： 例如，如果我搜索单词“食物和水”，我希望每个单词至少出现在嵌套文档中。即使只有一个单词存在，当前搜索也会返回文档 谢谢你的帮助！ 更新：正如克里斯托所建议的，解决方案有效。现在我有以下问题。 这是我的索引： 我要执行的查询是，如

  • ElasticSearch Java Client查询嵌套对象

    问题内容： 如何转换这种查询。 使用QueryBuilders进行Java客户端查询 问题答案： 以下Java代码将生成您的查询 参数为： 参数为：

  • 使用PropType对嵌套对象属性进行类型检查

    问题内容： 我有以下我想用流程注释的内容： 我知道该怎么做了类型检查，这样的类型的（如上图所示），但我怎么能型检查其属性呢？ 已经尝试过： 但是随后流程只是抱怨而从未使用过。 问题答案： 因此，您要发送类型为的道具，该道具必须具有属性和？ 如果没有编写执行此检查的自定义函数，则无法实现。为此，您需要这样声明： 这是官方文档所说的： 您还可以指定一个自定义验证器。如果验证失败，它将返回一个Error

相关阅读

如何在elasticsearch中避免嵌套类型的跨对象搜索行为如何在ElasticSearch / NEST中将单个.NET类型映射到多个嵌套对象类型？如何在PHP中检查特定类型的对象Elasticsearch中的嵌套查询Elasticsearch：嵌套对象中的remove / update字段

相关文章

VB.类和对象Kotlin 类和对象Scala 类和对象Ruby 类和对象如何获取ServletContext对象

相关问答

如何递归查找嵌套对象中值的键如何使用NEST在ElasticSearch嵌套对象中搜索Elasticsearch嵌套对象筛选器如何在typescript中检查运行时的对象类型？检查对象的类型[重复]

相关工具

UITable嵌套UITable纵向Table里嵌套横向TableElasticsearchSPT 对象数据库elasticsearch-py

相关文档

你不懂JS: this 与对象原型Mastering Elasticsearch 中文版Python 面向对象Elasticsearch-PHP 中文文档Spring Data Elasticsearch 中文版
快捷导航： 新手教程 算法原理 架构设计 Java进阶 数据库进阶 大厂专栏 面试经验 编程笔记 编程问答 所有专题 文档资料 工具软件 电子书籍 小牛导航
在线工具： 房贷计算器 个税计算器 Linux命令查询 Json格式化 正则表达式 颜色转换 AES加解密 SHA1加密 MD5加密 毒鸡汤 字数统计 随机密码生成 进制转换 Base64编解码 励志句子
Copyright © 2019-2024 小牛知识库@xnip.cn. All Rights Reserved.