基础查询：简单查询，条件查询，聚合查询

简单查询：

(GET)127.0.0.1:9200/book/novel/1

条件查询：

-- 查询全部数据
(POST)127.0.0.1:9200/book/_search
{
  "query":{
	"match_all":{}
   }
}
-- 分页查询全部数据
(POST)127.0.0.1:9200/book/_search
{
  "query":{
    "match_all":{}
  },
  "from":1,
  "size":4
}
-- 关键词查询数据。title字段中包含ElasticSearch的数据
(POST)127.0.0.1:9200/book/_search
{
  "query":{
    "match":{"title":"ElasticSearch"}
  }
}
-- 关键词查询并排序
(POST)127.0.0.1:9200/book/_search
{
  "query":{
    "match":{ "title":"ElasticSearch" }
  },
  "sort":[
    {"publish_date":{"order":"desc"}}
  ]
}

聚合查询：

(POST)127.0.0.1:9200/book/_search
{
  "aggs":{
    "group_by_word_count":{ -- 自定义
      "terms":{ -- 关键词
        "field":"word_count"  -- 指定字段
	  }
	}
  }
}

(POST)127.0.0.1:9200/book/_search
{
  "aggs":{
    "group_by_word_count":{ -- 自定义
      "terms":{ -- 关键词
        "field":"word_count"  -- 指定字段
      }
    },
    "group_by_publish_date":{
      "terms":{
        "field":"publish_date"
      }
    }
  }
}

(POST)127.0.0.1:9200/book/_search
{
  "aggs":{
    "grades_word_count":{ 
      "stats":{ 
        "field":"word_count" 
      }
    }
  }
}

高级查询：子条件查询，复合条件查询

子条件查询： 特定字段查询所知特定值
        Query context:
        在查询过程中，判断文档是否满足查询条件外，ES还会计算一个_score来标识匹配的程度，旨在判断目标文档和查询条件匹配的有多好
            全文本查询：针对文本类型数据
            字段级别查询：针对结构化数据，如数字，日期等
            
        Filter context
        在查询过程中，只判断该文档是否满足条件，只有Yes或者No
 复合条件查询：以一定的逻辑组合子条件查询

全文本查询：如下写法模糊查询会匹配ElasticSearch 和 入门
(POST)127.0.0.1:9200/book/_search
{
  "query":{
    "match":{
      "title":"ElasticSearch入门"
    }
  }
}
其余匹配查询：模糊匹配ElasticSearch入门
(POST)127.0.0.1:9200/book/_search
{
  "query":{
    "match_phrase":{
      "title":"ElasticSearch入门"
    }
  }
}
多个字段的匹配查询
(POST)127.0.0.1:9200/book/_search
{
  "query":{
    "multi_match":{
      "query":"瓦力",
      "fields":["author","title"]
    }
  }
}
语法查询：用于数据搜索，支持通配符，范围查询，布尔查询，正则。语法表达丰富
(POST)127.0.0.1:9200/book/_search
{
  "query":{
    "query_string":{
      "query": "ElasticSearch AND 大法"
    }
  }
}

{
  "query":{
    "query_string":{
      "query": "(ElasticSearch AND 大法) OR Python"
    }
  }
}
{
  "query":{
    "query_string":{
      "query": "ElasticSearch OR Python",
      "fields": ["title","author"]
    }
  }
}
字段查询:
{
  "query":{
    "term":{
      "word_count": 1000
    }
  }
}

{
  "query":{
    "term":{
      "author": "瓦力"
    }
  }
}

{
  "query":{
    "range":{
      "word_count":{
        "gte": 1000,
         "lte": 2000
      }
    }
  }
}

{
  "query":{
    "range":{
      "publish_date":{
        "gte": "2017-0102",
        "lte": "now",
        "time_zone":"+08:00"     时区！！！！！
      }
    }
  }
}
Filter context,比query快一点，需要结合bool一起使用
{
  "query":{
    "bool":{
      "filter":{
        "term":{ "word_count":1000  }
      }
    }
  }
}

复合条件查询：
    固定分数查询，布尔查询，等等

固定分数查询：
{
  "query":{
    "constant_score":{
      "filter":{
        "match":{
          "title":"ElasticSearch"
        }
      }
    },
    "boost":2
  }
}
布尔查询
{
  "query":{
    "bool":{
      "should":[ -- OR的关系
        {
          "match":{"author":"瓦力"},
        },
        {
          "match":{"title":"ElasticSearch"}
        }
      ]
    }
  }
}

{
  "query":{
    "bool":{
      "must":[	-- AND 的关系
        {"match":{"author","瓦力"}},
        {"match":{"title":"ElasticSearch"}}
      ]
    }
  }
}

组合
{
  "query":{
    "bool":{
      "must":[
        {"match":{"author":"瓦力"}}
      ],
      "filter":[
        {"term":{"word_count":1000}
      }
      ]
    }
  }
}

{
  "query":{
    "bool":{
      "must_not":{ -- 不等于
        "term":{"author":"瓦力"}
      }
    }
  }
}

查询中 term,terms,match,match_phrase的区别？

==========================es 权威指南

匹配所有文档
{
	"query":{
		"match_all":{}
	}
}
查询子句：                                     
{												
  "match":{										
    "tweet":"elasticsearch"							
  }												
}												
 完整的请求：
{
  "query":{
    "match":{"tweet":"elasticsearch"}
  }
}
合并多子句
{
	"bool":{
		"must":{"match":{"tweet":"elasticsearch"}},
		"must_not":{"match":{"name":"mary"}},
		"should":{"match":{"tweet":"full text"}}
	}
}
term 过滤:主要用于精确匹配哪些值，比如数字，日期，布尔值或not_analyzed的字符串
{"term":{"age":26}}
terms 过滤:和term类似，但terms允许指定多个匹配条件
{"terms":{"tag":["search","full_text",nosql]}}
range 过滤:允许我们按照指定范围查找一批数据
{"range":{"age":{"gte":20,"lte":30}}}
exists 和 missing 过滤：可以用于查找文档中是否包含指定字段或没有某个字段，类似于IS NULL条件
missing 本质是exists的反义词
{"exists":{"field":"title"}}
bool 过滤：可以用来合并多个过滤条件查询结果的布尔逻辑，它包含以下操作符：
  must: 多个查询条件的完全匹配，相当于 and
  must_not: 多个查询字段的相反匹配，相当于not
  should：至少有一个查询条件匹配，相当于or
{
  "bool":{
    "must":{"term":{"folder":"index"}},
    "must_not":{"term":{"tag":"span"}},
    "should":[
      {"term":{"starred":true}},
      {"term":{"unread":true}}
    ]
  }
}
match 查询 是一个标准查询，不管是全文本查询还是精确查询基本都要用到它
  match 查询全文本字段，他会在真正查询之前用分析器先分析match一下查询字符
    {"match":{"tweet":"about search"}}
  match 查询确切值，搜索给定值
    {"match":{"tag":"full_text"}}
PS:做精确匹配搜索时，最好使用过滤语句，因为过滤语句可以缓存数据
multi_match 允许你做match查询的基础上同时搜索多个字段
{
  "multi_match":{
    "query":"full text search",
    "fields":["title","body"]
  }
}
bool 查询 与 bool 过滤相似，用于合并多个子查询语句。
  不同的是，bool过滤可以直接给出是否匹配成功，而bool查询要计算每一个子查询语句的_score
  must: 指定文档一定要被包含
  must_not: 指定文档一定不要被包含
  should：指定文档，有则可以为文档相关性加分
  {
    "bool":{
      "must":{"match":{"title":"how to make millions"}},
      "must_not":{"match":{"tag":"spam"}},
      "should":[
        {"match":{"tag":"starred"}},
        {"range":{"date":{"gte":"2018-09-01"}}}
      ]
    }
  }
PS: 如果bool查询下没有must子句，那么至少应该有一个should子句
查询和过滤条件的合并：
查询语句： 
{
  "match":{"email":"bussiness opportunity"}
}
加入term过滤:
{
  "term":{"folder":"inbox"}
}
search API中指南包含query语句，所以我们需要用filtered来同时包含"query"和"filter"
{
  "filtered":{
    "query":{"match":{"email":"bussiness opportunity"}},
    "filter":{"term":{"folder":"inbox"}}
  }
}
外面再加入query的上下文关系
{
  "query":{
    "filtered":{
      "query":{"match":{"email":"bussiness opportunity"}},
      "filter":{"term":{"folder":"inbox"}}
    }
  }
}

 

count: 查询结果的条数

java代码 : org.elasticsearch.client.transport 和 es 版本：5.4.16

long loginNum = loginSrb.setSize(0).setQuery(boolQueryBuilder).get().getHits().totalHits;
get: 
t_log_info/logInfo/_count

删除es数据

post  t_log_info/logInfo/_delete_by_query

{
  "query": {
    "match_all": {}
  }
}