es 3期第15节-词项查询与跨度查询实战运用

#### 1.Elasticsearch是数据库，不是普通的Java应用程序，传统数据库需要的硬件资源同样需要，提升性能最有效的就是升级硬件。
#### 2.Elasticsearch是文档型数据库，不是关系型数据库，不具备严格的ACID事务特性，任何企图直接替代严格事务性场景的应用项目都会失败!!!

##### 索引字段与属性都属于静态设置，若后期变更历史数据需要重建索引才可生效
##### 对历史数据无效！！！！
##### 一定要重建索引！！！！

#### 全文文本概念
### 概念介绍
## 1.文章语句分词
## 2.分词之后，支持基于分词检索
## 3.分词算法很多，分词领域很深入
## 4.基于倒排索引算法-Inverted-Index
## 5.分词检索的打分算法TF/IDF=>BM25
## 6.字段类型仅限于text类型

### Term 精确词项概念
# Term词项概念整个语句文字分为一个词
# 1.主要是keyword类型，其余非text字段部分可用2.数据内容有长度限制(2的16次方字节)
## 词项精确查询介绍
# l.Term
# 2.Terms
# 3.Terms Lookup
# 4.Terms set
## 是否需要分值计算
# query:分值计算
# filter:无需分值计算

# 准备数据

DELETE kibana_sample_data_flights_term
POST _reindex
{
  "source": {
    "index": "kibana_sample_data_flights"
  },
  "dest": {
    "index": "kibana_sample_data_flights_term"
  }
}

# 查不出来，因为Dest是text类型

GET kibana_sample_data_flights_term/_search
# 查不出来，因为Dest是text类型
GET kibana_sample_data_flights_term/_search
{
  "track_total_hits": true,
  "query":{
    "bool": {
      "must": [
        {
          "term": {
            "Dest": {
              "value": "Venice Marco Polo Airport"
            }
          }
        }
      ]
    }
  }
}

# 使用Dest.keyword查出来，既然是精确查询也可以不必用must，使用filter

GET kibana_sample_data_flights_term/_search
{
  "track_total_hits": true,
  "query":{
    "bool": {
      "filter": [
        {
          "term": {
            "Dest.keyword": {
              "value": "Venice Marco Polo Airport"
            }
          }
        }
      ]
    }
  }
}

# 去掉一个Airport就查询不出来，注意区分一整个词和分词的区别

GET kibana_sample_data_flights_term/_search
{
  "track_total_hits": true,
  "query":{
    "bool": {
      "filter": [
        {
          "term": {
            "Dest.keyword": {
              "value": "Venice Marco Polo"
            }
          }
        }
      ]
    }
  }
}

# Airport 改为小写的 airport 查询不出来，使用keywod时候es不会做任何处理

GET kibana_sample_data_flights_term/_search
{
  "track_total_hits": true,
  "query":{
    "bool": {
      "filter": [
        {
          "term": {
            "Dest.keyword": {
              "value": "Venice Marco Polo airport"
            }
          }
        }
      ]
    }
  }
}

# 使用term检索数值类型，原则上非text类型都能用term检索

GET kibana_sample_data_flights_term/_search
{
  "track_total_hits": true,
  "query":{
    "bool": {
      "filter": [
        {
          "term": {
            "FlightDelayMin": {
              "value": 30
            }
          }
        }
      ]
    }
  }
}

# 使用range效率没有term高，es对数值类型有两套存储检索方式

GET kibana_sample_data_flights_term/_search
{
  "track_total_hits": true,
  "query":{
    "bool": {
      "filter": [
        {
          "range": {
            "FlightDelayMin": {
              "gte": 20,
              "lte": 36
            }
          }
        }
      ]
    }
  }
}

# case_insensitive, ASCII 是否区分大小写，取值范围true/false，默认false，7.10.0版本之后增加

GET kibana_sample_data_flights_term/_search
{
  "track_total_hits": true,
  "query":{
    "bool": {
      "filter": [
        {
          "term": {
            "OriginCityName.keyword": {
              "value": "warsaw",
              "case_insensitive": true
            }
          }
        }
      ]
    }
  }
}

### terms查询

GET kibana_sample_data_flights_term/_search
{
  "track_total_hits": true,
  "query": {
    "bool": {
      "filter": [
        {
          "terms": {
            "OriginCityName.keyword": [
              "Zurich",
              "Warsaw"
            ]
          }
        }
      ]
    }
  }
}

## terms lookup查询
# 基于指定某条数据的词项作为输入值，生成词项查询条件
# 等同于应用中反向查询某个索引数据，作为输入源
# 非常适用于比较同类型数据，避免应用中二次查询
## 查询参数
# terms，查询关键字入口，查询表达式入口
# index，指定输入源索引
# id，指定输入源数据 id
# path，指定输入源字段路径，特别要注意对象类型数据，以及层次
# routing，可指定输入源数据的路由标签

GET kibana_sample_data_ecommerce/_search
GET kibana_sample_data_ecommerce/_search
{
  "track_total_hits": true,
  "query": {
    "terms": {
      "sku": {
        "index": "kibana_sample_data_ecommerce",
        "id": "9oTR0Y8BbWz2Sn6Eg4wZ",
        "path": "sku",
        "routing":"9oTR0Y8BbWz2Sn6Eg4wZ"
      }
    }
  }
}

## terms_set
# terms_set 也是多个输入值查询，类似与 terms查询，在属性条件上有更多的选择。
# 期望查询的字段的词数量与内容完全符合，而不是只命中其中一个，提供了一种字段数据与字段数据长度自主比较的能力。
## 查询参数
# terms_set，关键字，查询表达式
# terms，关键字，输入查询内容的词数组
# minimum should match field，关键字，指定一个数值类字段，要求输入的搜索内容必须与此值相等
# minimum should match script，关键字，通过脚本计算获取一个字段的长度数值
# boost，关键字，分值加权

GET kibana_sample_data_ecommerce/_search
# 重新准备新数据，使用脚本增加一个manufacturer_count字段，数据来源是manufacturer的长度
POST _reindex
{
  "source": {
    "index": "kibana_sample_data_ecommerce"
  },
  "dest": {
    "index": "kibana_sample_data_ecommerce_term"
  },
  "script": {
    "source": """
      ctx._source.manufacturer_count = ctx._source.manufacturer.length;
    """
  }
}

# terms 查询匹配数量与manufacturer_count一致的数据

GET kibana_sample_data_ecommerce_term/_mappings
GET kibana_sample_data_ecommerce_term/_search
# terms 查询匹配数量与manufacturer_count一致的数据
GET kibana_sample_data_ecommerce_term/_search
{
  "track_total_hits": true,
  "query": {
    "terms_set": {
      "manufacturer.keyword": {
        "terms": [
          "Elitelligence",
          "Oceanavigations",
          "Champion Arts",
          "Pyramidustries"
        ],
        "minimum_should_match_field": "manufacturer_count"
      }
    }
  }
}

# terms 查询匹配数量与脚本返回一致的数据

GET kibana_sample_data_ecommerce_term/_search
{
  "track_total_hits": true,
  "query": {
    "terms_set": {
      "manufacturer.keyword": {
        "terms": [
          "Elitelligence",
          "Oceanavigations",
          "Champion Arts",
          "Pyramidustries"
        ],
        "minimum_should_match_script": {
          "source":"""
            doc['manufacturer.keyword'].length;
          """
        }
      }
    }
  }
}

## Fuzzy 容错查询，非高效率查询
# 有很多应用场景，我们对于输入的内容并无严格的校验，导致入库的内容有错别字，此时需要一定的纠错查询，ES 针对此需求，设计了糊纠错查询。
# fuzzy 查询是一种非常消耗 CPU 资源的查询方式，主要要海量的计算，应该尽量避免或者缩短差值
## 查询参数
# fuzzy，关键字，查询表达式
# value，关键字，查询输入的内容单词，本质应该输入一个错误的词项
# fuzziness，关键字，容错的字符数量，建议设置为严格的数字，取值范围数字或者“AUTO”
# max_expansions，关键字，计算的容错词项数量，默认50，尽量控制这个数量！！组，建议设置更低，性能影响巨大
# prefix_length，关键字，控制容错词的起始位置，从左开始，设置的值应该小于 value 的字符长度，建议设置的更加精确，性能更好
# transpositions，关键字，控制字符前后位置对调来纠错查询，取值范围 true/false，默认 true
# boost，关键字，分值加权
# rewrite，重写查询表达式，此值目前不过渡深入，属于资深人员学习掌握

GET kibana_sample_data_flights_term/_search
# 查询 Washington, 故意把最后一个字母写错Washingtom，可以查出来
GET kibana_sample_data_flights_term/_search
{
  "track_total_hits": true,
  "query": {
    "bool": {
      "must": [
        {
          "fuzzy": {
            "DestCityName.keyword": {
              "value": "Washingtom"
            }
          }
        }
      ]
    }
  }
}

# 查询错误的 Washington, Washingtomm 并设置fuzziness数量为1查不出来，改为2就可以查出来了

GET kibana_sample_data_flights_term/_search
{
  "track_total_hits": true,
  "query": {
    "bool": {
      "must": [
        {
          "fuzzy": {
            "DestCityName.keyword": {
              "value": "Washingtomm",
              "fuzziness":1
            }
          }
        }
      ]
    }
  }
}

## prefix 前缀查询，类说mysql 的like语句
# 基于词项的前缀内容自动匹配后面的内容，只要符合就全部查询出来
## 查询参数
# prefix，关键字，查询表达式
# value，关键字，输入的前缀字符内容
# rewrite，重写参数
# case_insensitive，大小写敏感

# 查询Washington的前缀
GET kibana_sample_data_flights_term/_search
{
  "track_total_hits": true,
  "query": {
    "bool": {
      "must": [
        {
          "prefix": {
            "DestCityName.keyword": {
              "value": "Washing"
            }
          }
        }
      ]
    }
  }
}

## wildcard，通配符查询，基于通配符"*"模糊查询
# ES7.9版本推出了 wildcard 字段类型，基于 ngram 算法，检索效率相比"*"的查询要高
## 查询参数
# wildcard，关键字，查询表达式
# value，关键字，查询输入内容，内容可以采用通配符方式
# boosts，关键字，分值加权
# rewrite，重写表达式
# case_insensitive，大小写敏感

# 在这个索引中DestCityName是text类型，使用通配时要定义成wildcard类型最好
GET kibana_sample_data_flights_term/_mappings
# 通配查询Washington
GET kibana_sample_data_flights_term/_search
{
  "track_total_hits": true,
  "query": {
    "wildcard": {
      "DestCityName.keyword": {
        "value": "*ashington"
      }
    }
  }
}

## exist 逻辑查询
# ES 字段是可以动态扩展的，常规下无任何限制，导致在数据查询时，会造成部分数据字段缺失，从而查询错误，此判断可以有效过滤筛选此类数据

GET kibana_sample_data_ecommerce,kibana_sample_data_ecommerce_term/_search
{
  "track_total_hits":true,
  "query":{
    "exists": {
      "field": "manufacturer_count"
    }
  }
}

## ids查询，本质上等同于MGET

GET kibana_sample_data_ecommerce_term/_doc/9oTR0Y8BbWz2Sn6Eg4wZ
GET kibana_sample_data_ecommerce_term/_search
{
  "query":{
    "ids": {
      "values": [
        "9oTR0Y8BbWz2Sn6Eg4wZ","94TR0Y8BbWz2Sn6Eg4wZ"
        ]
    }
  }
}
// 有限制字符串长度，默认512字节
GET kibana_sample_data_ecommerce_term/_search
{
  "query":{
    "terms": {
      "_id": [
        "9oTR0Y8BbWz2Sn6Eg4wZ","94TR0Y8BbWz2Sn6Eg4wZ"
        ]
    }
  }
}

## range 数值范围查询
# 查询参数
# range，关键字，查询表达式
# gte，关键字，范围值
# # # gt，关键字，范围值
# # lte，关键字，范围值
# lt，关键字，范围值
# boost，关键字，分值加权
# relation，关键字，范围查询关系，针对xxx_range 范围字段才有效

# 数值范围查询
GET kibana_sample_data_flights_term/_search
{
  "track_total_hits": true,
  "query":{
    "range": {
      "FlightDelayMin":
        {
          "gte": 10,
          "lte": 20,
          "boost": 1
        }
    
    }
  }
}

## 时间范围查询
# date，时间是一种特殊的数值类型，还必须考虑到时区，所以建议任何时候都必须使用UTC格式，否则容易出现问题
# range，关键字，查询表达式
# time zone，关键字，时区表达式，增加时区或者减少时区
# 查询某个时间范围类的航班信息，时间范围支持固定时间，也支持动态计算类型

# 查询固定时间
GET kibana_sample_data_flights_term/_search
{
  "track_total_hits": true,
  "query":{
    "range": {
      "timestamp":
        {
          "time_zone": "+00:00", 
          "gte":"2024-03-20T12:09:35",
          "lte": "2024-07-20T12:09:35",
          "boost": 2
        }
    
    }
  }
}
# 查询动态时间
GET kibana_sample_data_flights_term/_search
{
  "track_total_hits": true,
  "query":{
    "range": {
      "timestamp":
        {
          "time_zone": "+00:00", 
          "gte":"now-200d/d",
          "lte": "now",
          "boost": 2
        }
    
    }
  }
}

## ragexp 正则表达式查询，慎用或者禁用，容易出现性能问题！！！有通配符的已经足够了
# 查询参数
# regexp，关键字，查询表达式
# values，关键字，输入内容包括查询表达式

GET kibana_sample_data_flights_term/_search
{
  "track_total_hits": true,
  "query":{
    "regexp": {
      "DestCityName.keyword":
        {
          "value": "Man.*"
        }
    
    }
  }
}

## 词项限制
# terms查询字段数量限制，超过查询会报错，一般也不会超过
# 此设置属于动态设置，可临时修改
# 字段数量限制，默认 65535index.max terms count:65536

### span 跨度查询，全文本查询使用，高级查询，非必须掌握
# span，跨度查询，基于分词词项的精确位置，控制问隔，设定相似度来执行，相比match 匹配类查询，提供了更加底层灵活的查询机制，同时也是非常复杂。
# span，也提供了多种跨度查询方式

# 默认分词会转成小写
POST _analyze
{
  "text":["Hello David so Cool"]
}

## span_term
# span term 等同与 term 查询，区别在于前者是应用在 text类型中，后者是在 keyword 类型
# span term 单独查询仅仅是为了展示，目的是为了后续的关系查询准备
# 查询参数
# span term，关键字，查询表达式
# value，关键字，输入值，注意，默认standard分词下，此处采用统一会转化成小写
# boost，关键字，分值加权

# 大写开头查不出来，注意大小写
GET kibana_sample_data_flights_term/_search
{
  "track_total_hits": true,
  "query": {
    "span_term": {
      "Origin": {
        "value": "edmonton"
      }
    }
  }
}

## span_first
# span_first，跨度第一个词搜索，词项位置属于靠前，从左往右
# 查询参数
# span_first，关键字，查询表达式
# span_term，关键字，指定其中跨度搜索的字段
# end，关键字，控制搜索词项内容的距离，最大位置

# 搜索目的地机场，名字中包含“international”，且从第1个位置不超过2个词;修改查询条件，对比前后查询的结果与数据量。
GET kibana_sample_data_flights_term/_search
{
  "track_total_hits": true,
  "query": {
    "span_first": {
      "match": {
        "span_term": {
          "Dest": "international"
        }
      },
      "end": 2
    }
  }
}

## span near
# span_near，跨度相近位置查询
# 查询参数
# span_near，关键字，查询表达式
# clauses，关键字，组合多个跨度查询
# slop，多个跨度条件直接的间隔
# in_order，多个跨度查询是否按照顺序进行，取值范围true/false

# 搜索目的机场包含“charlotte”与“international“，且中间间隔不超过1个词项，必须按照顺序
GET kibana_sample_data_flights_term/_search
{
  "query": {
    "span_near": {
      "clauses": [
        {
          "span_term": {
            "Dest": {
              "value": "vienna"
            }
          }
        },{
          "span_term": {
            "Dest": {
              "value": "international"
            }
          }
        }
      ],
      "slop": 1,
      "in_order": true
    }
  }
}

## span_or
# span_or，多个跨度词项组合，关系是 or，只要其中任意的满足查询即可
# 查询参数
# span_or，关键字
# clauses，关键字，查询表达式，组成多个跨度查询
# span_term，关键字，跨度查询，必须所有的跨度查询，字段指向一致

GET kibana_sample_data_flights_term/_search
{
  "query": {
    "span_or": {
      "clauses": [
        {
          "span_term": {
            "Dest": {
              "value": "airport"
            }
          }
        },{
          "span_term": {
            "Dest": {
              "value": "international"
            }
          }
        },{
          "span_term": {
            "Dest": {
              "value": "pisa"
            }
          }
        }
      ]
    }
  }
}

## span not
# span_not，组合多个跨度查询，包含其中跨度，不包含其中部分跨度
# 查询参数
# span_not，关键字
# include，关键字，包含
# exclude，关键字，不包含

# 查询目的地机场，词项包含“internationa!”，不包含“Spokane”的航班信息
GET kibana_sample_data_flights_term/_search
{
  "query": {
    "span_not": {
      "include": {
        "span_term": {
          "Dest": {
            "value": "international"
          }
        }
      },
      "exclude": {
        "span_term": {
          "Dest": {
            "value": "spokane"
          }
        }
      }
    }
  }
}

## span_multi
# span_multi，组合多种查询方式,
# 查询参数
# span_multi，关键字，查询表达式
# match，关键字，查询表达式，prefix、term、range、wildcard，fuzzy，参考 term 领域的查询方式

# 搜索目的地机场，词项前缀包括”edmonton“的航班信息
GET kibana_sample_data_flights_term/_search
{
  "query": {
    "span_multi": {
      "match": {
        "prefix": {
          "Dest": {
            "value": "edmonton"
          }
        }
      }
    }
  }
}

## span_containing
# span containing，组合多种跨度查询;little 优先，big次之
# 组合多个条件检索，仅仅返回 little 部分数据

## span_within
# span within，组合多种跨度查询;big优先，little次之
# 组合多个条件检索，仅仅返回 big 部分数据

## field_masking_span
# field_maskingspan，组合多种跨度查询，带有一点伪装的特性。
# 跨越多个字段组合查询

## Specialized 特殊查询
# script
# script，脚本是一种非常灵活的查询方式，同时背后也是有性能代价的若脚本查询的字段需要更多的操作计算，建议可以采用runtime字段方式
# 查询参数
# script，脚本查询表达式入口
# source，脚本内容，必须符合 bool类型;脚本采用painless
# params，输入值参数

# 查询电商信息数据，依据星期数，过滤返回结果
GET kibana_sample_data_ecommerce/_search
{
  "track_total_hits": true,
  "query": {
    "bool": {
      "filter": [
        {
          "script": {
            "script": {
              "source": """
                doc['day_of_week_i'].value==1;
              """,
              "params": {
                "day_of_week_i":1
              }
            }
          }
        }
      ]
    }
  }
}

## script score
# 文本字符查询，ES 默认采用 BM25 计算分值排序，若要需要基于自定义字段分值，可采用script_score
# 同比类同 function_score 一样
# 也支持很多高级函数
# 查询参数
# script score，脚本分值查询关键字，查询表达式入口
# query，查询表达式
# script，脚本计算，自定义分值计算
# boost，加权值
# min_score，最低分值限制

# 基于航班数据，搜索目的包含“warsaw”,排序基于2个时间相加
GET kibana_sample_data_flights_term/_search
{
  "track_total_hits": true,
  "query": {
    "script_score": {
      "query": {
        "match": {
          "Dest": "warsaw"
        }
      },
      "script": {
        "source": """
                doc['FlightDelayMin'].value+doc['FlightTimeMin'].value;
              """
      }
    }
  }
}

## pinned 文档“固定”到搜索结果的顶部
# 对于实现个性化推荐、广告展示或确保某些重要文档始终出现在搜索结果的前面非常有用
# ids：这是一个数组，包含你希望固定的文档的 _id 或其他唯一标识符。这些文档将被固定到搜索结果的顶部。
# field：指定用于匹配文档的字段，默认是 _id。如果你使用的是自定义的唯一标识符字段，可以在这里指定。
# exclude：布尔值，表示是否从最终的搜索结果中排除固定的文档。默认值为 false，即固定的文档仍然会出现在搜索结果中。如果设置为 true，则固定的文档不会出现在最终结果中，但它们的排名信息仍然会被保留。
# inner_hits：可选参数，用于配置返回的固定文档的详细信息。你可以使用 inner_hits 来控制返回的固定文档的数量、排序方式、高亮显示等。
# rest：这是用于查询其他非固定文档的查询条件。你可以在这里使用任何标准的 Elasticsearch 查询 DSL，例如 match、term、bool 等。

GET kibana_sample_data_ecommerce/_search
{
  "query": {
    "pinned": {
      "ids": ["VITR0Y8BbWz2Sn6Eg40a", "U4TR0Y8BbWz2Sn6Eg40a"], 
      "organic": {                        
        "match": {
          "products.product_name": "top"
        }
      }
    }
  }
}

### 查询建议
# Term查询应该大规模使用，属于精确查询
# span慎重应用，了解底层机制优先

# 词项查询
# https://www.elastic.co/guide/en/elasticsearch/reference/8.6/term-level-queries.html
# 跨度查询
# https://www.elastic.co/guide/en/elasticsearch/reference/8.6/span-queries.html
# 特殊查询
# https://www.elastic.co/guide/en/elasticsearch/reference/8.6/specialized-queries.html
# script-score 脚本分值
# https://www.elastic.co/guide/en/elasticsearch/reference/8.6/query-dsl-script-score-guery.htm
# index-max-terms-count
# https://www.elastic.co/guide/en/elasticsearch/reference/8.6/index-modules.html#index-max-terms-count
# fuzziness 取值范围
# https://www.elastic.co/guide/en/elasticsearch/reference/8.6/common-options.html#fuzziness
# fuzzy 计算算法
# https://en.wikipedia.org/wiki/Levenshtein_distance
# rewrite 重写参数
# https://www.elastic.co/guide/en/elasticsearch/reference/8.6/query-dsl-multi-term-rewrite.html
# date-math 时间计算
# https:/www.elastic.co/guide/en/elasticsearch/reference/8.6/common-options.html#date-math