PUT article
{
  "mappings": {
    "_doc": {
      "properties": {
        "articleId": {
          "type": "keyword"
        }
      }
    }
  }
}

POST /article/_doc/_bulk
{"index": {"_id": 1}}
{"articleId": "XHDK-A-1293-#fJ3", "userId": 1, "hidden": false, "postDate": "2017-01-01", "tag": ["java", "elasticsearch"], "tag_cnt": 2, "view_cnt": 30, "title" : "this is java and elasticsearch blog"}
{"index": {"_id": 2}}
{"articleId": "KDKE-B-9947-#kL5", "userId": 1, "hidden": false, "postDate": "2017-01-02", "tag": ["java"], "tag_cnt": 1, "view_cnt": 50, "title" : "this is java blog"}
{"index": {"_id": 3}}
{"articleId": "JODL-X-1937-#pV7", "userId": 2, "hidden": false, "postDate": "2017-01-01", "tag": ["elasticsearch"], "tag_cnt": 1, "view_cnt": 100, "title": "this is elasticsearch blog"}
{"index": {"_id": 4}}
{"articleId": "QQPX-R-3956-#aD8", "userId": 2, "hidden": true, "postDate": "2017-01-02", "tag": ["java", "elasticsearch", "hadoop"], "tag_cnt": 3, "view_cnt": 80, "title": "this is java, elasticsearch, hadoop blog"}
{"index": {"_id": 5}}
{"articleID": "DHJK-B-1395-#Ky5", "userID": 3, "hidden": false, "postDate": "2017-03-01", "tag": ["spark"], "tag_cnt": 1, "view_cnt": 10, "title": "this is spark blog"}

# 搜索标题中包含java或elasticsearch的blog
# 4条结果
GET /article/_doc/_search
{
  "query": {
    "match": {
      "title": "java elasticsearch"
    }
  }
}

# 搜索标题中包含java和elasticsearch的blog
# 2条结果
# 如果希望所有的搜索关键字都要匹配，那么就用and
GET /article/_doc/_search
{
  "query": {
    "match": {
      "title": {
        "query": "java elasticsearch",
        "operator": "and"
      }
    }
  }
}

# 搜索包含标题中java，elasticsearch，spark，hadoop，4个关键字中，至少3个的blog
# 1条结果
GET /article/_doc/_search
{
  "query": {
    "match": {
      "title": {
        "query": "java elasticsearch spark hadoop",
        "minimum_should_match": "75%"
      }
    }
  }
}

# 用bool组合多个搜索条件
# 查询标题中必须包含"java"，必须不包含"spark"，"hadoop"和"elasticsearch"包含不包含都可以的帖子
GET /article/_doc/_search
{
  "query": {
    "bool": {
      "must": {
        "match": {"title": "java"}
      },
      "must_not": {
        "match": {"title": "spark"}
      },
      "should": [
        {"match": {"title": "hadoop"}},
        {"match": {"title": "elasticsearch"}}
      ]
    }
  }
}

# 结果
{
  "took" : 10,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : 3,
    "max_score" : 1.449981,
    "hits" : [
      {
        "_index" : "article",
        "_type" : "_doc",
        "_id" : "4",
        "_score" : 1.449981,
        "_source" : {
          "articleId" : "QQPX-R-3956-#aD8",
          "userId" : 2,
          "hidden" : true,
          "postDate" : "2017-01-02",
          "tag" : [
            "java",
            "elasticsearch",
            "hadoop"
          ],
          "tag_cnt" : 3,
          "view_cnt" : 80,
          "title" : "this is java, elasticsearch, hadoop blog"
        }
      },
      {
        "_index" : "article",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 0.5753642,
        "_source" : {
          "articleId" : "XHDK-A-1293-#fJ3",
          "userId" : 1,
          "hidden" : false,
          "postDate" : "2017-01-01",
          "tag" : [
            "java",
            "elasticsearch"
          ],
          "tag_cnt" : 2,
          "view_cnt" : 30,
          "title" : "this is java and elasticsearch blog"
        }
      },
      {
        "_index" : "article",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 0.19856805,
        "_source" : {
          "articleId" : "KDKE-B-9947-#kL5",
          "userId" : 1,
          "hidden" : false,
          "postDate" : "2017-01-02",
          "tag" : [
            "java"
          ],
          "tag_cnt" : 1,
          "view_cnt" : 50,
          "title" : "this is java blog"
        }
      }
    ]
  }
}

relevance score = must和should搜索对应的分数加起来 / must和should的总数

# 使用bool组合多个搜索条件，控制全文检索的精确度
# 搜索标题中至少包含"java"、"hadoop"、"spark"、"elasticsearch"其中3个关键字的帖子
GET /article/_doc/_search
{
  "query": {
    "bool": {
      "should": [
        {"match": {"title": "java"}},
        {"match": {"title": "elasticsearch"}},
        {"match": {"title": "hadoop"}},
        {"match": {"title": "spark"}}
      ],
      "minimum_should_match": 3
    }
  }
}

# 在使用match query进行多值搜索的时候，es会在底层自动将match query转换为bool的语法
{
  "match": {"title": "java elasticsearch"}
}
# 转化为
{
  "bool": {
    "should": [
      {"term": {"title": "java"}},
      {"term": {"title": "elasticsearch"}},
    ]
  }
}

{
  "match": {
    "title": {
      "query": "java elasticsearch",
      "operator": "and"
    }
  }
}
# 转换为
{
  "bool": {
    "must": [
      { "term": { "title": "java" }},
      { "term": { "title": "elasticsearch"}}
    ]
  }
}

{
  "match": {
    "title": {
      "query":  "java elasticsearch hadoop spark",
      "minimum_should_match": "75%"
    }
  }
}
# 转换为
{
  "bool": {
    "should": [
      { "term": { "title": "java" }},
      { "term": { "title": "elasticsearch"}},
      { "term": { "title": "hadoop" }},
      { "term": { "title": "spark" }}
    ],
    "minimum_should_match": 3 
  }
}

GET /article/_doc/_search
{
  "query": {
    "bool": {
      "must": [
        {"match": {"title": "blog"}}
      ],
      "should": [
        {"match": {"title": "java"}},
        {"match": {"title": "hadoop"}},
        {"match": {"title": "elasticsearch"}},
        {
          "match": {
            "title": {
              "query": "spark",
              "boost": 5.0
            } 
          }
        }
      ]
    }
  }
}

# 为帖子增加"content"字段
POST /article/_doc/_bulk
{"update": {"_id": "1"}}
{"doc": {"content": "i like to write best elasticsearch article"}}
{"update": {"_id": "2"}}
{"doc": {"content": "i think java is the best programming language"}}
{"update": {"_id": "3"}}
{"doc": {"content": "i am only an elasticsearch beginner"}}
{"update": { "_id": "4"}}
{"doc": {"content": "elasticsearch and hadoop are all very good solution, i am a beginner"}}
{"update": { "_id": "5"}}
{"doc": {"content": "spark is best big data solution based on scala ,an programming language similar to java"}}

# 搜索title或content中包含java或solution的帖子
GET /article/_doc/_search
{
  "query": {
    "bool": {
      "should": [
        {"match": {"title": "java solution"}},
        {"match": {"content": "java solution"}}
      ]
    }
  },
  "_source": ["title", "content"]
}

# 结果
# 1. doc2(score=0.95): title匹配"java"，content匹配"java"
# 2. doc4(score=0.81): title匹配"java"，content匹配"solution"
# 3. doc5(score=0.58): title无匹配，content匹配"java"和"solution"
# 4. doc1(score=0.29): title匹配"java"，content无匹配
# 我们期望的是doc5排名靠前，因为content同时匹配了"java"和"solution"
# 而实际却是doc2和doc4排名更靠前

# 分析一下doc4和doc5的socre
# score=每个query的分数 * 匹配到条件的个数 / 总条件个数
# 假设在每个查询条件中，匹配到一个单词得分1
# 那么doc4得分为(1+1)*2/2=2
# 同理doc5得分为(0+2)*1/2=1
# 于是doc4就排在了doc5之前

GET /article/_doc/_search
{
  "query": {
    "dis_max": {
      "queries": [
        {"match": {"title": "java solution"}},
        {"match": {"content": "java solution"}}
      ]
    }
  },
  "_source": ["title", "content"]
}

# 结果
# 1. doc2(score=0.75): title匹配"java"，content匹配"java"
# 2. doc4(score=0.64): title匹配"java"，content匹配"solution"
# 3. doc5(score=0.58): title无匹配，content匹配"java"和"solution"
# 4. doc1(score=0.29): title匹配"java"，content无匹配
# 说明
# 这里没有达到我的预期效果，预期应该是doc5的排名应该更靠前，这可能与影响评分的其他因素有关
# 但是doc2和doc4的得分都下降了，说明dis_max还是有有效果的

# 换一个搜索条件 
GET /article/_doc/_search
{
  "query": {
    "dis_max": {
      "queries": [
        {"match": {"title": "java beginner"}},
        {"match": {"content": "java beginner"}}
      ]
    }
  },
  "_source": ["title", "content"]
}

# 结果
# 1. doc2(score=0.75): title匹配java，content匹配java
# 2. doc4(score=0.64): title匹配java，content匹配beginner
# 3. doc5(score=0.29): title不匹配，content匹配java
# 4. doc1(score=0.29): title匹配java，content不匹配
# 5. doc3(score=0.29): title不匹配，content匹配beginner

# tie_breaker
# 这里结果还是比较符合预期的，以下是一种不符合预期的结果：
# 1. docA: title匹配java，content不匹配
# 1. docB: title不匹配，content匹配beginner
# 2. docC: title匹配java，content匹配beginner
# 对于上述结果，我们期望的可能是docC排在其他两个doc之前，这就需要使用tie_breaker
# dis_max只取某一个query最大的分数，完全不考虑其他query的分数
# 使用tie_breaker可以将其他query的分数也考虑进去
# tie_breaker参数的作用：
# 将其他query的分数乘以tie_breaker的值
# 然后与最高的分数综合在一起进行计算
# 除了取最高分以外，还会考虑其他的query的分数
# tie_breaker的值，在0~1之间，是个小数

GET /article/_doc/_search
{
  "query": {
    "dis_max": {
      "queries": [
        {"match": {"title": "java beginner"}},
        {"match": {"content": "java beginner"}}
      ],
      "tie_breaker": 0.3
    }
  },
  "_source": ["title", "content"]
}

# 结果
# 1. doc2(score=0.81): title匹配java，content匹配java
# 2. doc4(score=0.69): title匹配java，content匹配beginner
# 3. doc5(score=0.29): title不匹配，content匹配java
# 4. doc1(score=0.29): title匹配java，content不匹配
# 5. doc3(score=0.29): title不匹配，content匹配beginner
# 可以看出对分数还是有影响的

GET /article/_doc/_search
{
  "query": {
    "multi_match": {
      "query": "java solution",
      "type": "best_fields", # best fields就是dis_max的策略，即认为一个字段匹配到尽可能多的关键词就评分更高
      "fields": ["title^2", "content"], # "title^2：将title字段的权重乘以2
      "tie_breaker": 0.3,
      "minimum_should_match": "50%"
    }
  },
  "_source": ["title", "content"]
}

# 上面的查询语法与下面的查询语法的结果是一样的
GET /article/_doc/_search
{
  "query": {
    "dis_max": {
      "queries": [
        {
          "match": {
            "title": {
              "query": "java solution",
              "minimum_should_match": "50%",
              "boost": 2
            }
          }
        },
        {
          "match": {
            "content": {
              "query": "java solution",
              "minimum_should_match": "50%"
            }
          }
        }
      ],
      "tie_breaker": 0.3
    }
  },
  "_source": ["title", "content"]
}

# minimum_should_match的作用：去长尾
# 比如搜索5个关键词，但是很多结果只匹配1个关键词的，这些结果与预期相差甚远，这些结果就是长尾
# minimum_should_match，控制搜索结果的精准度，只有匹配一定数量的关键词的数据，才能返回

# 增加测试数据
POST /article/_mapping/_doc
{
  "properties": {
      "sub_title": { 
          "type": "text",
          "analyzer": "english",
          "fields": {
              "std": { 
                "type": "text",
                "analyzer": "standard"
              }
          }
      }
  }
}

POST /article/_doc/_bulk
{"update": {"_id": "1"}}
{"doc": {"sub_title": "learning more courses"}}
{"update": {"_id": "2"}}
{"doc": {"sub_title": "learned a lot of course"}}
{"update": {"_id": "3"}}
{"doc": {"sub_title" : "we have a lot of fun"}}
{"update": {"_id": "4"}}
{"doc": {"sub_title": "both of them are good"}}
{"update": {"_id": "5"}}
{"doc": {"sub_title": "haha, hello world"}}

GET /article/_doc/search
{
  "query": {
    "match": {
      "sub_title": "learning courses"
    }
  }
}
# 结果，两条：doc1和doc2
# 使用english分词器进行分词后,learning->learn,learned->learn,courses->course
# 所以两条都可以搜索到

# 只有doc1一条结果
# sub_title.std使用standard分词器，按照非字母和非数字字符进行分隔，单词转为小写，不会进行常规化处理
GET /article/_doc/_search
{
  "query": {
    "match": {
      "sub_title.std": "learning courses"
    }
  }
}

# most_fieds策略
GET /article/_doc/_search
{
  "query": {
    "multi_match": {
      "query": "learning courses",
      "type": "most_fields",
      "fields": ["sub_title", "sub_title.std"]
    }
  },
  "_source": ["sub_title"]
}}
# 1. doc2(score=1.39): sub_title匹配learn和course，sub_title.std无匹配
# 2. doc1(score=1.15): sub_title匹配learn和course，sub_title.std匹配learning和courses
# 这里结果也是很难理解的，因为我们预期doc1是比doc2优先返回的
# 评分计算时很复杂的， 不只是TF/IDF算法，不同的query，不同的语法，都有不同的计算score的细节，所以这里就不再深究了

# 添加测试数据
POST /article/_doc/_bulk
{"update": {"_id": "1"}}
{"doc" : {"author_first_name": "Peter", "author_last_name": "Smith"}}
{"update": {"_id": "2"}}
{"doc" : {"author_first_name": "Smith", "author_last_name": "Williams"}}
{"update": {"_id": "3"}}
{"doc" : {"author_first_name": "Jack", "author_last_name": "Ma"}}
{"update": {"_id": "4"}}
{"doc" : {"author_first_name": "Robbin", "author_last_name": "Li"}}
{"update": {"_id": "5"}}
{"doc" : {"author_first_name": "Tonny", "author_last_name": "Peter Smith"}}

GET /article/_doc/_search
{
  "query": {
    "multi_match": {
      "query": "Peter Smith",
      "type": "most_fields",
      "fields": ["author_first_name", "author_last_name"]
    }
  },
  "_source": ["author_first_name", "author_last_name"]
}

# 结果
# 1. doc2(score=0.69): author_first_name匹配Smith，author_last_name无匹配
# 2. doc5(score=0.58): author_first_name不匹配，author_last_name匹配Peter和Smith
# 3. doc1(score=0.58): author_first_name匹配Peter，author_last_name匹配Smith
# 结果分析：为什么只匹配到"Smith"的doc反而排名最高
# score受TF/IDF的影响，IDF就是搜索词在所有文档中出现的次数，这个数字越高，TF/IDF越低
# 在所有文档的 "author_last_name"字段中，Smith出现2次，Peter出现1次
# 在所有文档的 "author_first_name"字段中，Smith出现1次，Peter出现1次
# 所有，在author_last_name中匹配到Smith的分数就不如在author_first_name中匹配到Smith的分数
# 当然影响分数的因素是很多的，这里是说一个普适的规律

PUT my_index
{
  "mappings": {
    "_doc": {
      "properties": {
        "first_name": {
          "type": "text",
          "copy_to": "full_name" 
        },
        "last_name": {
          "type": "text",
          "copy_to": "full_name" 
        },
        "full_name": {
          "type": "text"
        }
      }
    }
  }
}

PUT my_index/_doc/1
{
  "first_name": "Peter",
  "last_name": "Smith"
}

PUT my_index/_doc/2
{
  "first_name": "Smith",
  "last_name": "Williams"
}

PUT my_index/_doc/3
{
  "first_name": "Jack",
  "last_name": "Ma"
}

PUT my_index/_doc/4
{
  "first_name": "Robbin",
  "last_name": "Li"
}

PUT my_index/_doc/5
{
  "first_name": "Tonny",
  "last_name": "Peter Smith"
}

GET my_index/_search
{
  "query": {
    "match": {
      "full_name": "Peter Smith"
    }
  }
}

# 结果
# 1. doc2(score=0.69): first_name匹配Smith，last_name无匹配
# 2. doc5(score=0.58): first_name不匹配，author_last_name匹配Peter和Smith
# 3. doc1(score=0.58): first_name匹配Peter，last_name匹配Smith
# 这个结果也是不符合预期的，这与ES计算分数的算法有关，影响分数的因素是很多的

GET my_index/_search
{
  "query": {
    "match": {
      "full_name": { 
        "query": "Peter Smith",
        "operator": "and"
      }
    }
  }
}

# 结果
# 1. doc5(score=0.58): first_name不匹配，author_last_name匹配Peter和Smith
# 2. doc1(score=0.58): first_name匹配Peter，last_name匹配Smith

most-fields，只需要任意一个字段中出现一个关键词即可
GET my_index/_search
{
  "query": {
    "multi_match": {
      "query": "Peter Smith",
      "type": "cross_fields",
      "operator": "and",
      "fields": ["first_name", "last_name"]
    }
  }
}

# 结果
[
    {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "5",
        "_score" : 0.5753642,
        "_source" : {
            "first_name" : "Tonny",
            "last_name" : "Peter Smith"
        }
    },
    {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 0.5753642,
        "_source" : {
            "first_name" : "Peter",
            "last_name" : "Smith"
        }
    }
]

# type=cross_fields的原理
# 要求Peter必须在first_name或last_name中出现
# 要求Smith必须在first_name或last_name中出现
# doc2(first_name=Smith,last_name=Williams)就无法满足条件了
# 而原来的most-fields，只需要任意一个字段中出现一个关键词即可