ElasticSearch高级功能

目录

ES数据预处理

Ingest Node

Ingest Node VS Logstash

Ingest Pipeline

Painless Script

ES文档建模

Elasticsearch中处理关联关系

对象类型

嵌套对象(Nested Object)

父子关联关系(Parent / Child )

ES数据预处理

Ingest Node

Elasticsearch 5.0后，引入的一种新的节点类型。默认配置下，每个节点都是Ingest Node：
1. 具有预处理数据的能力，可拦截lndex或 Bulk API的请求。
2. 对数据进行转换，并重新返回给Index或 Bulk APl。

无需Logstash，就可以进行数据的预处理，例如：
1. 为某个字段设置默认值。
2. 重命名某个字段的字段名。
3. 对字段值进行Split 操作。
4. 支持设置Painless脚本，对数据进行更加复杂的加工。

Ingest Node VS Logstash

Logstash

Ingest Node

数据输入与输出

支持从不同的数据源读取，并写入不同的数据源

支持从ES REST API获取数据，并且写入Elasticsearch

数据缓冲

实现了简单的数据队列，支持重写

不支持缓冲

数据处理

支持大量的插件，也支持定制开发

内置的插件，可以开发Plugin进行扩展(Plugin更新需要重启)

配置和使用

增加了一定的架构复杂度

无需额外部署

Ingest Pipeline

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

案例：后期需要对Tags进行Aggregation统计。Tags字段中，逗号分隔的文本应该是数组，而不是一个字符串。

#Blog数据，包含3个字段，tags用逗号间隔
PUT tech_blogs/_doc/1
{
  "title":"Introducing big data......",
  "tags":"hadoop,elasticsearch,spark",
  "content":"You konw, for big data"
}
# 测试split tags
POST _ingest/pipeline/_simulate
{
  "pipeline": {
    "description": "to split blog tags",
    "processors": [
      {
        "split": {
          "field": "tags",
          "separator": ","
        }
      }
    ]
  },
  "docs": [
    {
      "_index": "index",
      "_id": "1",
      "_source": {
        "title": "Introducing big data......",
        "tags": "hadoop,elasticsearch,spark",
        "content": "You konw, for big data"
      }
    },
    {
      "_index": "index",
      "_id": "2",
      "_source": {
        "title": "Introducing cloud computering",
        "tags": "openstack,k8s",
        "content": "You konw, for cloud"
      }
    }
  ]
}

#同时为文档，增加一个字段。blog查看量
POST _ingest/pipeline/_simulate
{
  "pipeline": {
    "description": "to split blog tags",
    "processors": [
      {
        "split": {
          "field": "tags",
          "separator": ","
        }
      },
      {
        "set":{
          "field": "views",
          "value": 0
        }
      }
    ]
  },

  "docs": [
    {
      "_index":"index",
      "_id":"1",
      "_source":{
        "title":"Introducing big data......",
        "tags":"hadoop,elasticsearch,spark",
        "content":"You konw, for big data"
      }
    },
    {
      "_index":"index",
      "_id":"2",
      "_source":{
        "title":"Introducing cloud computering",
        "tags":"openstack,k8s",
        "content":"You konw, for cloud"
      }
    }
    ]
}

创建pipeline

# 为ES添加一个 Pipeline
PUT _ingest/pipeline/blog_pipeline
{
  "description": "a blog pipeline",
  "processors": [
      {
        "split": {
          "field": "tags",
          "separator": ","
        }
      },

      {
        "set":{
          "field": "views",
          "value": 0
        }
      }
    ]
}

#查看Pipleline
GET _ingest/pipeline/blog_pipeline

使用pipeline更新数据

#不使用pipeline更新数据
PUT tech_blogs/_doc/1
{
  "title":"Introducing big data......",
  "tags":"hadoop,elasticsearch,spark",
  "content":"You konw, for big data"
}

#使用pipeline更新数据
PUT tech_blogs/_doc/2?pipeline=blog_pipeline
{
  "title": "Introducing cloud computering",
  "tags": "openstack,k8s",
  "content": "You konw, for cloud"
}

Painless Script

       自Elasticsearch 5.x后引入，专门为Elasticsearch 设计，扩展了Java的语法。Painless支持所有Java 的数据类型及Java API子集。

Painless Script具备以下特性：

1. 高性能/安全。

2. 支持显示类型或者动态定义类型。

通过Painless脚本访问字段

上下文

语法

Ingestion

ctx.field_name

Update

ctx._source.field_name

Search & Aggregation

doc["field_name"]

测试

# 增加一个 Script Prcessor
POST _ingest/pipeline/_simulate
{
  "pipeline": {
    "description": "to split blog tags",
    "processors": [
      {
        "split": {
          "field": "tags",
          "separator": ","
        }
      },
      {
        "script": {
          "source": """
          if(ctx.containsKey("content")){
            ctx.content_length = ctx.content.length();
          }else{
            ctx.content_length=0;
          }

          """
        }
      },

      {
        "set":{
          "field": "views",
          "value": 0
        }
      }
    ]
  },

  "docs": [
    {
      "_index":"index",
      "_id":"1",
      "_source":{
        "title":"Introducing big data......",
  "tags":"hadoop,elasticsearch,spark",
  "content":"You konw, for big data"
      }
    },


    {
      "_index":"index",
      "_id":"2",
      "_source":{
        "title":"Introducing cloud computering",
  "tags":"openstack,k8s",
  "content":"You konw, for cloud"
      }
    }

    ]
}

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

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

# 查看views计数
POST tech_blogs/_search



#保存脚本在 Cluster State
POST _scripts/update_views
{
  "script":{
    "lang": "painless",
    "source": "ctx._source.views += params.new_views"
  }
}

POST tech_blogs/_update/1
{
  "script": {
    "id": "update_views",
    "params": {
      "new_views":1000
    }
  }
}


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": {}
  }
}

ES文档建模

Elasticsearch中处理关联关系

       关系型数据库范式化（Normalize）设计的主要目标是减少不必要的更新，往往会带来一些副作用：一个完全范式化设计的数据库会经常面临“查询缓慢”的问题。数据库越范式化，就需要Join越多的表。范式化节省了存储空间，但是存储空间已经变得越来越便宜。范式化简化了更新，但是数据读取操作可能更多。

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

优点: 无需处理Join操作，数据读取性能好。Elasticsearch可以通过压缩_source字段，减少磁盘空间的开销。

缺点: 不适合在数据频繁修改的场景。 一条数据的改动，可能会引起很多数据的更新。

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

Elasticsearch并不擅长处理关联关系，一般会采用以下四种方法处理关联：

对象类型

嵌套对象(Nested Object)

父子关联关系(Parent / Child )

应用端关联

对象类型

案例1： 博客作者信息变更

对象类型：

1. 在每一博客的文档中都保留作者的信息。

2. 如果作者信息发生变化，需要修改相关的博客文档。

DELETE blog
# 设置blog的 Mapping
PUT /blog
{
  "mappings": {
    "properties": {
      "content": {
        "type": "text"
      },
      "time": {
        "type": "date"
      },
      "user": {
        "properties": {
          "city": {
            "type": "text"
          },
          "userid": {
            "type": "long"
          },
          "username": {
            "type": "keyword"
          }
        }
      }
    }
  }
}

# 插入一条 blog信息
PUT /blog/_doc/1
{
  "content":"I like Elasticsearch",
  "time":"2024-01-01T00:00:00",
  "user":{
    "userid":1,
    "username":"zhangsan",
    "city":"beijing"
  }
}


# 查询 blog信息
POST /blog/_search
{
  "query": {
    "bool": {
      "must": [
        {"match": {"content": "Elasticsearch"}},
        {"match": {"user.username": "zhangsan"}}
      ]
    }
  }
}

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

DELETE /my_movies
# 电影的Mapping信息
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"
    }

  ]
}

# 查询电影信息
POST /my_movies/_search
{
  "query": {
    "bool": {
      "must": [
        {"match": {"actors.first_name": "Keanu"}},
        {"match": {"actors.last_name": "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}}
        }
      }
    }
}

POST /my_movies/_doc/1
{
  "title":"Speed",
  "actors":[
    {
      "first_name":"Keanu",
      "last_name":"Reeves"
    },

    {
      "first_name":"Dennis",
      "last_name":"Hopper"
    }

  ]
}

# Nested 查询
POST /my_movies/_search
{
  "query": {
    "bool": {
      "must": [
        {"match": {"title": "Speed"}},
        {
          "nested": {
            "path": "actors",
            "query": {
              "bool": {
                "must": [
                  {"match": {
                    "actors.first_name": "Keanu"
                  }},

                  {"match": {
                    "actors.last_name": "Hopper"
                  }}
                ]
              }
            }
          }
        }
      ]
    }
  }
}

父子关联关系(Parent / Child )

对象和Nested对象的局限性: 每次更新，可能需要重新索引整个对象(包括根对象和嵌套对象)

ES提供了类似关系型数据库中Join 的实现。使用Join数据类型实现，可以通过维护Parent/ Child的关系，从而分离两个对象。

1.父文档和子文档是两个独立的文档。

2. 更新父文档无需重新索引子文档。子文档被添加，更新或者删除也不会影响到父文档和其他的子文档。

设定 Parent/Child Mapping

DELETE /my_blogs

# 设定 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参数来保证，分配到相同的分片。

查询

# 查询所有文档
POST /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" : {
                "match": {
                    "username" : "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 Object

Parent / Child

优点

文档存储在一起，读取性能高

父子文档可以独立更新

缺点

更新嵌套的子文档时，需要更新整个文档

需要额外的内存维护关系。读取性能相对差

适用场景

子文档偶尔更新，以查询为主

子文档更新频繁

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/397472.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

从可靠性的角度理解 tcp

从可靠性的角度理解 tcp

可靠性是 tcp 最大的特点。常见的用户层协议，比如 http, ftp, ssh, telnet 均是使用的 tcp 协议。可靠性，即从用户的角度来看是可靠的，只要用户调用系统调用返回成功之后，tcp 协议栈保证将报文发送到对端。引起不可靠的表现主要有…
阅读更多...
频段划分学习射频知识的意义

频段划分学习射频知识的意义

一、射频电路设计与低频电路设计的不同点 随着频率提高，相应电磁波的波长与变得可与分立电路元件的尺寸相比拟时，电阻、电容和电感这些元件的电响应，将偏离他们的理想频率特性。以 WIFI 2.4G 频段为例，当频率为 2437MHz&#xff0…
阅读更多...
【QT】QFile读取.txt文本文件时，中文乱码问题（已解决）

【QT】QFile读取.txt文本文件时，中文乱码问题（已解决）

目录 0.背景 1.修改方法 0.背景 项目读取一个【.txt】文本文件，显示到下拉框中，其中含有中文，在读取中文相关字段时会出现乱码，代码和显示如下 .txt文本内容如下（显示到下拉框时，我做了分割处理&#xff…
阅读更多...
代码随想录 Leetcode509. 斐波那契数

代码随想录 Leetcode509. 斐波那契数

题目&#xff1a; 代码&#xff08;首刷自解 2024年2月19日&#xff09;&#xff1a; class Solution { public:int fib(int n) {if (n < 2) return n;/*三个数表示加法算式里的 加数 加数 和*//*初始化*/int leftVal 0;int rightVal 1;int sum 0;for (int i 2; i <…
阅读更多...
智慧城市的新宠儿：会“思考”的井盖

智慧城市的新宠儿：会“思考”的井盖

在城市化飞速发展的今天&#xff0c;我们或许未曾过多地关注那些平凡却至关重要的井盖。它们无声地矗立在城市的每个角落&#xff0c;守护着深藏于地下的城市生命线&#xff0c;然而&#xff0c;这些井盖并未满足于传统的角色&#xff0c;它们正逐步融入智慧城市的宏大画卷中&a…
阅读更多...
【Go语言】Go语言的数据类型

【Go语言】Go语言的数据类型

GO 语言的数据类型 Go 语言内置对以下这些基本数据类型的支持&#xff1a; 布尔类型&#xff1a;bool 整型&#xff1a;int8、byte、int16、int、uint、uintptr 等 浮点类型&#xff1a;float32、float64 复数类型&#xff1a;complex64、complex128 字符串&#xff1a;st…
阅读更多...
Git基本操作（1）

Git基本操作（1）

Git基本操作&#xff08;1&#xff09; 初始化git本地仓库git本地仓库配置git config user.name 和git config user.emailgit config --unset user.name和git config --unset user.emailgit config --global 认识工作区&#xff0c;暂存区&#xff0c;版本库更深层次理解 git a…
阅读更多...
Leetcoder Day15｜ 二叉树 part04

Leetcoder Day15｜ 二叉树 part04

语言&#xff1a;Java/C 110.平衡二叉树 给定一个二叉树&#xff0c;判断它是否是高度平衡的二叉树。 本题中&#xff0c;一棵高度平衡二叉树定义为&#xff1a; 一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。 输入&#xff1a;root [3,9,20,null,null,15,…
阅读更多...
使用LangChain结合通义千问API基于自建知识库的多轮对话和流式输出

使用LangChain结合通义千问API基于自建知识库的多轮对话和流式输出

使用LangChain结合通义千问API基于自建知识库的多轮对话和流式输出 本文章的第三弹&#xff0c;由于LangChain本文不支持直接使用通义千问API进行多轮对话和流式输出&#xff0c;但是自建知识库呢&#xff0c;还需要LangChain,因此我尝试了一下&#xff0c;自建知识库用LangCh…
阅读更多...
OpenAI最新Sora视频学习与生成的技术分析与最新体验渠道

OpenAI最新Sora视频学习与生成的技术分析与最新体验渠道

前言 前些天发现了一个巨牛的人工智能学习网站&#xff0c;通俗易懂&#xff0c;风趣幽默&#xff0c;忍不住分享一下给大家&#xff1a;https://www.captainbed.cn/z ChatGPT体验地址 文章目录 前言OpenAI体验通道Spacetime Latent Patches 潜变量时空碎片, 建构视觉语言系统…
阅读更多...
Unity之闪电侠大战蓝毒兽（简陋的战斗系统）

Unity之闪电侠大战蓝毒兽（简陋的战斗系统）

目录 &#x1f3a8;一、创建地形 &#x1f3ae;二、创建角色 &#x1f3c3;2.1 动画 &#x1f3c3;2.2 拖尾 &#x1f3c3;2.3 角色控制 ​&#x1f3c3;2.4 技能释放 &#x1f3c3;2.5 准星 &#x1f4f1;三、创建敌人 &#x1f432;3.1 选择模型 &#x1f432;3.…
阅读更多...
UI美化stylesheet

UI美化stylesheet

一、网上找到自己喜欢的图标 大家可以每个图标类型找出三种不同的颜色&#xff0c;方便后续美化效果&#xff0c;这里我每种只找了一个。&#xff08;随便找的&#xff0c;最后效果不好看&#xff09; 将这个文件夹复制到项目的文件夹中。 然后右键Add New…选择QT&#xff0c…
阅读更多...
小迪安全27WEB 攻防-通用漏洞SQL 注入Tamper 脚本Base64Jsonmd5 等

小迪安全27WEB 攻防-通用漏洞SQL 注入Tamper 脚本Base64Jsonmd5 等

#知识点&#xff1a; 1、数据表现格式类型注入 2、字符转义绕过-宽字节注入 3、数字&字符&搜索&编码&加密等 #参考资料&#xff1a; https://www.cnblogs.com/bmjoker/p/9326258.html 扫描&#xff0c;利用工具等都不会自动判断数据类型&#xff0c…
阅读更多...
常见面试题：TCP的四次挥手和TCP的滑动窗口

常见面试题：TCP的四次挥手和TCP的滑动窗口

说一说 TCP 的四次挥手。 挥手即终止 TCP 连接&#xff0c;所谓的四次挥手就是指断开一个 TCP 连接时。需要客户端和服务端总共发出四个包&#xff0c;已确认连接的断开在 socket 编程中&#xff0c;这一过程由客户端或服务端任意一方执行 close 来触发。这里我们假设由客户端…
阅读更多...
胶管生产中可自动控制外径的测径仪 你心动吗？

胶管生产中可自动控制外径的测径仪 你心动吗？

摘要&#xff1a;在线测径仪是测控一体的精密仪器&#xff0c;PID闭环控制方法&#xff0c;提升产品外径质量&#xff0c;可以说连测带控才是真绝色&#xff0c;为胶管品质负责。 关键词&#xff1a;胶管测径仪,测径仪,在线测径仪,外径测量仪,直径测量仪 引言 胶管应用领域众多…
阅读更多...
2024最新软件测试面试题（带答案）

2024最新软件测试面试题（带答案）

1. 请自我介绍一下(需简单清楚的表述自已的基本情况&#xff0c;在这过程中要展现出自信&#xff0c;对工作有激情&#xff0c;上进&#xff0c;好学) 面试官您好&#xff0c;我叫###&#xff0c;今年26岁&#xff0c;来自江西九江&#xff0c;就读专业是电子商务&#xff0c;毕…
阅读更多...
若依不分离版本部署流程

若依不分离版本部署流程

一、分离与不分离的区别 参考博客&#xff1a;前后端分离与不分离的本质区别&#xff01;_前后端分离本质-CSDN博客 概念适用场景前后端不分离前端页面看到的效果都是由后端控制&#xff0c;由后端渲染页面或重定向适合纯网页应用前后端分离后端仅返回前端所需的数据&#xf…
阅读更多...
《汇编语言》- 读书笔记 - 实验 10 编写子程序

《汇编语言》- 读书笔记 - 实验 10 编写子程序

《汇编语言》- 读书笔记 - 实验 10 编写子程序 1. 显示字符串问题子程序描述 show_str提示结果演示 2. 解决除法溢出的问题问题子程序描述 divdw提示结果演示 3. 数值显示问题子程序描述 dtoc提示结果演示 在这次实验中&#xff0c;我们将要编写3个子程序&#xff0c;通过它们来…
阅读更多...
UE蓝图 分支(Branch)节点和源码

UE蓝图 分支(Branch)节点和源码

系列文章目录 UE蓝图 Get节点和源码 UE蓝图 Set节点和源码 UE蓝图 Cast节点和源码 UE蓝图 分支(Branch)节点和源码 文章目录 系列文章目录一、分支节点功能二、分支节点用法三、分支节点使用场景四、分支节点实现过程五、分支节点相关源码 一、分支节点功能 在Unreal Engine&a…
阅读更多...
QGis软件 —— 6、QGis - 线与点相互转化操作

QGis软件 —— 6、QGis - 线与点相互转化操作

线转为点 1、创建一条线 2、对线用点进行分割&#xff0c;由于下图单位是"度" 那么需要对该图层做重投影。 3、对线做"重投影图层"操作 4、对线用点进行分割 点转为线 将点转为线&#xff0c;如下动图。通常用作于外出人员采集gps点后通过csv文件导入qgis&…
阅读更多...
最新文章

Copyright @ 2022~2023