精华内容
下载资源
问答
  • ElasticSearch查询语句

    2020-10-10 15:20:53
    ElasticSearch查询学习;ElasticSearch查询学习;ElasticSearch查询学习;ElasticSearch查询学习;ElasticSearch查询学习;ElasticSearch查询学习;
  • elasticsearch 查询语句

    2018-11-15 17:51:50
    #elasticsearch 查询语句 包含分页、单条件查询、多条件查询、高亮、排序、精准匹配 { "query": { "bool": { "must": [ { "query_string&...

    elasticsearch 查询语句

    包含分页、单条件查询、多条件查询、高亮、排序、精准匹配

    {
        "query": {
            "bool": {
                "must": [
                    {
                        "query_string": {
                            "fields": [
                                "source"
                            ],
                            "query": "zk"
                        }
                    },
                    {
                        "query_string": {
                            "fields": [
                                "sid"
                            ],
                            "query": "f2d3b6190"
                        }
                    },
                    {
                        "query_string": {
                            "fields": [
                                "session",
                                "level",
                                "name",
                                "content"
                            ],
                            "query": "refused"
                        }
                    },
                    {
                        "match_phrase": {
                            "content": {
                                "query": ""
                            }
                        }
                    },
                    {
                        "range": {
                            "tnum": {
                                "lte": "now-5m",
                                "gte": "now-5h"
                            }
                        }
                    }
                ]
            }
        },
        "highlight": {
            "pre_tags": [
                "<hight>"
            ],
            "post_tags": [
                "</hight>"
            ],
            "fields": {
                "*": {}
            }
        },
        "from": 0,
        "size": 100,
        "sort": [
            {
                "time": "desc"
            }
        ]
    }
    
    展开全文
  • elasticsearch查询语句

    2020-12-20 16:07:59
    1. es 查询排序 首先排序字段必须为 date 或 integer 类型,其他类型不可排序,具体使用语句: GET zhifou/doc/_search { "query": { "match_all": {} }, "sort": [ { "age": { "order": "asc" } } ] } ...
    1. es 查询排序

    首先排序字段必须为 date 或 integer 类型,其他类型不可排序,具体使用语句:

    GET zhifou/doc/_search
    {
      "query": {
        "match_all": {}
      },
      "sort": [
        {
          "age": {
            "order": "asc"
          }
        }
      ]
    }
    

    参考: https://www.cnblogs.com/heshun/articles/10657327.html

    2. es 常用 curl 语句

    使用curl命令操作elasticsearch And 使用http 查询ES

    展开全文
  • 查询表达式转变为elasticsearch查询语句

    查询表达式转变为elasticsearch查询语句

    查询表达式:(a=1 | (b<2  | c>3 &f>6)) & (d=4  | e<5) | m >9   注意:带括号,且为多层嵌套;且不考虑&|优先级

    思路:

    1.切割查询表达式,使成为含有表达式,左右括号,关系& | 的  list 集合

    2.遍历 list 集合。关系&|符号入符号栈;左括号、表达式入bool栈。遇到右括号时,则逆序遍历bool栈,并把遍历到的元素放入临时list中,直到遇到左括号为止。然后出栈,并处理这个临时list,并把返回的结果继续压入bool栈。循环处理,直到list无元素。

    3.处理临时list。

    3.1若只有一个元素,则变为DSL语句后,符号出栈;

    3.2若为两个元素,则用符号栈的第一个元素,拼接为bool语句,符号出栈(只出一次);

    3.3若为多个元素,则每个元素拼接为bool语句时,用栈中第一个元素,每个元素用完后符号栈出栈。最后那个元素无符号,则用最后一个出栈符号。

    总结:

    1.其实也不算非常复杂,但处理这个问题确实花费了很长时间。关键是基础薄弱,思路不清。一开始自己也没想好怎么做,就乱写。自己都没想好乱写的逻辑还奢望计算机能理解并正确运行。真是惭愧。最后自己思路清晰了,还真得就正确了。

    2.对栈理解不深刻,用法也不熟悉。需要加强。

    3.对经典问题算术表达式的处理不理解。需要熟悉。

    4.写的看的代码太少。何谓见多识广,游刃有余?

    import java.util.ArrayList;
    import java.util.LinkedList;
    import java.util.List;
    import org.elasticsearch.index.query.BoolQueryBuilder;
    import org.elasticsearch.index.query.QueryBuilder;
    import org.elasticsearch.index.query.QueryBuilders;
    import org.elasticsearch.index.query.QueryStringQueryBuilder;
    
    public class Test4 {
    	public static void main(String[] args) {
    
    		String s = "(a=1 | (b<2  | c>3 &f>6)) & (d=4  | e<5) | m >9";// 分割成对象,如果遇到左括号或者是|开始分割
    		//s = "(a=1 | (b<2  | c>3 &f>6)) & (d=4  | e<5) & m >9";// 
    		//s = "(a=1 | (b<2  | c>3 &f>6 | e^3) | (d=4  & e<5) & m >9)";// 
    		//s = "a=1 | (b<2  | c>3 &f>6 | e^3) | (d=4  | e<5) & m >9";// 
    		//s = "a=1 & (b<2  | c>3 &f>6) | ((d=4  & e<5) | m >9)";// 
    		List list = getSplit(s);
    		BoolQueryBuilder bool = doBra(list);
    		System.out.println(bool.toString());
    
    	}
    
    	private static BoolQueryBuilder doBra(List listO) {
    
    		LinkedList<String> opraStack = new LinkedList<String>();
    		LinkedList boolStack = new LinkedList();
    		Object obj;
    		String s;
    		List list;
    		for (int i = 0; i < listO.size(); i++) {
    			obj = listO.get(i);
    			if (obj instanceof String) {
    				s = (String) obj;
    				if (s.equals("&") || s.equals("|")) {// 符号入栈
    					opraStack.push(s);
    				} else if (s.equals(")")) {// 如果碰到右括号
    					int n = 0;
    					list = new ArrayList<String>();
    					int f = 0;
    
    					for (int j = 0; j < boolStack.size(); j++) {// 循环以前的栈,直到左括号为止,并把未遇到左括号之前的都加入一个list中。
    						Object obj2 = boolStack.get(j);
    						if (obj2 instanceof String) {
    							if (obj2.toString().equals("(")) {
    								boolStack.pop();
    								break;
    							}
    						} 
    						n++;
    						list.add(obj2);
    					}
    					
    					for (int m = 0; m < n; m++) {// 清理栈
    						boolStack.pop();
    					}
    
    					 boolStack.push(doBool(list, opraStack));// 运算后把左括号的内容加入到bool栈中
    				} else {
    					boolStack.push(obj);
    				}
    			} else {
    				boolStack.push(obj);
    			}
    		}
    		
    		BoolQueryBuilder bool3 = doBool(boolStack, opraStack);
    		return bool3;
    	}
    
    	private static BoolQueryBuilder doBool(List list,
    			LinkedList<String> opraStack) {
    		BoolQueryBuilder bool = QueryBuilders.boolQuery();
    		String temp = null;
    		int n = 1;
    		boolean flag = false;
    		for (int i = 0; i < list.size(); i++) {
    			Object obj = list.get(i);
    
    			if(list.size() == 1 || list.size()==2){
    					if (obj instanceof Expression)
    						obj = doCon((Expression) obj);
    					if(opraStack.size()==0)
    						return (BoolQueryBuilder) obj;
    					bool = doRela(bool, (QueryBuilder) obj,
    							opraStack.getFirst());
    				if (i == 1)
    					opraStack.pop();
    			} else {
    				if(opraStack.size()==0){
    					flag = true;
    					opraStack.push(temp);
    				}
    				
    				if (obj instanceof Expression) {
    					bool = doRela(bool, doCon((Expression) obj),opraStack.getFirst());
    				} else if (obj instanceof BoolQueryBuilder) {
    					bool = doRela(bool, (BoolQueryBuilder) obj,opraStack.getFirst());
    					temp = opraStack.getFirst();
    				}
    				if (n < list.size()) {
    					opraStack.pop();
    					n++;
    				}
    
    			}
    			
    		}
    
    		if(flag)
    			opraStack.pop();
    		
    		return bool;
    	}
    
    	private static QueryBuilder doCon(Expression exp) {
    		QueryBuilder qb = null;
    		String field = exp.getValueA();
    		String value = exp.getValueB();
    		String con = exp.getCal();
    		if ("=".equals(con))
    			qb = QueryBuilders.termQuery(field, value);
    	    else if (">".equals(con))
    			qb = QueryBuilders.rangeQuery(field).gt(value);
    		else if ("<".equals(con))
    			qb = QueryBuilders.rangeQuery(field).lt(value);
    		else if ("^".equals(con))//代替不等于
    			qb = QueryBuilders.boolQuery().mustNot(QueryBuilders.termQuery(field, value));
    		return qb;
    	}
    
    	private static BoolQueryBuilder doRela(BoolQueryBuilder bool,
    			QueryBuilder subBool, String opra) {
    		if ("&".equals(opra)) {
    			bool.must(subBool);
    		} else if ("|".equals(opra)) {
    			bool.should(subBool);
    		}
    		return bool;
    	}
    
    	private static List getSplit(String s) {
    
    		String[] ss = s.replace(" ", "").split("");
    		List list = new ArrayList();
    		List<String> listExp = new ArrayList<String>();
    		for (int i = 1; i < ss.length; i++) {
    			if (ss[i].equals("&") || (ss[i]).equals("|")) {
    				if (listExp.size() > 0) {
    					doList(list, listExp);
    				}
    				list.add(ss[i]);
    			} else if (ss[i].equals(")") || ss[i].equals("(")) {//
    				if (ss[i].equals(")") && listExp.size() > 0) {
    					doList(list, listExp);
    				}
    				list.add(ss[i]);
    			} else {
    				listExp.add(ss[i]);
    			}
    		}
    		if (listExp.size() > 0) {
    			doList(list, listExp);
    		}
    		return list;
    	}
    
    	private static void doList(List list, List<String> listExp) {
    		list.add(new Expression(listExp.get(0), listExp.get(2), listExp.get(1)));
    		listExp.clear();
    	}
    }
    



    表达式实体类:

    public class Expression {
    	String valueA;
    	String valueB;
    	String cal;
    	public String getValueA() {
    		return valueA;
    	}
    	public void setValueA(String valueA) {
    		this.valueA = valueA;
    	}
    	public String getValueB() {
    		return valueB;
    	}
    	public void setValueB(String valueB) {
    		this.valueB = valueB;
    	}
    	public String getCal() {
    		return cal;
    	}
    	public void setCal(String cal) {
    		this.cal = cal;
    	}
    	public Expression() {
    		super();
    	}
    	public Expression(String valueA, String valueB, String cal) {
    		super();
    		this.valueA = valueA;
    		this.valueB = valueB;
    		this.cal = cal;
    	}
    }


    展开全文
  • es查询语句

    2020-06-23 19:55:05
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1t8BEStV-1592913263205)(C:\Users\lvcky2333\AppData\Roaming\Typora\typora-user-images\image-20200623170216177.png)] ...get 查询 - G

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1t8BEStV-1592913263205)(C:\Users\lvcky2333\AppData\Roaming\Typora\typora-user-images\image-20200623170216177.png)]

    与传统数据库对比

    常用method

    • put 增加/改变
    PUT /索引/类型/1
    {
     	json串
    }
    
    • update 改变
    • delete 删除
    DELETE /索引
    
    • get 查询
    - GET /索引/类型/_search  //查询所有
    
    - GET /索引/类型/_search
    {"query":{"match_all":{}}}
    
    - GET /索引/类型/1?_source=字段列表
    
    - GET /索引/类型/_search
    {"query":{
    		"match":{json串}
    	}
    }
    
    • post 查询/改变
    POST /索引/类型/1/_updata
    {
    	"doc":{
    		列名:值   //精准的修改某一列
    	}
    }
    
    POST /_bulk   //批量操作,增删改   必须写在同一行,不能换行
    - {"create":{"index":索引,"_type":类型,"_id":编号}}
    {json串}
    - {"update":{"index":索引,"_type":类型,"_id":编号}}
    "doc":{json串}
    - {"delete":{"index":索引,"_type":类型,"_id":编号}}
    
    • head 改变/删除

    es查询

    • match_all:返回所有文档
    GET stu/_search
    {
        "query": {
            "match_all": {}
        }
    }
    
    • match:布尔匹配查询 有匹配字符,并包含任意一个就返回true
    GET stu/_search
    {
        "query": {
            "match": {
              "name":"John Kerry"
            }
        }
    }
    
    • match_phrase:短语匹配查询 必须完全匹配才返回
    GET stu/_search
    {
        "query": {
            "match_phrase": {
              "name":"John Kerry"
            }
        }
    }
    
    • match_phrase_prefix:短语前缀匹配查询,类似match_phrase,但最后一个分词作为前缀匹配
    GET stu/_search
    {
        "query": {
            "match_phrase_prefix": {
              "name":"John Ke"
            }
        }
    }
    
    • multi_match:多字段匹配查
    GET stu/_search
    {
        "query": {
            "multi_match": {
              "query": "John like cooking",
              "fields": ["name","interest"]
            }
        }
    }
    
    • range:范围查询
    GET stu/_search
    {
        "query": {
            "range" : {
                "yearOfBorn" : {
                    "gte" : 1995,
                    "lte" : 2000
                }
            }
        }
    }
    
    • bool:布尔查询
    // 查询喜欢“cooking”且不在1995-2000间出生的学生
    GET stu/_search
    {
        "query": {
          "bool": {
            "must": {
                "match": { "interest": "cooking"} },
            "must_not": {
                "range": { "yearOfBorn": { "gte": 1995, "lte": 2000 }}}
          }
        }
    }
    

    match": { “interest”: “cooking”} },
    “must_not”: {
    “range”: { “yearOfBorn”: { “gte”: 1995, “lte”: 2000 }}}
    }
    }
    }

    
    
    
    
    展开全文
  • elasticsearch查询语句叫DSL(Domain Specific Language) 查询语句由两种类型子句组成 简单查询( Leaf query Cluase) 复合查询(Compound query clauses) 查询子句的不同取决于他们是在查询子句上下文中使用...
  • ES查询语句

    千次阅读 2019-09-05 10:54:16
    1.通配符查询KEYWORD字段(不会建分词索引,会建索引) { “query”: { “bool”:{ “filter”:{“wildcard”:{“sourceMode”:“Desktop.rar”}}} } }
  • 13.Elasticsearch查询语句4

    千次阅读 2018-05-29 17:14:31
    本文从简单到复杂,将前面的查询关键字都用起来,并给出在mysql中的语句样式,方便对比理解。 1.简单条件查询 mysql: SELECT * FROM policy_file WHERE LEVEL = '国家级' AND web_source = '浙江省人民...
  • elasticsearch查询语句

    千次阅读 2017-05-01 22:44:08
    1.ElasticSearch基本概念elasticsearch基本概念见:https://es.xiaoleilu.com/010_Intro/05_What_is_it.html 集群模式安装:http://blog.csdn.net/cweeyii/article/details/710558842. 重点概念 搜素类型...
  • 常用mysql语句elasticsearch查询语句

    千次阅读 2018-10-08 15:04:41
    多个查询条件 bool(must、should、must_not) select * from index_person where name = 'jeck' or sex = 'male' order by age,sex { "query":{ "bool":{ "should":{ {&...
  • SQL JDBC    此功能是实验性的,可...Elasticsearch的SQL jdbc驱动程序是Elasticsearch的丰富,功能齐全的JDBC驱动程序。它是Type 4驱动程序,这意味着它是一个独立于平台的独立Direct to Database纯Java驱动...
  • 之前谈过Elasticsearch的介绍,还有服务端和客户端的使用,这一篇该到重点了---查询语句。正所谓--无搜索,无Elasticsearch,至少,我是这么认为的。那么,ES的搜索语句有哪些呢?其实,它们比你想象中的多! 一.全...
  • es是什么? es是基于Apache Lucene的开源分布式(全文)搜索引擎,,提供简单的RESTful API来隐藏Lucene的复杂性。...Relational DB Elasticsearch 数据库(database) 索引(indices) 表(tables) types 行(rows
  • Elasticsearch 查询语句
  • MySQL 转 ES 查询语句

    2020-04-20 16:39:41
    MySQL 转 ES 查询语句 http://www.ischoolbar.com/EsParser/
  • 通过ES进行查询,如果需要新增查询条件,则每次都需要进行硬编码,然后实现对应的查询功能。这样不仅开发工作量大,而且如果有多个不同的索引对象需要进行同样的查询,则需要开发多次,代码复用性不高。 想要解决这...
  • 查询语句中包含must与should的时候,发现should失效。那我们就把must改成must_not,逻辑再取反就可以了(无意中发现)。 希望能帮到大家,真TM有趣~ 贴俩真实语句给大家看看把。 失败语句: { "from" : 0...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 70,834
精华内容 28,333
关键字:

elasticsearch查询语句