ElasticSearch 基础案例

案例

以下是30个涵盖不同方面的Elasticsearch开发案例：

创建一个名为products的索引，包含字段name、description和price。
向products索引添加一个产品文档，具有名称、描述和价格。
获取products索引中ID为1的产品文档。
更新products索引中ID为1的产品文档的价格字段。
删除products索引中ID为1的产品文档。
在products索引中搜索包含关键词的产品文档。
过滤products索引中价格大于100的产品文档，并按价格降序排序。
计算products索引中价格的平均值。
计算products索引中价格的最大值。
计算products索引中价格的最小值。
计算products索引中价格的总和。
计算products索引中价格的汇总统计信息。
创建一个名为logs的索引，包含字段timestamp、message和severity。
向logs索引添加一个日志文档，具有时间戳、消息和严重程度。
获取logs索引中最近的10条日志文档。
过滤logs索引中严重程度为"error"的日志文档，并按时间戳升序排序。
计算logs索引中每个严重程度的日志数。
创建一个名为articles的索引，包含字段title、content和tags。
向articles索引添加一个文章文档，具有标题、内容和标签。
获取articles索引中包含特定标签的文章文档。
在articles索引中搜索包含关键词的文章文档，并按相关性排序。
过滤articles索引中包含特定标签的文章文档，并按发布日期降序排序。
计算articles索引中每个标签的文章数。
创建一个名为users的索引，包含字段username、email和age。
向users索引添加一个用户文档，具有用户名、电子邮件和年龄。
获取users索引中年龄在特定范围内的用户文档。
在users索引中搜索具有特定电子邮件的用户文档。
计算users索引中年龄的平均值。
计算users索引中年龄的最大值。
计算users索引中年龄的最小值。

以下是与上述30个案例相关的实战代码示例

创建一个名为products的索引，包含字段name、description和price。

PUT /products
{
  "mappings": {
    "properties": {
      "name": { "type": "text" },
      "description": { "type": "text" },
      "price": { "type": "float" }
    }
  }
}

向products索引添加一个产品文档，具有名称、描述和价格。

POST /products/_doc/1
{
  "name": "iPhone 12",
  "description": "A popular smartphone",
  "price": 999.99
}

获取products索引中ID为1的产品文档。

GET /products/_doc/1

更新products索引中ID为1的产品文档的价格字段。

POST /products/_update/1
{
  "doc": {
    "price": 1099.99
  }
}

删除products索引中ID为1的产品文档。

DELETE /products/_doc/1

在products索引中搜索包含关键词的产品文档。

GET /products/_search
{
  "query": {
    "match": {
      "description": "smartphone"
    }
  }
}

过滤products索引中价格大于100的产品文档，并按价格降序排序。

GET /products/_search
{
  "query": {
    "range": {
      "price": { "gt": 100 }
    }
  },
  "sort": [
    { "price": "desc" }
  ]
}

计算products索引中价格的平均值。

GET /products/_search
{
  "size": 0,
  "aggs": {
    "avg_price": {
      "avg": {
        "field": "price"
      }
    }
  }
}

计算products索引中价格的最大值。

GET /products/_search
{
  "size": 0,
  "aggs": {
    "max_price": {
      "max": {
        "field": "price"
      }
    }
  }
}

计算products索引中价格的最小值。

GET /products/_search
{
  "size": 0,
  "aggs": {
    "min_price": {
      "min": {
        "field": "price"
      }
    }
  }
}

计算products索引中价格的总和。

GET /products/_search
{
  "size": 0,
  "aggs": {
    "sum_price": {
      "sum": {
        "field": "price"
      }
    }
  }
}

计算products索引中价格的汇总统计信息。

GET /products/_search
{
  "size": 0,
  "aggs": {
    "price_stats": {
      "stats": {
        "field": "price"
      }
    }
  }
}

创建一个名为logs的索引，包含字段timestamp、message和severity。

PUT /logs
{
  "mappings": {
    "properties": {
      "timestamp": { "type": "date" },
      "message": { "type": "text" },
      "severity": { "type": "keyword" }
    }
  }
}

向logs索引添加一个日志文档，具有时间戳、消息和严重程度。

POST /logs/_doc/1
{
  "timestamp": "2023-06-05T10:00:00",
  "message": "An error occurred",
  "severity": "error"
}

获取logs索引中最近的10条日志文档。

GET /logs/_search
{
  "size": 10,
  "sort": [
    { "timestamp": "desc" }
  ]
}

过滤logs索引中严重程度为"error"的日志文档，并按时间戳升序排序。

GET /logs/_search
{
  "query": {
    "term": {
      "severity": "error"
    }
  },
  "sort": [
    { "timestamp": "asc" }
  ]
}

计算logs索引中每个严重程度的日志数。

GET /logs/_search
{
  "size": 0,
  "aggs": {
    "severities": {
      "terms": {
        "field": "severity",
        "size": 10
      }
    }
  }
}

创建一个名为articles的索引，包含字段title、content和tags。

PUT /articles
{
  "mappings": {
    "properties": {
      "title": { "type": "text" },
      "content": { "type": "text" },
      "tags": { "type": "keyword" }
    }
  }
}

向articles索引添加一个文章文档，具有标题、内容和标签。

POST /articles/_doc/1
{
  "title": "Introduction to Elasticsearch",
  "content": "Elasticsearch is a distributed search and analytics engine.",
  "tags": ["search", "analytics"]
}

获取articles索引中包含特定标签的文章文档。

GET /articles/_search
{
  "query": {
    "terms": {
      "tags": ["search", "elasticsearch"]
    }
  }
}

在articles索引中搜索包含关键词的文章文档，并按相关性排序。

GET /articles/_search
{
  "query": {
    "match": {
      "content": "distributed search"
    }
  }
}

过滤articles索引中包含特定标签的文章文档，并按发布日期降序排序。

GET /articles/_search
{
  "query": {
    "term": {
      "tags": "elasticsearch"
    }
  },
  "sort": [
    { "publish_date": "desc" }
  ]
}

计算articles索引中每个标签的文章数。

GET /articles/_search
{
  "size": 0,
  "aggs": {
    "tag_counts": {
      "terms": {
        "field": "tags",
        "size": 10
      }
    }
  }
}

创建一个名为users的索引，包含字段username、email和age。

PUT /users
{
  "mappings": {
    "properties": {
      "username": { "type": "keyword" },
      "email": { "type": "keyword" },
      "age": { "type": "integer" }
    }
  }
}

向users索引添加一个用户文档，具有用户名、电子邮件和年龄。

POST /users/_doc/1
{
  "username": "john_doe",
  "email": "john@example.com",
  "age": 30
}

获取users索引中年龄在特定范围内的用户文档。

GET /users/_search
{
  "query": {
    "range": {
      "age": { "gte": 25, "lte": 40 }
    }
  }
}

在users索引中搜索具有特定电子邮件的用户文档。

GET /users/_search
{
  "query": {
    "term": {
      "email": "john@example.com"
    }
  }
}

计算users索引中年龄的平均值。

GET /users/_search
{
  "size": 0,
  "aggs": {
    "avg_age": {
      "avg": {
        "field": "age"
      }
    }
  }
}

计算users索引中年龄的最大值。

GET /users/_search
{
  "size": 0,
  "aggs": {
    "max_age": {
      "max": {
        "field": "age"
      }
    }
  }
}

计算users索引中年龄的最小值。

GET /users/_search
{
  "size": 0,
  "aggs": {
    "min_age": {
      "min": {
        "field": "age"
      }
    }
  }
}