【Elasticsearch】flattened`类型在查询嵌套数组时可能返回不准确结果的情况

好的！为了更清楚地说明`flattened`类型在查询嵌套数组时可能返回不准确结果的情况，我们可以通过一个具体的例子来展示。这个例子将展示如何在文档中没有完全匹配的嵌套对象时，`flattened`类型仍然可能返回该文档。

示例文档结构

假设你有以下文档结构，其中`addresses`是一个嵌套数组：

```json

PUT /my_index/_doc/1

{

  "user": {

    "id": 1,

    "name": "John Doe",

    "addresses": [

      {

        "street": "123 Main St",

        "city": "Anytown",

        "state": "NY" // 注意这里 state 是 NY，而不是 CA

      },

      {

        "street": "456 Elm St",

        "city": "Othertown",

        "state": "CA" // 注意这里 city 是 Othertown，而不是 Anytown

      }

    ]

  }

}

```

在这个文档中，`addresses`数组包含两个地址对象：

1. 第一个地址对象的`city`是`"Anytown"`，但`state`是`"NY"`。

2. 第二个地址对象的`state`是`"CA"`，但`city`是`"Othertown"`。

查询示例

假设你希望查询所有`city`为`"Anytown"`且`state`为`"CA"`的地址。如果`addresses`字段被定义为`flattened`类型，你可能会写出以下查询：

```json

GET /my_index/_search

{

  "query": {

    "bool": {

      "must": [

        {

          "term": {

            "user.addresses.city": {

              "value": "Anytown"

            }

          }

        },

        {

          "term": {

            "user.addresses.state": {

              "value": "CA"

            }

          }

        }

      ]

    }

  }

}

```

查询结果

由于`flattened`类型会将嵌套结构展开为多个字段路径，Elasticsearch 无法保证`city`和`state`属于同一个嵌套对象。因此，查询可能会返回不准确的结果。

在上面的例子中，`flattened`类型会将`addresses`展开为以下字段路径：

```json

{

  "user.addresses.street.0": "123 Main St",

  "user.addresses.city.0": "Anytown",

  "user.addresses.state.0": "NY",

  "user.addresses.street.1": "456 Elm St",

  "user.addresses.city.1": "Othertown",

  "user.addresses.state.1": "CA"

}

```

当你执行查询时，Elasticsearch 会分别匹配`city`和`state`，但无法保证它们属于同一个嵌套对象。因此，查询可能会返回包含以下内容的文档：

```json

{

  "hits": {

    "total": {

      "value": 1,

      "relation": "eq"

    },

    "max_score": 1.0,

    "hits": [

      {

        "_index": "my_index",

        "_type": "_doc",

        "_id": "1",

        "_score": 1.0,

        "_source": {

          "user": {

            "id": 1,

            "name": "John Doe",

            "addresses": [

              {

                "street": "123 Main St",

                "city": "Anytown",

                "state": "NY"

              },

              {

                "street": "456 Elm St",

                "city": "Othertown",

                "state": "CA"

              }

            ]

          }

        }

      }

    ]

  }

}

```

问题解释

尽管文档中没有完全匹配`city`为`"Anytown"`且`state`为`"CA"`的地址对象，但查询仍然返回了该文档。这是因为`flattened`类型无法保证`city`和`state`属于同一个嵌套对象。具体来说：

• 第一个地址对象的`city`是`"Anytown"`，但`state`是`"NY"`。

• 第二个地址对象的`state`是`"CA"`，但`city`是`"Othertown"`。

由于`flattened`类型将这些字段路径展开后，Elasticsearch 会分别匹配`city`和`state`，而不会检查它们是否属于同一个嵌套对象。因此，只要文档中存在满足条件的字段路径，即使这些字段路径不属于同一个嵌套对象，查询也会返回该文档。

使用`nested`类型的正确结果

如果`addresses`字段被定义为`nested`类型，查询会正确地返回没有匹配结果的情况：

```json

PUT /my_index

{

  "mappings": {

    "properties": {

      "user": {

        "properties": {

          "id": { "type": "integer" },

          "name": { "type": "text" },

          "addresses": { "type": "nested" }

        }

      }

    }

  }

}

```

查询：

```json

GET /my_index/_search

{

  "query": {

    "nested": {

      "path": "user.addresses",

      "query": {

        "bool": {

          "must": [

            {

              "term": {

                "user.addresses.city": {

                  "value": "Anytown"

                }

              }

            },

            {

              "term": {

                "user.addresses.state": {

                  "value": "CA"

                }

              }

            }

          ]

        }

      }

    }

  }

}

```

返回结果：

```json

{

  "hits": {

    "total": {

      "value": 0,

      "relation": "eq"

    },

    "max_score": null,

    "hits": []

  }

}

```

`nested`类型会正确地检查每个嵌套对象的完整性，因此不会返回不匹配的文档。

总结

• `flattened`类型的限制：`flattened`类型会将嵌套结构展开为多个字段路径，无法保证这些字段属于同一个嵌套对象。因此，在查询时可能会返回不准确的结果。

• `nested`类型的优势：`nested`类型可以保持嵌套对象的完整性，支持复杂的嵌套查询，能够精确匹配嵌套结构。

希望这个例子清楚地展示了`flattened`类型在查询嵌套数组时可能返回不准确结果的情况。

这里`flattened`类型在处理嵌套对象时出现不准确结果的问题，主要是因为嵌套对象是列表（数组）结构。当嵌套对象是数组时，`flattened`类型会将数组中的每个对象展开为多个字段路径，而这些字段路径之间没有关联关系，因此无法保证它们属于同一个嵌套对象。
为什么`flattened`类型在数组结构中会出现问题？

当嵌套对象是数组时，`flattened`类型会将数组中的每个对象的字段路径展开为独立的字段。例如，假设你有以下文档结构：

```json
{
  "user": {
    "id": 1,
    "name": "John Doe",
    "addresses": [
      {
        "street": "123 Main St",
        "city": "Anytown",
        "state": "NY"
      },
      {
        "street": "456 Elm St",
        "city": "Othertown",
        "state": "CA"
      }
    ]
  }
}
```

如果`addresses`字段被定义为`flattened`类型，Elasticsearch 会将`addresses`展开为以下字段路径：

```json
{
  "user.addresses.street.0": "123 Main St",
  "user.addresses.city.0": "Anytown",
  "user.addresses.state.0": "NY",
  "user.addresses.street.1": "456 Elm St",
  "user.addresses.city.1": "Othertown",
  "user.addresses.state.1": "CA"
}
```

当你执行查询时，Elasticsearch 会分别匹配这些字段路径，但无法保证它们属于同一个嵌套对象。因此，查询可能会返回不准确的结果。

示例：`flattened`类型在数组结构中的问题

假设你希望查询所有`city`为`"Anytown"`且`state`为`"CA"`的地址。如果`addresses`字段被定义为`flattened`类型，你可能会写出以下查询：

```json
GET /my_index/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "user.addresses.city": {
              "value": "Anytown"
            }
          }
        },
        {
          "term": {
            "user.addresses.state": {
              "value": "CA"
            }
          }
        }
      ]
    }
  }
}
```
由于`flattened`类型将数组中的每个对象的字段路径展开为独立的字段，Elasticsearch 会分别匹配`city`和`state`，但无法保证它们属于同一个嵌套对象。因此，查询可能会返回包含以下内容的文档：

```json
{
  "hits": {
    "total": {
      "value": 1,
      "relation": "eq"
    },
    "max_score": 1.0,
    "hits": [
      {
        "_index": "my_index",
        "_type": "_doc",
        "_id": "1",
        "_score": 1.0,
        "_source": {
          "user": {
            "id": 1,
            "name": "John Doe",
            "addresses": [
              {
                "street": "123 Main St",
                "city": "Anytown",
                "state": "NY"
              },
              {
                "street": "456 Elm St",
                "city": "Othertown",
                "state": "CA"
              }
            ]
          }
        }
      }
    ]
  }
}
```

尽管文档中没有完全匹配`city`为`"Anytown"`且`state`为`"CA"`的地址对象，但查询仍然返回了该文档。这是因为`flattened`类型无法保证`city`和`state`属于同一个嵌套对象。

如果嵌套对象不是数组结构呢？

如果嵌套对象不是数组结构，`flattened`类型通常不会出现这种问题。例如，假设你有以下文档结构：

```json
{
  "user": {
    "id": 1,
    "name": "John Doe",
    "address": {
      "street": "123 Main St",
      "city": "Anytown",
      "state": "CA"
    }
  }
}
```

在这种情况下，`address`是一个嵌套对象，而不是数组。如果`address`字段被定义为`flattened`类型，Elasticsearch 会将`address`展开为以下字段路径：

```json
{
  "user.address.street": "123 Main St",
  "user.address.city": "Anytown",
  "user.address.state": "CA"
}
```
当你执行查询时，Elasticsearch 会匹配这些字段路径，而这些字段路径属于同一个嵌套对象，因此不会出现不准确的结果。
示例：`flattened`类型在非数组结构中的表现

假设你希望查询所有`city`为`"Anytown"`且`state`为`"CA"`的地址。如果`address`字段被定义为`flattened`类型，你可能会写出以下查询：

```json
GET /my_index/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "user.address.city": {
              "value": "Anytown"
            }
          }
        },
        {
          "term": {
            "user.address.state": {
              "value": "CA"
            }
          }
        }
      ]
    }
  }
}
```

返回结果：

```json
{
  "hits": {
    "total": {
      "value": 1,
      "relation": "eq"
    },
    "max_score": 1.0,
    "hits": [
      {
        "_index": "my_index",
        "_type": "_doc",
        "_id": "1",
        "_score": 1.0,
        "_source": {
          "user": {
            "id": 1,
            "name": "John Doe",
            "address": {
              "street": "123 Main St",
              "city": "Anytown",
              "state": "CA"
            }
          }
        }
      }
    ]
  }
}
```
在这种情况下，`flattened`类型可以正确匹配`city`和`state`，因为它们属于同一个嵌套对象。
总结
• `flattened`类型在数组结构中的问题：

• 当嵌套对象是数组时，`flattened`类型会将数组中的每个对象的字段路径展开为独立的字段。

• Elasticsearch 无法保证这些字段路径属于同一个嵌套对象，因此查询可能会返回不准确的结果。

• `flattened`类型在非数组结构中的表现：

• 当嵌套对象不是数组时，`flattened`类型可以正确匹配字段路径，因为这些字段路径属于同一个嵌套对象。

• 查询结果通常是准确的。

因此，`flattened`类型在处理嵌套数组时需要特别小心，而`nested`类型在这种场景下通常是更好的选择，因为它可以保持嵌套对象的完整性并支持复杂的嵌套查询。