Elasticsearch7.17 六 :ES高级功能和数据建模

最新推荐文章于 2024-01-12 15:35:15 发布
最新推荐文章于 2024-01-12 15:35:15 发布
阅读量359 收藏
点赞数
文章标签： elasticsearch 数据库 大数据
原文链接：https://blog.csdn.net/admin522043032/article/details/125430856?spm=1001.2014.3001.5502
版权

ES高级功能和数据建模

文档关联关系处理

关系型数据库范式化（Normalize）设计的主要目标是减少不必要的更新，往往会带来一些副作用：

  • 一个完全范式化设计的数据库会经常面临“查询缓慢”的问题。数据库越范式化，就需要Join越多的表；
  • 范式化节省了存储空间，但是存储空间已经变得越来越便宜；
  • 范式化简化了更新，但是数据读取操作可能更多。

反范式化(Denormalize)的设计不使用关联关系，而是在文档中保存冗余的数据拷贝。

  • 优点: 无需处理Join操作，数据读取性能好。Elasticsearch可以通过压缩_source字段，减少磁盘空间的开销
  • 缺点: 不适合在数据频繁修改的场景。 一条数据的改动，可能会引起很多数据的更新

关系型数据库，一般会考虑Normalize 数据；在Elasticsearch，往往考虑Denormalize 数据。

  • Elasticsearch并不擅长处理关联关系，一般会采用以下四种方法处理关联：
  • 对象类型
  • 嵌套对象(Nested Object)
  • 父子关联关系(Parent / Child )
  • 应用端关联

对象类型
案例1： 博客作者信息
当我们查询博客信息的同时需要知道作者信息，那么把作者信息当成一个对象放到博客信息当中

  • 在每一博客的文档中都保留作者的信息
  • 如果作者信息发生变化，需要修改相关的博客文档
PUT /blog
{
  "mappings": {
    "dynamic":"false",
    "properties": {
      "content":{
        "type": "text"
      },
      "time":{
        "type": "date"
      },
      "user":{
        "properties": {
          "city":{
            "type": "keyword"
          },
          "userid":{
            "type":"long"
          },
          "username":{
            "type":"keyword"
          }
        }
      }
    }
  },
  "settings" : {
        "index" : {
            "analysis.analyzer.default.type": "ik_max_word"
        },
        "number_of_replicas": 1,
        "number_of_shards": 3
    }
}
PUT /blog/_doc/1
{
  "content":"I like Elasticsearch",
  "time":"2022-06-23T17:20:20",
  "user":{
    "userid":1,
    "username":"lsx",
    "city":"厦门"
  }
}
# 查询对应作者的文档
GET blog/_search
{
  "query": {
    "term": {
      "user.username": {
        "value": "lsx"
      }
    }
  }
}

案例2：包含对象数组的文档

PUT /my_movies
{
      "mappings" : {
      "properties" : {
        "actors" : {
          "properties" : {
            "first_name" : {
              "type" : "keyword"
            },
            "last_name" : {
              "type" : "keyword"
            }
          }
        },
        "title" : {
          "type" : "text",
          "fields" : {
            "keyword" : {
              "type" : "keyword",
              "ignore_above" : 256
            }
          }
        }
      }
    }
}

# 写入一条电影信息
POST /my_movies/_doc/1
{
  "title":"Speed",
  "actors":[
    {
      "first_name":"Keanu",
      "last_name":"Reeves"
    },
    {
      "first_name":"Dennis",
      "last_name":"Hopper"
    }
  ]
}
# 根据first_name 和 last_name 查询全名是Keanu Hopper
GET /my_movies/_search
{
  "query": {
    "bool": {
      "must": [
        {"term": { "actors.first_name": "Keanu"}},
        {"term": {"actors.last_name": "Hopper"}}
      ]
    }
  }  
}

文档里面没有全名是Keanu Hopper 这个人，但是依然查了出来。查询出了不需要的数据。为什么会这样？
存储时，内部对象的边界并没有考虑在内,JSON格式被处理成扁平式键值对的结构。当对多个字段进行查询时，导致了意外的搜索结果。可以用Nested Data Type解决这个问题。

嵌套对象(Nested Object)

什么是Nested Data Type

  • Nested数据类型: 允许对象数组中的对象被独立索引
  • 使用nested 和properties 关键字，将所有actors索引到多个分隔的文档
  • 在内部, Nested文档会被保存在两个Lucene文档中，在查询时做Join处理
DELETE /my_movies
# 创建 Nested 对象 Mapping
PUT /my_movies
{
      "mappings" : {
      "properties" : {
        "actors" : {
          "type": "nested",
          "properties" : {
            "first_name" : {"type" : "keyword"},
            "last_name" : {"type" : "keyword"}
          }},
        "title" : {
          "type" : "text",
          "fields" : {"keyword":{"type":"keyword","ignore_above":256}}
        }
      }
    }
}

Nested 查询和普通查询不一样，通过上面的查询是查不出结果的

GET /my_movies/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "nested": {
            "path": "actors",
            "query": {
              "bool": {
                "must": [
                  {"term": {"actors.first_name": "Keanu"}},
                  {"term": {"actors.last_name": "Reeves"}}
                ]
              }
            }
          }
          
        }
      ]
    }
  } 
}
# nested聚合
GET /my_movies/_search
{
  "size": 0,
  "aggs": {
    "actors": {
      "nested": {
        "path": "actors"
      },
      "aggs": {
        "actor_name": {
          "terms": {
            "field": "actors.first_name",
            "size": 10
          }
        }
      }
    }
  }
}

父子关联关系(Parent / Child )

  • 对象和Nested对象的局限性: 每次更新，可能需要重新索引整个对象(包括根对象和嵌套对象)
  • ES提供了类似关系型数据库中Join 的实现。使用Join数据类型实现，可以通过维护Parent/ Child的关系，从而分离两个对象
    父文档和子文档是两个独立的文档；
    更新父文档无需重新索引子文档。子文档被添加，更新或者删除也不会影响到父文档和其他的子文档。

设定 Parent/Child Mapping

PUT /my_blogs
{
  "settings": {
    "number_of_shards": 2
  },
  "mappings": {
    "properties": {
      "blog_comments_relation": {
        "type": "join",
        "relations": {
          "blog": "comment"
        }
      },
      "content": {
        "type": "text"
      },
      "title": {
        "type": "keyword"
      }
    }
  }
}

在这里插入图片描述
索引父文档

#索引父文档
PUT /my_blogs/_doc/blog1
{
  "title":"Learning Elasticsearch",
  "content":"learning ELK ",
  "blog_comments_relation":{
    "name":"blog"
  }
}

#索引父文档
PUT /my_blogs/_doc/blog2
{
  "title":"Learning Hadoop",
  "content":"learning Hadoop",
  "blog_comments_relation":{
    "name":"blog"
  }
}

在这里插入图片描述

索引子文档

#索引子文档
PUT /my_blogs/_doc/comment1?routing=blog1
{
  "comment":"I am learning ELK",
  "username":"Jack",
  "blog_comments_relation":{
    "name":"comment",
    "parent":"blog1"
  }
}

#索引子文档


PUT /my_blogs/_doc/comment2?routing=blog2
{
  "comment":"I like Hadoop!!!!!",
  "username":"Jack",
  "blog_comments_relation":{
    "name":"comment",
    "parent":"blog2"
  }
}

#索引子文档
PUT /my_blogs/_doc/comment3?routing=blog2
{
  "comment":"Hello Hadoop",
  "username":"Bob",
  "blog_comments_relation":{
    "name":"comment",
    "parent":"blog2"
  }
}

在这里插入图片描述
注意：
父文档和子文档必须存在相同的分片上，能够确保查询join 的性能
当指定子文档时候，必须指定它的父文档ld。使用routing参数来保证，分配到相同的分片

查询

# 查询所有文档
GET /my_blogs/_search

#根据父文档ID查看
GET /my_blogs/_doc/blog2

# Parent Id 查询
POST /my_blogs/_search
{
  "query": {
    "parent_id": {
      "type": "comment",
      "id": "blog2"
    }
  }
}

# Has Child 查询,返回父文档
POST /my_blogs/_search
{
  "query": {
    "has_child": {
      "type": "comment",
      "query" : {
                "term": {
                    "username.keyword": "Jack"
                }
            }
    }
  }
}
# Has Parent 查询，返回相关的子文档
POST /my_blogs/_search
{
  "query": {
    "has_parent": {
      "parent_type": "blog",
      "query" : {
                "match": {
                    "title" : "Learning Hadoop"
                }
            }
    }
  }
}

#通过ID ，访问子文档
GET /my_blogs/_doc/comment3
#通过ID和routing ，访问子文档
GET /my_blogs/_doc/comment3?routing=blog2

#更新子文档
PUT /my_blogs/_doc/comment3?routing=blog2
{
    "comment": "Hello Hadoop??",
    "blog_comments_relation": {
      "name": "comment",
      "parent": "blog2"
    }
}

嵌套文档 VS 父子文档

Nested ObjectParent / Child
优点文档存储在一起，读取性能高父子文档可以独立更新
缺点更新嵌套的子文档时，需要更新整个文档需要额外的内存维护关系。读取性能相对差
适用场景子文档偶尔更新，以查询为主子文档更新频繁

Ingest Pipeline & Painless Script

应用场景： 修复与增强写入数据

Ingest Pipeline

Ingest Node
Elasticsearch 5.0后，引入的一种新的节点类型。默认配置下，每个节点都是Ingest Node：

  • 具有预处理数据的能力，可拦截lndex或 Bulk API的请求
  • 对数据进行转换，并重新返回给Index或 Bulk APl

无需Logstash，就可以进行数据的预处理，例如

  • 为某个字段设置默认值;重命名某个字段的字段名;对字段值进行Split 操作
  • 支持设置Painless脚本，对数据进行更加复杂的加工

Pipeline & Processor

  • Pipeline ——管道会对通过的数据(文档)，按照顺序进行加工
  • Processor——Elasticsearch 对一些加工的行为进行了抽象包装
  • Elasticsearch 有很多内置的Processors，也支持通过插件的方式，实现自己的Processor

一些内置的Processors:https://www.elastic.co/guide/en/elasticsearch/reference/7.17/ingest-processors.html

Split Processor ： 将给定字段值分成一个数组
Remove / Rename Processor ：移除一个重命名字段
Append ： 为商品增加一个新的标签
Convert：将商品价格，从字符串转换成float 类型
Date / JSON：日期格式转换，字符串转JSON对象
Date lndex Name Processor︰将通过该处理器的文档,分配到指定时间格式的索引中
Fail Processor︰一旦出现异常，该Pipeline 指定的错误信息能返回给用户
Foreach Process︰数组字段，数组的每个元素都会使用到一个相同的处理器
Grok Processor︰日志的日期格式切割)
Gsub / Join / Split︰字符串替换│数组转字符串/字符串转数组
Lowercase / upcase︰大小写转换

在这里插入图片描述
测试数据

PUT tech_blogs/_doc/1
{
  "title":"Introducing big data......111",
  "tags":"hadoop,elasticsearch,spark",
  "content":"You konw, for big data"
}

PUT tech_blogs/_doc/2
{
  "title":"Introducing big data......222",
  "tags":"java,php,js",
  "content":"You konw, for big data"
}

创建Pipeline
Pipeline的功能，文档中的tags标签，通过，转成数组对象，并且增加views字段

PUT _ingest/pipeline/testPipeline
{
  "description": "test",
  # 定义管道处理器 
  "processors": [
    {
      # 字符串分割处理器
      "split": {
        "field": "tags",
        "separator": ","
      }
    },
    {
      # 字符串分割处理器
      "set": {
        "field": "views",
        "value": "0"
      }
    }
  ]
}
#查看所有管道
GET _ingest/pipeline

索引文档时，通过定义的管道加工数据

PUT tech_blogs/_doc/3?pipeline=testPipeline
{
  "title":"Introducing big data......3333",
  "tags":"mysql,redis,kafka",
  "content":"You konw, for big data"
}

PUT tech_blogs/_doc/4?pipeline=testPipeline
{
  "title":"Introducing big data......4444",
  "tags":"test,text,tttt",
  "content":"You konw, for big data"
}
GET tech_blogs/_doc/4

在这里插入图片描述
借助update_by_query更新已存在的文档

#增加update_by_query的条件
POST tech_blogs/_update_by_query?pipeline=blog_pipeline
{
    "query": {
        "bool": {
            "must_not": {
                "exists": {
                    "field": "views"
                }
            }
        }
    }
}

GET tech_blogs/_search

Ingest Node VS Logstash

LogstashIngest Node
数据输入与输出支持从不同的数据源读取，并写入不同的数据源支持从ES REST API获取数据，并且写入Elasticsearch
数据缓冲实现了简单的数据队列，支持重写不支持缓冲
数据处理支持大量的插件，也支持定制开发内置的插件，可以开发Plugin进行扩展(Plugin更新需要重启)
配置和使用增加了一定的架构复杂度无需额外部署

Painless Script
自Elasticsearch 5.x后引入，专门为Elasticsearch 设计，扩展了Java的语法。6.0开始，ES只支持 Painless。Groovy，JavaScript和 Python 都不再支持。Painless支持所有Java 的数据类型及Java API子集。
Painless Script具备以下特性：

  • 高性能/安全
  • 支持显示类型或者动态定义类型

Painless的用途：

  • 可以对文档字段进行加工处理
  • 更新或删除字段，处理数据聚合操作
  • Script Field:对返回的字段提前进行计算
  • Function Score:对文档的算分进行处理
  • 在lngest Pipeline中执行脚本
  • 在Reindex APl，Update By Query时，对数据进行处理

通过Painless脚本访问字段

上下文语法
Ingestionctx.field_name
Updatectx._source.field_name
Search & Aggregationdoc[“field_name”]

管道中定义脚本代码

PUT _ingest/pipeline/test2PP
{
  "description": "test2",
  "processors": [
    {
      "split": {
        "field": "tags",
        "separator": ","
      }
    },
    { # java 脚本代码 计算content长度
      "script": {
         "source": """
          if(ctx.containsKey("content")){
            ctx.content_length = ctx.content.length();
          }else{
            ctx.content_length=0;
          }
          """
      }
    },
    {
      "set": {
        "field": "views",
        "value": "0"
      }
    }
  ]
}

索引文档的时通过管道执行脚本

PUT tech_blogs/_doc/5?pipeline=test2PP
{
  "title":"Introducing big data......555",
  "tags":"mysql,redis,kafka",
  "content":"You konw, for big data"
}

GET tech_blogs/_doc/5

在这里插入图片描述
更新时执行脚本代码

POST tech_blogs/_update/4
{
  "script": {
    "source": "ctx._source.views += params.new_views",
    "params": {
      "new_views":100
    }
  }
}

定义脚本代码

POST _scripts/testScripts
{
  "script":{
    "lang": "painless",
    "source": "ctx._source.views += params.new_views"
  }
}

执行定义的脚本代码

POST tech_blogs/_update/4
{
  "script": {
    "id": "testScripts",
    "params": {
      "new_views":1000
    }
  }
}

查询中执行脚本代码

DELETE tech_blogs
PUT tech_blogs/_doc/1
{
  "title":"Introducing big data......",
  "tags":"hadoop,elasticsearch,spark",
  "content":"You konw, for big data",
  "views":0
}
GET tech_blogs/_search
{
  "script_fields": {
    "rnd_views": {
      "script": {
        "lang": "painless",
        "source": """
          java.util.Random rnd = new Random();
          doc['views'].value+rnd.nextInt(1000);
        """
      }
    }
  },
  "query": {
    "match_all": {}
  }
}

脚本编译的开销较大，Elasticsearch会将脚本编译后缓存在Cache 中
Inline scripts和 Stored Scripts都会被缓存，默认缓存100个脚本

参数说明
script.cache.max_size设置最大缓存数
script.cache.expire设置缓存超时
script.max_compilations_rate默认5分钟最多75次编译(75/5m)

数据建模建议

建模建议1：如何处理关联关系

  • Object: 优先考虑反范式（Denormalization）
  • Nested: 当数据包含多数值对象，同时有查询需求
  • Child/Parent：关联文档更新非常频繁时

建模建议2: 避免过多字段

一个文档中，最好避免大量的字段

  • 过多的字段数不容易维护
  • Mapping 信息保存在Cluster State 中，数据量过大，对集群性能会有影响
  • 删除或者修改数据需要reindex

默认最大字段数是1000，可以设置index.mapping.total_fields.limit限定最大字段数。

建模建议3︰避免正则，通配符，前缀查询

正则，通配符查询，前缀查询属于Term查询，但是性能不够好。特别是将通配符放在开头，会导致性能的灾难

建模建议4︰避免空值引起的聚合不准

# Not Null 解决聚合的问题
DELETE /scores
PUT /scores
{
  "mappings": {
      "properties": {
        "score": {
          "type": "float",
          "null_value": 0
        }
      }
    }
}

PUT /scores/_doc/1
{
 "score": 100
}
PUT /scores/_doc/2
{
 "score": null
}

POST /scores/_search
{
  "size": 0,
  "aggs": {
    "avg": {
      "avg": {
        "field": "score"
      }
    }
  }
}

如果不在mapping 中加上 “null_value”: 0 那么聚合会出现错误

建模建议5: 为索引的Mapping加入Meta 信息

Mappings设置非常重要，需要从两个维度进行考虑

  • 功能︰搜索，聚合，排序
  • 性能︰存储的开销; 内存的开销; 搜索的性能

Mappings设置是一个迭代的过程

  • 加入新的字段很容易（必要时需要update_by_query)
  • 更新删除字段不允许(需要Reindex重建数据)
  • 最好能对Mappings 加入Meta 信息，更好的进行版本管理
  • 可以考虑将Mapping文件上传git进行管理
逐风&者
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
elasticsearch7.17.9版本分词器插件安装包
11-13
总的来说，这个"elasticsearch7.17.9版本分词器插件安装包"是针对中文环境的Elasticsearch实例增强搜索功能的重要工具，通过IK分词器提供高效的文本分析能力，适用于日志收集、分析等场景。正确安装和配置此插件，...
elasticsearch7.17.10-最新支持Java1.8版本
06-19
Elasticsearch 7.17.10 是一个强大的开源搜索引擎和分析引擎，主要用于全文搜索、结构化搜索、近实时分析以及大数据处理。这个版本特别强调对Java 1.8（即Java 8）的支持，这意味着它可以在运行Java 8的环境中稳定...
【ElasticSearch-基础篇】ES高级查询Query DSL术语级别查询并结合springboot使用
qq_42890164的博客
01-12 2135
【ElasticSearch-基础篇】ES高级查询Query DSL术语级别查询并结合springboot使用
ES-数据建模
蓝天⊙白云的博客
03-20 369
数据模型是描述现实世界某种现象或者状态的物理抽象，比如我们之前用FSA来描述周老师的一天这种现象，就是把现实世界抽象成某种模型。现实世界有很多重要的关联关系：博客帖子有一些评论，银行账户有多次交易记录，客户有多个银行账户，订单有多个订单明细，文件目录有多个文件和子目录。每个实体（或 行 ，在关系世界中）可以被主键唯一标识。实体规范化（范式）。唯一实体的数据只存储一次，而相关实体只存储它的主键。只能在一个具体位置修改这个实体的数据。实体可以进行关联查询，可以跨实体搜索。
Elasticsearch7.17 四 : ElasticSearch集群架构
admin522043032的博客
06-23 2746
分布式系统的可用性与扩展性： 高可用性 服务可用性-允许有节点停止服务 数据可用性-部分节点丢失，不会丢失数据 可扩展性 请求量提升/数据的不断增长(将数据分布到所有节点上) ES集群架构的优势： 提高系统的可用性，部分节点停止服务，整个集群的服务不受影响 存储的水平扩容集群 一个集群可以有一个或者多个节点 不同的集群通过不同的名字来区分，默认名字“elasticsearch“ 通过配置文件修改，或者在命令行中 -E cluster.name=es-cluster进行设定’ 节点 节点是一个Elastics
es 数据建模
qq_38146392的博客
11-18 2190
数据建模 嵌套类型：Nested nested属于object类型的一种，是Elasticsearch中用于复杂类型对象数组的索引操作。Elasticsearch没有内部对象的概念，因此，ES在存储复杂类型的时候会把对象的复杂层次结果扁平化为一个键值对列表。 比如： PUT my-index-000001/_doc/1 { "group" : "fans", "user" : [ { "first" : "John", "last" : "Smith" }
java使用elasticsearchClient调用es7.17-生成连接、查询系统参数、索引相关操作
qq_41444892的博客
08-29 3109
java调用es7.17
Elasticsearch 篇之数据建模
我都不会的博客
02-03 521
Elasticsearch 篇之数据建模 数据建模简介 英文为Data Modeling，为创建数据模型的过程 数据模型Data Model 对现实世界进行抽象描述的一种工具方法 通过抽象的实体及实体之间联系的形式去描述业务规则，从而实现对现实世界的映射 数据建模的过程 概念模型 确定系统的核心需求和范围边界，设计实体和实体之间的关系 逻辑模型 进一步梳理业务需求，确定每个实体...
elasticsearch7.17.11版本分词器插件安装包
11-13
Elasticsearch（简称ES）是一款基于Lucene的分布式、RESTful搜索引擎，广泛应用于日志收集、数据分析等领域，是ELK（Elasticsearch、Logstash、Kibana）堆栈的重要组成部分。在处理中文数据时，合理的分词对于提升...
elasticsearch-7.17.6及对应版本IK分词
02-19
elasticsearch-7.17.6及对应版本IK分词 适合人群：elasticsearch初学者 Elasticsearch 是位于 Elastic Stack 核心的分布式搜索和分析引擎。Logstash 和 Beats 有助于收集、聚合和丰富您的数据并将其存储在 Elastic...
elasticsearch设计思路
10-14
介绍elasticsearch如何实现一个分布式近实时的搜索引擎的
elasticsearch7.17.13版本分词器插件安装包
11-13
Elasticsearch（ES）作为一款强大的开源搜索引擎，广泛应用于日志收集、数据分析等领域。为了提升中文文本处理的能力，安装合适的分词器插件是必不可少的步骤。本文将详细解析如何在Elasticsearch 7.17.13版本上安装...
elasticsearch7.17.8版本分词器插件安装包
11-13
Elasticsearch（ES）是一款流行的开源全文搜索引擎，常用于日志收集、数据分析和实时搜索等场景。在处理中文文本时，分词器插件是必不可少的组件，它能够将中文字符串分解为有意义的词汇单元，以提升搜索的准确性和...
elasticsearch7.17.10版本分词器插件安装包
11-13
在日志收集和数据分析领域，Elasticsearch（简称ES）扮演着重要的角色。作为一个强大的全文搜索引擎，Elasticsearch允许用户通过简单的API进行数据索引、搜索、分析和可视化。然而，为了更好地处理中文等复杂语言，...
elasticsearch7.17.14版本分词器插件安装包
11-13
在日志收集和分析领域，Elasticsearch（简称ES）是广泛应用的搜索引擎和数据分析工具，它与Logstash（数据采集）、Kibana（数据可视化）共同构成了ELK（Elasticsearch、Logstash、Kibana）栈。对于中文处理，分词器...
elasticsearch7.17开发笔记
qq_41444892的博客
08-30 1272
elasticsearch7.17开发笔记
干货 | Elasticsearch 数据建模指南
铭毅天下Elasticsearch
04-25 5194
0、题记我在做 Elasticsearch 相关咨询和培训过程中，发现大家普遍更关注实战中涉及的问题，下面我选取几个常见且典型的问题，和大家一起分析一下。订单表、账单表父子文档可以实现类似 SQL 的左连接吗？通过 canal 同步到 ES 中，能否实现类似左连接的效果？具体应该如何建模？一个人管理 1000 家连锁门店，如何更高效地查询自己管辖的商品类目？企微 一个人...
【ES数据库】商品数据库搭建
Sherry_Yau的博客
05-15 714
下面以医疗器械商品为例，介绍商品数据库如何构建在商品信息模块中，需要明确SPU、SKU、商品类别、商品属性、商品属性模板这 几个名词的定义及其关联。商品信息分为SPU(标准化产品单元，Standard Product Unit)、SKU(最小存货单 位，Stock Keeping Unit)。SPU是用于描述属性值、特性相同的产品最小信息集合，具有可复用、易检索特性。SKU 是描述商品的最小存货单元，通过 SKU 可确定具体的货物存量。
Elasticsearch7.17 三 : ElasticSearch搜索技术深入与聚合查询
huaxinzhang的博客
05-15 412
Elasticsearch7.17 三 : ElasticSearch搜索技术深入与聚合查询
01 - Elasticsearch 简单而高效的管道查询语言 - 刘晓国 重庆 2024.4.27
最新发布
04-29
Elasticsearch 查询语言 (ES|QL) 提供了一种强大的方法来过滤、转换和分析存储在 Elasticsearch 中以及未来其他运行时中的数据。 它旨在易于最终用户、SRE 团队、应用程序开发人员和管理员学习和使用。用户可以编写 ES|QL 查询来查找特定事件、执行统计分析并生成可视化效果。 它支持广泛的命令和功能，使用户能够执行各种数据操作，例如过滤、聚合、时间序列分析等。 Elasticsearch 查询语言 (ES|QL) 使用 “管道”(|) 逐步操作和转换数据。 这种方法允许用户组合一系列操作，其中一个操作的输出成为下一个操作的输入，从而实现复杂的数据转换和分析。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值