处理 Null 值

回到我们早期的示例，在文档中有一个多值的字段 tags，一个文档可能包含一个或多个标签，或根本没有标签。如果一个字段没有值，它是怎么储存在倒排索引中的？

这是一个取巧的问题，因为答案是它根本没有存储。让我们从看一下前几节的倒排索引：

Token DocIDs
open_source 2
search 1,2

你怎么可能储存一个在数据结构不存在的字段呢？倒排索引是标记和包含它们的文档的一个简单列表。假如一个字段不存在，它就没有任何标记，也就意味着它无法被倒排索引的数据结构表达出来。

本质上来说，null，[]（空数组）和 [null] 是相等的。它们都不存在于倒排索引中！

显然，这个世界却没有那么简单，数据经常会缺失字段，或包含空值或空数组。为了应对这些情形，Elasticsearch 有一些工具来处理空值或缺失的字段。

exists 过滤器

工具箱中的第一个利器是 exists 过滤器，这个过滤器将返回任何包含这个字段的文档，让我们用标签来举例，索引一些示例文档：

  1. POST /my_index/posts/_bulk
  2. { "index": { "_id": "1"              }}
  3. { "tags" : ["search"]                }  <1>
  4. { "index": { "_id": "2"              }}
  5. { "tags" : ["search", "open_source"] }  <2>
  6. { "index": { "_id": "3"              }}
  7. { "other_field" : "some data"        }  <3>
  8. { "index": { "_id": "4"              }}
  9. { "tags" : null                      }  <4>
  10. { "index": { "_id": "5"              }}
  11. { "tags" : ["search", null]          }  <5>

<1> tags 字段有一个值

<2> tags 字段有两个值

<3> tags 字段不存在

<4> tags 字段被设为 null

<5> tags 字段有一个值和一个 null

结果我们 tags 字段的倒排索引看起来将是这样：

Token DocIDs
open_source 2
search 1,2,5

我们的目标是找出所有设置了标签的文档，我们不关心这个标签是什么，只要它存在于文档中就行。在 SQL 语法中，我们可以用 IS NOT NULL 查询：

  1. SELECT tags
  2. FROM   posts
  3. WHERE  tags IS NOT NULL

在 Elasticsearch 中，我们使用 exists 过滤器：

  1. GET /my_index/posts/_search
  2. {
  3.     "query" : {
  4.         "filtered" : {
  5.             "filter" : {
  6.                 "exists" : { "field" : "tags" }
  7.             }
  8.         }
  9.     }
  10. }

查询返回三个文档：

  1. "hits" : [
  2.     {
  3.       "_id" :     "1",
  4.       "_score" :  1.0,
  5.       "_source" : { "tags" : ["search"] }
  6.     },
  7.     {
  8.       "_id" :     "5",
  9.       "_score" :  1.0,
  10.       "_source" : { "tags" : ["search", null] } <1>
  11.     },
  12.     {
  13.       "_id" :     "2",
  14.       "_score" :  1.0,
  15.       "_source" : { "tags" : ["search", "open source"] }
  16.     }
  17. ]

<1> 文档 5 虽然包含了一个 null 值，仍被返回了。这个字段存在是因为一个有值的标签被索引了，所以 null 对这个过滤器没有影响

结果很容易理解，所以在 tags 字段中有值的文档都被返回了。只排除了文档 3 和 4。

missing 过滤器

missing 过滤器本质上是 exists 的反义词：它返回没有特定字段值的文档，像这条 SQL 一样：

  1. SELECT tags
  2. FROM   posts
  3. WHERE  tags IS  NULL

让我们在前面的例子中用 missing 过滤器来取代 exists：

  1. GET /my_index/posts/_search
  2. {
  3.     "query" : {
  4.         "filtered" : {
  5.             "filter": {
  6.                 "missing" : { "field" : "tags" }
  7.             }
  8.         }
  9.     }
  10. }

如你所愿，我们得到了两个没有包含标签字段的文档：

  1. "hits" : [
  2.     {
  3.       "_id" :     "3",
  4.       "_score" :  1.0,
  5.       "_source" : { "other_field" : "some data" }
  6.     },
  7.     {
  8.       "_id" :     "4",
  9.       "_score" :  1.0,
  10.       "_source" : { "tags" : null }
  11.     }
  12. ]

什么时候 null 才表示 null

有时你需要能区分一个字段是没有值，还是被设置为 null。用上面见到的默认行为无法区分这一点，数据都不存在了。幸运的是，我们可以将明确的 null 值用我们选择的占位符来代替

当指定字符串，数字，布尔值或日期字段的映射时，你可以设置一个 null_value 来处理明确的 null 值。没有值的字段仍将被排除在倒排索引外。

当选定一个合适的 null_value 时，确保以下几点：

  • 它与字段的类型匹配，你不能在 date 类型的字段中使用字符串 null_value
  • 它需要能与这个字段可能包含的正常值区分开来，以避免真实值和 null 值混淆

对象的 exists/missing

exists 和 missing 过滤器同样能在内联对象上工作，而不仅仅是核心类型。例如下面的文档：

  1. {
  2.    "name" : {
  3.       "first" : "John",
  4.       "last" :  "Smith"
  5.    }
  6. }

你可以检查 name.first 和 name.last 的存在性，也可以检查 name 的。然而，在【映射】中，我们提到对象在内部被转成扁平化的键值结构，像下面所示：

  1. {
  2.    "name.first" : "John",
  3.    "name.last"  : "Smith"
  4. }

所以我们是怎么使用 exists 或 missing 来检测 name 字段的呢，这个字段并没有真正存在于倒排索引中。

原因是像这样的一个过滤器

  1. {
  2.     "exists" : { "field" : "name" }
  3. }

实际是这样执行的

  1. {
  2.     "bool": {
  3.         "should": [
  4.             { "exists": { "field": { "name.first" }}},
  5.             { "exists": { "field": { "name.last"  }}}
  6.         ]
  7.     }
  8. }

同样这意味着假如 first 和 last 都为空，那么 name 就是不存在的。