Elasticsearch使用總結

原文出自：https://www.2cto.com/database/201612/580142.html

 

ELK干貨：http://www.cnblogs.com/xing901022/p/4704319.html

 

自己存的東西 方便以后看

 

java里面debugger之后把查詢的格式放到 Console - Kibana 里查  工具：Console - Kibana

 

Elasticsearch 2.3.3 JAVA api說明文檔：https://www.blog-china.cn/template/documentHtml/1484101683485.html

 

這是官方對Elasticsearch的定位。通俗的講，Elasticsearch就是一款面向文檔的NoSQL數據庫，使用JSON作為文檔序列化格式。但是，它的高級之處在於，使用Lucene作為核心來實現所有索引和搜索的功能，使得每個文檔的內容都可以被索引、搜索、排序、過濾。同時，提供了豐富的聚合功能，可以對數據進行多維度分析。對外統一使用REST API接口進行溝通，即Client與Server之間使用HTTP協議通信。
     首先，來看看在存儲上的基本概念，這里將其與MySQL進行了對比，從而可以更清晰的搞清楚每個概念的意義。

Elasticsearch	MySQL
index（索引，名詞）	database
doc type（文檔類型）	table
document（文檔）	row
field（字段）	column
mapping（映射）	schema
query DSL（查詢語言）	SQL

然后，來看看倒排索引的概念（官方解釋）。倒排索引是搜索引擎的基石，也是Elasticsearch能實現快速全文搜索的根本。歸納起來，主要是對一個文檔內容做兩步操作：分詞、建立“單詞-文檔”列表。舉個例子，假如有下面兩個文檔：

1. {"content": "The quick brown fox jumped over the lazy dog"}
2. {"content": "Quick brown foxes leap over lazy dogs in summer"}

Elasticsearch會使用分詞器對content字段的內容進行分詞，再根據單詞在文檔中是否出現建立如下所示的列表，√表示單詞在文檔中有出現。假如我們想搜索“quick brown”，只需要找到每個詞在哪個文檔中出現即可。如果有多個文檔匹配，可以根據匹配的程度進行打分，找出相關性高的文檔。

Term	Doc_1	Doc_2
Quick		√
The	√
brown	√	√
dog	√
dogs		√
fox	√
foxes		√
in		√
jumped	√
lazy	√	√
leap		√
over	√	√
quick	√
summer		√
the	√

最后，我們再回過頭看看上面的映射的概念。類似於MySQL在db schema中申明每個列的數據類型、索引類型等，Elasticsearch中使用mapping來做這件事。常用的是，在mapping中申明字段的數據類型、是否建立倒排索引、建立倒排索引時使用什么分詞器。默認情況下，Elasticsearch會為所有的string類型數據使用standard分詞器建立倒排索引。

查看mapping：GET https://localhost:9200/<index name="">/_mapping
NOTE: 這里的index是blog，doc type是test
{
    "blog": {
        "mappings": {
            "test": {
                "properties": {
                    "activity_type": {
                        "type": "string",
                        "index": "not_analyzed"
                    },
                    "address": {
                        "type": "string",
                        "analyzer": "ik_smart"
                    },
                    "happy_party_id": {
                        "type": "integer"
                    },
                    "last_update_time": {
                        "type": "date",
                        "format": "yyyy-MM-dd HH:mm:ss"
                    }
                }
            }
        }
    }
}</index>

數據插入

    在MySQL中，我們需要先建立database和table，申明db schema后才可以插入數據。而在Elasticsearch，可以直接插入數據，系統會自動建立缺失的index和doc type，並對字段建立mapping。因為半結構化數據的數據結構通常是動態變化的，我們無法預知某個文檔中究竟有哪些字段，如果每次插入數據都需要提前建立index、type、mapping，那就失去了其作為NoSQL的優勢了。

直接插入數據：POST https://localhost:9200/blog/test
{
    "count": 5,
    "desc": "hello world"
}
 
查看索引：GET https://localhost:9200/blog/_mapping
{
    "blog": {
        "mappings": {
            "test": {
                "properties": {
                    "count": {
                        "type": "long"
                    },
                    "desc": {
                        "type": "string"
                    }
                }
            }
        }
    }
}

   然而這種靈活性是有限，比如上文我們提到，默認情況下，Elasticsearch會為所有的string類型數據使用standard分詞器建立倒排索引，那么如果某些字段不想建立倒排索引怎么辦。Elasticsearch提供了dynamic template的概念來針對一組index設置默認mapping，只要index的名稱匹配了，就會使用該template設置的mapping進行字段映射。
??下面所示即創建一個名稱為blog的template，該template會自動匹配以”blog_”開頭的index，為其自動建立mapping，對文檔中的所有string自動增加一個.raw字段，並且該字段不做索引。 這也是ELK中的做法，可以查看ELK系統中Elasticsearch的template，會發現有一個名為logstash的template。

創建template：POST https://localhost:9200/_template/blog
{
    "template": "blog_*",
    "mappings": {
        "_default_": {
            "dynamic_templates": [{
                "string_fields": {
                    "mapping": {
                        "type": "string",
                        "fields": {
                            "raw": {
                                "index": "not_analyzed",
                                "ignore_above": 256,
                                "type": "string"
                            }
                        }
                    },
                    "match_mapping_type": "string"
                }
            }],
            "properties": {
                "timestamp": {
                    "doc_values": true,
                    "type": "date"
                }
            },
            "_all": {
                "enabled": false
            }
        }
    }
}
 
直接插入數據：POST https://localhost:9200/blog_2016-12-25/test
{
    "count": 5,
    "desc": "hello world"
}

   插入問題還有個話題就是批量插入。Elasticsearch提供了bulk API用來做批量的操作，你可以在該API中自由組合你要做的操作和數據，一次性發送給Elasticsearch進行處理，其格式是這樣的。

action_and_meta_data\n
optional_source\n
action_and_meta_data\n
optional_source\n
....
action_and_meta_data\n
optional_source\n
 
比如：
{ "index" : { "_index" : "test", "_type" : "type1", "_id" : "1" } }
{ "field1" : "value1" }
{ "delete" : { "_index" : "test", "_type" : "type1", "_id" : "2" } }
{ "create" : { "_index" : "test", "_type" : "type1", "_id" : "3" } }
{ "field1" : "value3" }
{ "update" : {"_id" : "1", "_type" : "type1", "_index" : "test"} }
{ "doc" : {"field2" : "value2"} }

如果是針對相同的index和doc type進行操作，則在REST API中指定index和type即可。批量插入的操作舉例如下：

批量插入：POST https://localhost:9200/blog_2016-12-24/test/_bulk
{"index": {}}
{"count": 5, "desc": "hello world 111"}
{"index": {}}
{"count": 6, "desc": "hello world 222"}
{"index": {}}
{"count": 7, "desc": "hello world 333"}
{"index": {}}
{"count": 8, "desc": "hello world 444"}
 
查看插入的結果：GET https://localhost:9200/blog_2016-12-24/test/_search

數據查詢

     Elasticsearch的查詢語法（query DSL）分為兩部分：query和filter，區別在於查詢的結果是要完全匹配還是相關性匹配。filter查詢考慮的是“文檔中的字段值是否等於給定值”，答案在“是”與“否”中；而query查詢考慮的是“文檔中的字段值與給定值的匹配程度如何”，會計算出每份文檔與給定值的相關性分數，用這個分數對匹配了的文檔進行相關性排序。
??在實際使用中，要注意兩點：第一，filter查詢要在沒有做倒排索引的字段上做，即上面mapping中增加的.raw字段；第二，通常使用filter來縮小查詢范圍，使用query進行搜索，即二者配合使用。舉例來看，注意看三個不同查詢在寫法上的區別：

1. 只使用query進行查詢：
POST https://localhost:9200/user_action/_search
查詢的結果是page_name字段中包含了wechat所有文檔
這里使用size來指定返回文檔的數量，默認Elasticsearch是返回前100條數據的
{
    "query": {
        "bool": {
            "must": [{
                "match": {
                    "page_name": "wechat"
                }
            },
            {
                "range": {
                    "timestamp": {
                        "gte": 1481218631,
                        "lte": 1481258231,
                        "format": "epoch_second"
                    }
                }
            }]
        }
    },
    "size": 2
}
 
2. 只使用filter進行查詢：
POST https://localhost:9200/user_action/_search
查詢的結果是page_name字段值等於"example.cn/wechat/view.html"的所有文檔
{
    "filter": {
        "bool": {
            "must": [{
                "term": {
                    "page_name.raw": "example.cn/wechat/view.html"
                }
            },
            {
                "range": {
                    "timestamp": {
                        "gte": 1481218631,
                        "lte": 1481258231,
                        "format": "epoch_second"
                    }
                }
            }]
        }
    },
    "size": 2
}
 
3. 同時使用query與filter進行查詢：
POST https://localhost:9200/user_action/_search
查詢的結果是page_name字段值等於"example.cn/wechat/view.html"的所有文檔
{
    "query": {
        "bool": {
            "filter": [{
                "bool": {
                    "must": [{
                        "term": {
                            "page_name.raw": "job.gikoo.cn/wechat/view.html"
                        }
                    },
                    {
                        "range": {
                            "timestamp": {
                                "gte": 1481218631,
                                "lte": 1481258231,
                                "format": "epoch_second"
                            }
                        }
                    }]
                }
            }]
        }
    },
    "size": 2
}

聚合分析

    類似於MySQL中的聚合由分組和聚合計算兩種，Elasticsearch的聚合也有兩部分組成：Buckets與Metrics。Buckets相當於SQL中的分組group by，而Metrics則相當於SQL中的聚合函數COUNT，SUM，MAX，MIN等等。聚合分析自然離不開對多個字段值進行分組，在MySQL中，我們只要使用“group by c1, c2, c3”就可以完成這樣的功能，但是Elasticsearch沒有這樣的語法。Elasticsearch提供了另一種方法，即Buckets嵌套，仔細想想，似乎這種設計更加符合人的思維方式。舉例來看具體操作方法：

1. 最簡單的聚合查詢
POST https://localhost:9200/user_action/_search
為了簡單，這里刪除了query的條件描述
將符合條件的文檔按照公司進行聚合
這里有兩個size，和aggs並列的size=0表示返回結果不包含查詢結果，只返回聚合結果，terms里面的size表示返回的聚合結果數量
{
    "aggs": {
        "company_terms": {
            "terms": {
                "field": "company",
                "size": 2
            }
        }
    },
    "size": 0
}
 
2. Buckets與Metric配合
POST https://localhost:9200/user_action/_search
將符合條件的文檔按照公司進行聚合，並獲取每個公司最近一次操作的時間
{
    "aggs": {
        "company_terms": {
            "terms": {
                "field": "company",
                "size": 2
            },
            "aggs": {
                "latest_record": {
                    "max": {
                        "field": "timestamp"
                    }
                }
            }
        }
    },
    "size": 0
}
 
3. Buckets嵌套
POST https://localhost:9200/user_action/_search
將符合條件的文檔先按照公司進行聚合，再對每個公司下的門店進行聚合，並獲取每個門店最近一次操作的時間
{
    "aggs": {
        "company_terms": {
            "terms": {
                "field": "company",
                "size": 1
            },
            "aggs": {
                "store_terms": {
                    "terms": {
                        "field": "store",
                        "size": 2
                    },
                    "aggs": {
                        "latest_record": {
                            "max": {
                                "field": "timestamp"
                            }
                        }
                    }
                }
            }
        }
    },
    "size": 0
}