【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`類型在數組結構中的問題：