Elasticsearch实现mysql的子查询

在Elasticsearch中实现MySQL的子查询可以使用Nested类型或者Join类型来实现。具体实现步骤如下：

1. 使用Nested类型实现子查询

Nested类型是一种特殊的数据类型，它允许嵌套文档类型的结构。在Elasticsearch中，可以使用Nested类型来实现MySQL的子查询，具体步骤如下：

- 创建索引时，将需要嵌套的字段设置为Nested类型；
- 在查询时，使用Nested查询来查询嵌套的文档。

例如，如果我们要查询一个用户的所有订单信息，并且订单信息中包含了商品信息，可以将订单信息设置为Nested类型，然后使用Nested查询来查询订单信息。具体实现代码如下：

PUT /my_index
{
  "mappings": {
    "properties": {
      "user_id": {
        "type": "integer"
      },
      "orders": {
        "type": "nested",
        "properties": {
          "order_id": {
            "type": "integer"
          },
          "order_date": {
            "type": "date"
          },
          "products": {
            "type": "nested",
            "properties": {
              "product_id": {
                "type": "integer"
              },
              "product_name": {
                "type": "text"
              }
            }
          }
        }
      }
    }
  }
}

POST /my_index/_doc
{
  "user_id": 1,
  "orders": [
    {
      "order_id": 1,
      "order_date": "2021-05-01",
      "products": [
        {
          "product_id": 1,
          "product_name": "product1"
        },
        {
          "product_id": 2,
          "product_name": "product2"
        }
      ]
    },
    {
      "order_id": 2,
      "order_date": "2021-05-02",
      "products": [
        {
          "product_id": 3,
          "product_name": "product3"
        },
        {
          "product_id": 4,
          "product_name": "product4"
        }
      ]
    }
  ]
}

POST /my_index/_search
{
  "query": {
    "nested": {
      "path": "orders",
      "query": {
        "bool": {
          "must": [
            {
              "match": {
                "orders.order_id": 1
              }
            },
            {
              "nested": {
                "path": "orders.products",
                "query": {
                  "match": {
                    "orders.products.product_name": "product1"
                  }
                }
              }
            }
          ]
        }
      }
    }
  }
}

2. 使用Join类型实现子查询

Join类型是一种特殊的数据类型，它允许在一个文档中引用另一个文档。在Elasticsearch中，可以使用Join类型来实现MySQL的子查询，具体步骤如下：

- 创建两个索引，分别存储父文档和子文档；
- 在父文档中创建Join字段，并使用Routing来关联子文档；
- 在查询时，使用HasChild查询来查询子文档。

例如，如果我们要查询一个用户的所有订单信息，并且订单信息中包含了商品信息，可以将订单信息存储在子文档中，然后使用Join类型来关联父文档和子文档，具体实现代码如下：

PUT /my_index
{
  "mappings": {
    "properties": {
      "user_id": {
        "type": "integer"
      },
      "order_join": {
        "type": "join",
        "relations": {
          "user": "order"
        }
      }
    }
  }
}

PUT /my_index/_doc/1?routing=1
{
  "user_id": 1,
  "order_join": {
    "name": "user",
    "parent": null
  }
}

PUT /my_index/_doc/2?routing=1
{
  "order_id": 1,
  "order_date": "2021-05-01",
  "user_id": 1,
  "order_join": {
    "name": "order",
    "parent": "1"
  },
  "products": [
    {
      "product_id": 1,
      "product_name": "product1"
    },
    {
      "product_id": 2,
      "product_name": "product2"
    }
  ]
}

PUT /my_index/_doc/3?routing=1
{
  "order_id": 2,
  "order_date": "2021-05-02",
  "user_id": 1,
  "order_join": {
    "name": "order",
    "parent": "1"
  },
  "products": [
    {
      "product_id": 3,
      "product_name": "product3"
    },
    {
      "product_id": 4,
      "product_name": "product4"
    }
  ]
}

POST /my_index/_search
{
  "query": {
    "has_child": {
      "type": "order",
      "query": {
        "bool": {
          "must": [
            {
              "match": {
                "order_id": 1
              }
            },
            {
              "has_child": {
                "type": "product",
                "query": {
                  "match": {
                    "product_name": "product1"
                  }
                }
              }
            }
          ]
        }
      }
    }
  }
}