Elastic Stack学习笔记02

ElasticSearch核心详解

文档

元数据（metadata）

• _index 索引
• _type 文档类型
• _id 唯一标识符（默认32位）

查询响应

美化pertty : 使得返回的json更易查看

GET {查询url}?pretty

指定响应字段 : _source

GET /haoke/user/1005?_source=id,name

只返回指定字段 : _source?source=

GET /haoke/user/1005/_source?_source=id,name

判断文档是否存在

HEAD /{索引}/{类型}/{id}

批量操作

批量查询 _mget

POST /{索引}/{类型}/_mget

{
  "ids":["AXqP5R4PXV22eQAormWv","1111"]
}

found:false 表示查询结果不存在

批量增、删、改 _bulk

POST /{索引}/{类型}/_bulk

/* 插入 */
{"create":{"_index":"haoke","_type":"user","_id":2001}}
{"id":2001,"name":"name1","age": 20,"sex": "男"}
{"create":{"_index":"haoke","_type":"user","_id":2002}}
{"id":2002,"name":"name2","age": 20,"sex": "男"}
//最后一行需要有回车

/* 删除 */
{"delete":{"_index":"haoke","_type":"user","_id":2001}}
{"delete":{"_index":"haoke","_type":"user","_id":2002}}
//最后一行需要有回车

分页

size : 结果数，默认10
from : 跳过开始的结果数，默认0

GET /{索引}/{类型}/_search?size=10&from=0

ES 分页会在每个分片生成一次排序结果，最后集中起来汇总排序，因此分页太深或请求太多会影响性能

映射

text ：需要被全文搜索（分词）的字段，如内容，描述
keyword ：结构化字段，如地址，状态，标签

创建映射

PUT /{索引}

{
    "settings":{
        "index":{
            "number_of_shards":"2",
            "number_of_replicas":"0"
        }
    },
    "mappings":{
        "person":{
            "properties":{
                "name":{
                    "type":"text"
                },
                "age":{
                    "type":"integer"
                },
                "mail":{
                    "type":"keyword"
                },
                "hobby":{
                    "type":"text"
                }
            }
        }
    }
}

查看映射

GET /{索引}/_mapping

搜索测试

POST /test/person/_bulk

{"create":{"_index":"test","_type":"person","_id":1}}
{"id":1,"name":"听音乐","age": 20}
{"create":{"_index":"test","_type":"person","_id":2}}
{"id":2,"name":"玩音乐","age": 20}

POST /{索引}/{文档}/_search

{
    "query":{
        "match":{
            "name":"音乐"
        }
    }
}

结构化查询

term查询：精确匹配值。如数字，日期，布尔值

POST /{索引}/{文档}/_search
{
    "query":{
        "term":{
            "age": 20
        }
    }
}

terms查询：多条件匹配

POST /{索引}/{文档}/_search
{
    "query":{
        "terms":{
            "age": [20, 21]
        }
    }
}

range查询：范围匹配

POST /{索引}/{文档}/_search
{
    "query":{
        "range":{
            "age": {
                "gte" : 20
            }
        }
    }
}

exits查询：文档是够包含某字段，相当于SQL的IS NULL条件

POST /{索引}/{文档}/_search
{
    "query":{
        "exists":{
            "field" : "hobby" 
        }    
    }
}

match查询：标准查询，全文本查询，精确查询

POST /{索引}/{文档}/_search
{
    "query":{
        "match":{
            "name" : "音乐" 
        }    
    }
}

bool查询：合并多个查询条件

must 多个条件完全匹配，相当于and
must_not 多个条件相反匹配，相当于not
should 至少有一个条件匹配，相当于or

POST /{索引}/{文档}/_search
{
    "query":{
        "bool": {
            "must": {
                "term":{
                    "age" : 20 
                }
            },
            "must_not": {
                "term":{
                    "name" : "听音乐" 
                }
            },
            "should": [
                {
                    "term":{
                        "name" : "name1" 
                    }
                },
                {
                    "term":{
                        "name" : "name2" 
                    }
                }
            ]
        }
            
    }
}

过滤查询：filter

POST /{索引}/{文档}/_search
{
    "query":{
        "bool" : {
            "filter": {
                "term": {
                    "age": 20
                }
            }    
        }
    }
}

查询和过滤的对比

• 一条过滤语句会询问每个文档的字段值是否包含着特定值。
• 查询语句会询问每个文档的字段值与特定值的匹配程度如何。
• 一条查询语句会计算每个文档与查询语句的相关性，会给出一个相关性评分 _score，并且 按照相关性对匹 配到的文档进行排序。 这种评分方式非常适用于一个没有完全配置结果的全文本搜索。
• 一个简单的文档列表，快速匹配运算并存入内存是十分方便的， 每个文档仅需要1个字节。这些缓存的过滤结果集与后续请求的结合使用是非常高效的。
• 查询语句不仅要查找相匹配的文档，还需要计算每个文档的相关性，所以一般来说查询语句要比 过滤语句更耗时，并且查询结果也不可缓存。

建议：做精确匹配搜索时，最好用过滤语句，因为过滤语句可以缓存数据。