精华内容
下载资源
问答
  • I also noticed, that previously as you entered words into the search field a list of headings containing that word would be listed below the search box. That does not happen now. The only text now ...
  • <p>Results in a whole bunch of suggested alternatives with the word "None" highlighted. Apparently some underlying mechanism is interpreting a Python empty result as a keyword which should be ...
  • Word count

    2020-12-28 04:45:04
    repo%3Apressbooks%2Fpressbooks">perform a cursory search</a> to see if your bug or enhancement is already listed?</li></ul> <h3>Description <p>There should be a way to get a book's word count. ...
  • Search

    2020-11-29 23:05:32
    <p>It would be great if can search for a related word inside the book. And can we create an index of the topics? Any API for reference?</p><p>该提问来源于开源项目:Simbul/baker</p></div>
  • books.find_each { |book| book.update_pg_search_document } end end </code></pre> <p>I want to do pg search against books on the base of some specific category. Please see screenshot below. <p>...
  • Elasticsearch-05Elasticsearch之查询与过滤

    千次阅读 2019-04-20 09:42:18
    新建索引 book { "settings":{ "number_of_shards":3, "number_of_replicas":1 }, "mappings":{ "novel":{ "properties":{ "word_count":{ "type":"integer" }, "author":...


    在这里插入图片描述

    官方API文档

    当前版本 7.0 : https://www.elastic.co/guide/en/elasticsearch/reference/current/index.html

    5.6的版本的: https://www.elastic.co/guide/en/elasticsearch/reference/5.6/index.html


    准备数据

    新建索引 book

    {
    	"settings":{
    		"number_of_shards":3,
    		"number_of_replicas":1
    	},
    	
    	"mappings":{
    		"novel":{
    			"properties":{
    				"word_count":{
    					"type":"integer"
    				},
    				"author":{
    					"type":"keyword"
    				},
    				"title":{
    					"type":"text"
    				},
    				"publish_date":{
    					"type":"date",
    					"format":"yyyy-MM-dd HH:mm:ss || yyyy-MM-dd || epoch_millis"
    				}
    			}
    		}
    	}
    }
    
    
    
    

    在这里插入图片描述

    新增数据

    在这里插入图片描述

    多增加几条数据

    再增加个artisan 索引

    Types


    请求体查询

    空查询

    GET      /_search
    

    将会返回所有索引中所有的文档

    在这里插入图片描述


    可以查询一个, 多个或 _all 索引(indices)或类型(types) ,index支持通配符

    GET     /b*k/type1,type2/_search
    

    将会返回指定查询条件的文档

    在这里插入图片描述

    POST http://localhost:9200/*k/novel/_search

    在这里插入图片描述


    from 及 size 参数进行分页

    GET /_search
    {
    "from": 30,
    "size": 10
    }
    
    

    Get请求也能携带参数? 是不是很别扭? 因为携带交互数据的 GET 请求并不被广泛支持, 所以 search API同样支持 POST 请求, 类似于这样:

    POST /_search
    {
    "from": 30,
    "size": 10
    }
    
    

    这个原理同样应用于其他携带交互数据的 GET API请求中

    POST http://localhost:9200/book/novel/_search

    在这里插入图片描述


    结构化查询

    结构化查询Query DSL是一种灵活的, 多表现形式的查询语言。 Elasticsearch在一个简单的JSON接口中用结构化查询来展现Lucene的绝大多数能力, 使用DSL查询能够让查询更加灵活, 精准, 易于阅读并且易于debug。

    使用结构化查询, 需要query 参数

    GET /_search
    {
    "query": YOUR_QUERY_HERE
    }
    
    

    空查询 - {} - 在功能上等同于使用 match_all 查询子句, 正如其名字一样, 匹配所有的文档

    POST http://localhost:9200/book/novel/_search

    在这里插入图片描述


    查询子句

    语法如下:

    {
    	QUERY_NAME: {
    		ARGUMENT: VALUE,
    		ARGUMENT: VALUE,...
    	}
    }
    
    

    或指向一个指定的字段

    {
    	QUERY_NAME: {
    		FIELD_NAME: {
    			ARGUMENT: VALUE,
    			ARGUMENT: VALUE,...
    		}
    	}
    }
    
    

    举个例子: 使用 match 查询子句用来找寻在 title字段中找寻包含 elasticsearch 的成员

    {
    	"match": {
    		"title": "Elasticsearch"
    	}
    }
    
    

    完整的查询请求如下

    必须使用query关键字 , url中必须使用_search

    POST http://localhost:9200/book/novel/_search

    在这里插入图片描述


    合并多子句

    查询子句就像是搭积木一样, 可以合并简单的子句为一个复杂的查询语句。

    • 简单子句(leaf clauses)(比如 match 子句)用以在将查询字符串与一个字段(或多字段)进行比较
    • 复合子句(compound)用以合并其他的子句。 例如, bool 子句允许你合并其他的合法子句, 无论是 must , must_not 还是 should .
    • 复合子句可以合并多种子句为一个单一的查询, 无论是简单子句还是其他的复合子句

    在关系型数据库中有很多条件判断,比如 等于= 不等于!= ,或者 or ,在es中

    • must 需要满足条件 ==或like
    • must_not 不需要在满足条件内的 !=或 not like
    • should: should中的两个条件至少满足一个就可以,should下有多个条件时注意加参数 minimum_should_match

    举个例子,查找 title包含Elasticsearch ,并且作者不能为李四的记录

    {
    	"query":{
    		"bool":{
    			"must":{
    				"match":{
    					"title":"Elasticsearch"
    				}
    			},
    			"must_not":{
    				"match":{
    					"author":"李四"
    				}
    			}
    		}
    	}
    }
    
    

    POST http://localhost:9200/book/novel/_search在这里插入图片描述


    查询与过滤

    查询与过滤语句非常相似, 但是它们由于使用目的不同而稍有差异。

    一条过滤语句会询问每个文档的字段值是否包含着特定值, 比如 是否 createTime 的日期范围某个时间段内? 是否 status 字段中包含单词 “published” ?

    查询语句与过滤语句的区别

    • Query查询语句会询问每个文档的字段值与特定值的匹配程度如何,ES会给出一个相关性评分 _score , 并且 按照相关性对匹配到的文档进行排序。 这种评分方式非常适用于一个没有完全配置结果的全文本搜索。
    • Query查询语句不仅要查找相匹配的文档, 还需要计算每个文档的相关性, 所以一般来说查询语句要比过滤语句更耗时, 并且查询结果也不可缓存
    • Filter过滤查询语句在查询过程中,只判断该文档是否满足条件,只有yes和no。用作过滤不用做模糊查询. 对fifter es会用缓存,相对query来说会更快

    原则上来说, 使用查询语句做全文本搜索或其他需要进行相关性评分的时候, 剩下的全部用过滤语句


    Query DSL

    match_all 查询

    使用 match_all 可以查询到所有文档, 是没有查询条件下的默认语句

    POST http://localhost:9200/book/novel/_search

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

    match 查询

    match 查询是一个标准查询, 不管你需要全文本查询还是精确查询基本上都要用到它。

    如果你使用 match 查询一个全文本字段, 它会在真正查询之前用分析器先分析 match 一下查询字符:

    POST http://localhost:9200/book/novel/_search

    {
    	"query":{
    		"match":{
    			"title":"Elasticsearch"
    		}
    	}
    }
    
    

    在这里插入图片描述

    如果用 match 下指定了一个确切值, 在遇到数字, 日期, 布尔值或者 not_analyzed 的字符串时, 它将为你搜索你给定的值,举几个例子

    { "match": { "age": 26 }}
    
    
    { "match": { "date": "2014-09-01" }}
    
    
    { "match": { "public": true }}
    
    
    { "match": { "tag": "full_text" }}
    
    

    例子

    在这里插入图片描述

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


    multi_match 查询

    multi_match 查询允许你做 match 查询的基础上同时搜索多个字段

    {
        "multi_match": {
            "query": "full text search",
            "fields": [
                "title",
                "body"
            ]
        }
    }
    
    

    POST http://localhost:9200/book/novel/_search

    {
    	"query":{
    		"multi_match":{
    			"query":"李四",
    			"fields":["author","title"]
    		}
    	}
    }
    
    

    在这里插入图片描述


    bool 查询

    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": "2014-01-01"
                        }
                    }
                }
            ]
        }
    }
    
    

    上述查询将会找到 title 字段中包含 “how to make millions”, 并且 “tag” 字段没有被标为 spam. 如果有标识为 "starred"或者发布日期为2014年之前, 那么这些匹配的文档将比同类网站等级高.

    如果 bool 查询下没有 must 子句, 那至少应该有一个 should 子句。 但是 如果有 must 子句, 那么没有 should 子句也可以进行查询。


    Filter DSL

    term 过滤

    term 主要用于精确匹配哪些值, 比如数字, 日期, 布尔值或 not_analyzed 的字符串(未经分析的文本数据类型)

    term仅允许指定一个匹配条件 ,即 value只能有一个值

    举例:过滤查询"public_date" 精确匹配 "2017-08-15"的数据

    {
    	"query":{
    		"term":{
    			"public_date": "2017-08-15"
    		}
    	}
    }
    
    

    POST http://localhost:9200/book/novel/_search

    在这里插入图片描述


    terms 过滤

    terms 允许指定多个匹配条件。 如果某个字段指定了多个值, 那么文档需要一起去做匹配。

    例子 查询author匹配 "李三"或者"孙悟空"的数据

    POST http://localhost:9200/book/novel/_search

    {
    	"query":{
    		"terms":{
    			"author":["李三","孙悟空"]
    		}
    	}
    }
    
    

    在这里插入图片描述


    range 过滤

    range 过滤 按照指定范围查找一批数据

    范围操作符包含:

    • gt 大于
    • gte 大于等于
    • lt 小于
    • lte 小于等于

    例子: 过滤查询 字数 大于等于1000 小于2000的数据
    POST http://localhost:9200/book/novel/_search

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

    在这里插入图片描述


    exists 和 missing 过滤

    exists 和 missing 过滤可以用于查找文档中是否包含指定字段或没有某个字段, 类似于SQL语句中的 IS_NULL 条件。

    这两个过滤只是针对已经查出一批数据来, 但是想区分出某个字段是否存在的时候使用。

    目前es不推荐使用missing过滤, 使用bool.must_not + exists来替代

    
        "bool": {
            "must_not": {
                "exists": {
                    "field": "title"
                }
            }
        }
    
    

    例子 查询是否存在 名为 xxxx 的字段

    POST http://localhost:9200/book/novel/_search

    {
    	"query":{
    		"exists":{
    			"field":"xxxx"
    		}
    	}
    }
    
    

    在这里插入图片描述


    bool 过滤

    bool 过滤可以用来合并多个过滤条件查询结果的布尔逻辑,它包含一下操作符:

    • must :: 多个查询条件的完全匹配,相当于 and。
    • must_not :: 多个查询条件的相反匹配,相当于 not。
    • should :: 至少有一个查询条件匹配, 相当于 or。

    这些参数可以分别继承一个过滤条件或者一个过滤条件的数组:

    例子

    {
        "query": {
            "bool": {
                "must": {
                    "term": {
                        "folder": "inbox"
                    }
                },
                "must_not": {
                    "term": {
                        "tag": "spam"
                    }
                },
                "should": [
                    {
                        "term": {
                            "starred": true
                        }
                    },
                    {
                        "term": {
                            "unread": true
                        }
                    }
                ]
            }
        }
    }
    
    

    查询与过滤条件的合并

    查询语句和过滤语句可以放在各自的上下文中。 在 ElasticSearch API 中我们会看到许多带有 query 或 filter 的语句。

    这些语句既可以包含单条 query 语句, 也可以包含一条 filter 子句。

    换句话说, 这些语句需要首先创建一个 query 或 filter 的上下文关系

    复合查询语句可以加入其他查询子句, 复合过滤语句也可以加入其他过滤子句。 通常情况下, 一条查询语句需要过滤语句的辅助, 全文本搜索除外。

    所以说, 查询语句可以包含过滤子句, 反之亦然。 以便于我们切换 query 或 filter 的上下文。 这就要求我们在读懂需求的同时构造正确有效的语句。

    带过滤的查询语句

    假设我们有这样一条查询语句:

    {
        "match": {
            "email": "business opportunity"
        }
    }
    
    

    然后我们想要让这条语句加入 term 过滤, 在收信箱中匹配邮件:

    {
        "term": {
            "folder": "inbox"
        }
    }
    
    

    search API中只能包含 query 语句, 所以我们需要用 filtered 来同时包含 “query” 和 “filter” 子句 【过滤查询已被弃用,并在ES 5.0中删除,如下会在我们用的5.x版本中报错】

    {
        "filtered": {
            "query": {
                "match": {
                    "email": "business opportunity"
                }
            },
            "filter": {
                "term": {
                    "folder": "inbox"
                }
            }
        }
    }
    
    

    我们在外层再加入 query 的上下文关系:

    {
        "query": {
            "filtered": {
                "query": {
                    "match": {
                        "email": "business opportunity"
                    }
                },
                "filter": {
                    "term": {
                        "folder": "inbox"
                    }
                }
            }
        }
    }
    
    

    报错了。。。。在这里插入图片描述 改成使用bool / must / filter查询

    {
        "query": {
            "bool": {
                "must": {
                    "match": {
                        "email": "business opportunity"
                    }
                },
                "filter": {
                    "term": {
                        "folder": "inbox"
                    }
                }
            }
        }
    }
    
    

    单条过滤语句

    在 query 上下文中, 如果你只需要一条过滤语句, 比如在匹配全部邮件的时候, 你可以 省略 query 子句( 5.x以后的版本 需要用bool 代替 filtered):

    {
        "query": {
            "bool": {
                "filter": {
                    "term": {
                        "folder": "inbox"
                    }
                }
            }
        }
    }
    
    

    如果一条查询语句没有指定查询范围, 那么它默认使用 match_all 查询 ,等同于

    {
        "query": {
            "bool": {
                "must": {
                    "match_all": {}
                },
                "filter": {
                    "term": {
                        "folder": "inbox"
                    }
                }
            }
        }
    }
    
    

    上面说的是 查询中使用过滤。 那过滤中使用查询呢?

    我们很少用到的过滤语句中包含查询,为了语法的完整性,ES也支持这种。 只有在过滤中用到全文本匹配时候才会使用这种结构。


    验证查询 (_validate)

    查询语句可以变得非常复杂, 特别是与不同的分析器和字段映射相结合后。

    validate API 可以验证一条查询语句是否合法。

    POST http://localhost:9200/book/novel/_validate/query

    在这里插入图片描述

    重点看 valid 的返回结果

    在这里插入图片描述


    查看错误信息

    想知道语句非法的具体错误信息, 需要加上 explain 参数:

    POST: http://localhost:9200/book/novel/_validate/query?explain

    在这里插入图片描述

    查看ES如何执行的

    如果是合法语句的话, 使用 explain 参数可以返回一个带有查询语句的可阅读描述, 可以帮助了解查询语句在ES中是如何执行的

    以 以下的JSON为例

    {
    	"query":{
    		"match":{
    			"title":"Elasticserach"
    		}
    	}
    }
    
    
    

    POST http://localhost:9200/book/novel/_validate/query?explain

    关键请求: /_validate/query?explain

    返回:

    {
        "valid": true,
        "_shards": {
            "total": 1,
            "successful": 1,
            "failed": 0
        },
        "explanations": [
            {
                "index": "book",
                "valid": true,
                "explanation": "+title:elasticserach #_type:novel"
            }
        ]
    }
    
    

    explanation 会为每一个索引返回一段描述, 因为每个索引会有不同的映射关系和分析器. 上面的就只有一个。 ES如何查询是和分词器有关的。

    展开全文
  • Word import doubles endnotes

    2020-12-25 17:19:10
    </li><li>[x] Are you experiencing this issue with one of our built-in root or book themes?</li><li>[x] Did you ;+is%3Aissue+repo%3Apressbooks%2Fpressbooks">perform a cursory search</a> to see ...
  • </li><li>[x] Are you experiencing this issue with one of our built-in root or book themes?</li><li>[x] Did you ;+is%3Aissue+repo%3Apressbooks%2Fpressbooks">perform a cursory search</a> to see ...
  • Google Advanced Search Operators

    千次阅读 2014-04-16 18:04:51
    Search for an exact word or phrase  "search" Use quotes to search for an exact word or set of words on a web page. This is helpful when searching for song lyrics or a line from a book. But only
    Link: 
    https://support.google.com/websearch/answer/136861?hl=en
    

    syntax(语法) example(例子)
    完整语句
    "search"
    引号中的部分为一个整体
    "imagine all the people"
    排除语句
    -search
    不包含指定的单词
    jaguar speed -car
    特定网站、域搜索
    site:
    在网站内搜索,或不在网站内
    olympics site:nbc.com (网站内)
    olympics -site:nbc.com (网站外)

    olympics site:.gov
    Search for pages that link to a URL
    link:
    Find pages that link to a certain page. For example, you can find all the pages that link to google.com.
    link:google.com
    Search for pages that are similar to a URL
    related:
    Find sites that are similar to a URL you already know. If you search for related sites to the Time.com,you'll find other news publication sites you may be interested in.
    related:time.com
    Fill in the blank
    *
    Add an asterisk within a search as a placeholder for any unknown or wildcard terms.Use with quotation marks to find variations of that exact phrase or to remember words in the middle of a phrase.
    "a * saved is a * earned"
    Search for either word
    OR
    If you want to search for pages that may have just one of several words, include OR (capitalized) between the words.Without the OR, your results would typically show only pages that match both terms.
    world cup location 2014 OR 2018
    Search for a number range
    ..
    Separate numbers by two periods without spaces (..) to see results that contain numbers in a given range of things like dates, prices, and measurements.
    camera $50..$100
    Find information about a site
    info:
    Get information about a URL, including the cached version of the page, similar pages, and pages that link to the site.
    info:google.com
    See a cached version of a site
    cache:
    See what a page looks like the last time Google crawled the site.
    cache:washington.edu




    展开全文
  • </li><li>[x] Are you experiencing this issue with one of our built-in root or book themes?</li><li>[x] Did you ;+is%3Aissue+repo%3Apressbooks%2Fpressbooks">perform a cursory search</a> to see ...
  • Index and query your data to take advantage of search concepts such as relevance and word proximity Handle human language through the effective use of analyzers and queries Summarize and group data to...
  • ElasticSearch查询

    2021-02-28 11:30:48
    GET _search { "query": { "match_all": {} } } POST _analyze { "analyzer": "ik_max_word", "text": "中国人民" } PUT /person { "settings": { "number_of_shards": 5 , "number_of_replicas": 1 } } ...
    GET _search
    {
      "query": {
        "match_all": {}
      }
    }
    
    POST _analyze
    {
      "analyzer": "ik_max_word",
      "text": "中国人民"
    }
    
    PUT /person
    {
      "settings": {
        "number_of_shards": 5
        , "number_of_replicas": 1
      }
    }
    
    GET /person
    
    PUT /book
    {
      "settings": {
        "number_of_shards": 5,
        "number_of_replicas": 1
      },
      "mappings": {
        "novel":{
          "properties":{
            "name":{
              "type":"text",
              "analyzer":"ik_max_word",
              "index":true,
              "store":false
            },
            "author":{
              "type":"keyword"
            },
            "count":{
              "type":"long"
            },
            "on-sale":{
              "type":"date",
              "format":"yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
            },
            "descr":{
              "type":"text",
              "analyzer":"ik_max_word"
            }
          }
        }
      }
    }
    
    
    #添加文档,自动生成id
    POST /book/novel
    {
      "name":"zs",
      "author":"lhl",
      "count":100000,
      "on-sale":"2020-2-26",
      "descr":"wasd"
    }
    
    #添加文档,手动指定id
    PUT /book/novel/1
    {
      "name":"红楼梦",
      "author":"曹雪芹",
      "count":1000,
      "on-sale":"1999-7-10",
      "descr":"拉萨的房间欧赔无法"
    }
    
    #覆盖式修改文档
    PUT /book/novel/1
    {
      "name":"红楼梦1",
      "author":"曹雪芹1",
      "count":10001,
      "on-sale":"1999-7-10"
    }
    
    
    #修改文档,基于doc方式
    
    POST /book/novel/1/_update
    {
      "doc":{
        "count":"6666"
      }
    }
    
    #根据id删除
    DELETE /book/novel/1
    
    
    
    #term查询   完全匹配  不会对搜索的关键字进行分词
    POST /sms-logs-index/sms-logs-type/_search
    {
      "from":0,
      "size": 5,
      "query":{
        "term": {
          "province": {
            "value": "北京"
          }
        }
      }
    }
    
    #terms查询  相当于  where  xxx in(a,b,c)
    POST /sms-logs-index/sms-logs-type/_search
    {
      "query": {
        "terms": {
          "province": [
            "北京",
            "上海"
          ]
        }
      }
    }
    
    
    #match_all查询   查询全部内容,不指定任何查询条件
    POST /sms-logs-index/sms-logs-type/_search
    {
      "query": {
        "match_all": {}
      }
    }
    
    #match查询 指定一个Field作为筛选的条件 会被分词
    POST /sms-logs-index/sms-logs-type/_search
    {
      "query": {
        "match": {
          "smsContent": "收货安装"
        }
      }
    }
    
    #布尔match查询 指定一个Field作为匹配的内容 会被分词 #采用and或者or的方式连接   
    POST /sms-logs-index/sms-logs-type/_search
    {
      "query": {
        "match": {
          "smsContent": {
            "query": "中国 健康",
            "operator": "and"
          }
        }
      }
    }
    
    POST /sms-logs-index/sms-logs-type/_search
    {
      "query": {
        "match": {
          "smsContent": {
            "query": "中国 健康",
            "operator": "or"
          }
        }
      }
    }
    
    #multi_match查询  针对多个field做检索  多个field对应一个text
    #即一个关键字在多个不同的域(属性)中查找
    POST /sms-logs-index/sms-logs-type/_search
    {
      "query": {
        "multi_match": {
          "query": "北京",
          "fields": ["province","smsContent"]
        }
      }
    }
    
    
    #其他查询   
    #id查询
    GET /sms-logs-index/sms-logs-type/21
    
    #ids 查询  根据多个id查询 类似mysql中的where id in(id1,id2,id3)
    POST /sms-logs-index/sms-logs-type/_search
    {
      "query": {
        "ids": {
          "values": ["21","24","28"]
        }
      }
    }
    
    #prefix查询
    POST /sms-logs-index/sms-logs-type/_search
    {
      "query": {
        "prefix": {
          "corpName": {
            "value": "途虎"
          }
        }
      }
    }
    
    
    #fuzzy查询  模糊查询
    #prefix_length表示前两个字是不能出错的
    POST /sms-logs-index/sms-logs-type/_search
    {
      "query": {
        "fuzzy": {
          "corpName": {
            "value": "盒马先生",
            "prefix_length": 2
          }
        }
      }
    }
    
    
    #wildcard查询 通配查询  和mysql中的like是一个套路
    #可以在查询时,在字符串中指定通配符*和占位符?
    POST /sms-logs-index/sms-logs-type/_search
    {
      "query": {
        "wildcard": {
          "corpName": {
            "value": "中国*"
          }
        }
      }
    }
    
    
    #range查询  范围查询,只针对数值类型,对某一个Field进行大于或者小于的范围指定
    ## 可以使用 gt:>      gte:>=     lt:<     lte:<=
    
    POST /sms-logs-index/sms-logs-type/_search
    {
      "query": {
        "range": {
          "fee": {
            "gt": 5,
            "lt": 10
          }
        }
      }
    }
    
    #regexp查询 正则查询,通过你编写的正则表达式去匹配内容
    POST /sms-logs-index/sms-logs-type/_search
    {
      "query": {
        "regexp": {
          "mobile": "180[0-9]{8}"
        }
      }
    }
    
    #深分页scroll
    # 执行scroll查询,返回第一页数据,并且将文档id信息存放在ES上下文中,指定生存时间1m
    POST /sms-logs-index/sms-logs-type/_search?scroll=1m
    {
      "query": {
        "match_all": {}
      }
      , "size": 2,
      "sort": [
        {
          "fee": {
            "order": "desc"
          }
        }
      ]
    }
    
    # 根据scroll查询下一页数据
    POST /_search/scroll
    {
      "scroll_id":"DnF1ZXJ5VGhlbkZldGNoAwAAAAAAAEV2FmE4dXRoZFMyUlF1dkVySWkxTjg4QUEAAAAAAABFeBZhOHV0aGRTMlJRdXZFcklpMU44OEFBAAAAAAAARXcWYTh1dGhkUzJSUXV2RXJJaTFOODhBQQ==",
      "scroll":"1m"
    }
    
    # 删除scroll在ES上下文中的数据
        DELETE /_search/scroll/DnF1ZXJ5VGhlbkZldGNoAwAAAAAAAEV2FmE4dXRoZFMyUlF1dkVySWkxTjg4QUEAAAAAAABFeBZhOHV0aGRTMlJRdXZFcklpMU44OEFBAAAAAAAARXcWYTh1dGhkUzJSUXV2RXJJaTFOODhBQQ==
    
    
    #delete-by-query  删除查询到的数据
    POST /sms-logs-index/sms-logs-type/_delete_by_query
    {
      "query":{
        "range":{
          "fee":{
            "lt":4
          }
        }
      }
    }
    
    #bool查询 复合过滤器,将你的多个查询条件,以一定的逻辑组合在一起
    #must:所有的条件,用must组合在一起,表示and的意思
    #must_not:将must_not中的条件,全部都不能匹配,表示not的意思
    #should:所有的条件,用should组合在一起,表示or的意思
    # 查询省份为武汉或者北京
    # 运营商不是联通
    # smsContent中包含中国和平安
    POST /sms-logs-index/sms-logs-type/_search
    {
      "query": {
        "bool": {
          "should": [
            {
              "term": {
                "province": {
                  "value": "北京"
                }
              }
            },
            {
              "term": {
                "province": {
                  "value": "武汉"
                }
              }
            }
          ],
          "must_not": [
            {
              "term": {
                "operatorId": {
                  "value": "2"
                }
              }
            }
          ],
          "must": [
            {
              "match": {
                "smsContent": "平安"
              }
            }
          ]
        }
      }
    }
    
    
    #boosting查询
    #boosting查询可以帮助我们去影响查询后的score。
    
    # positive:只有匹配上positive的查询的内容,才会被放到返回的结果集中。
    # negative:如果匹配上和positive并且也匹配上了negative,就可以降低这样的文档score。
    # negative_boost:指定系数,必须小于1.0  
    
    #关于查询时,分数是如何计算的:
    
    # 搜索的关键字在文档中出现的频次越高,分数就越高
    # 指定的文档内容越短,分数就越高
    # 我们在搜索时,指定的关键字也会被分词,这个被分词的内容,被分词库匹配的个数越多,分数越高
    
    POST /sms-logs-index/sms-logs-type/_search
    {
      "query": {
        "boosting": {
          "positive": {
            "match": {
              "smsContent": "收货安装"
            }
          },
          "negative": {
            "match": {
              "smsContent": "王五"
            }
          },
          "negative_boost": 0.2
        }
      }
    }
    
    
    #filter查询
    #query,根据你的查询条件,去计算文档的匹配度得到一个分数,并且根据分数进行排序,不会做缓存的。
    
    #filter,根据你的查询条件去查询文档,不去计算分数,而且filter会对经常被过滤的数据进行缓存。相比较于query速度更快一些
    POST /sms-logs-index/sms-logs-type/_search
    {
      "query": {
        "bool": {
          "filter": [
            {
              "term":{
                "corpName":"招商银行"
              }
            },
            {
              "term":{
                "province":"上海"
              }
            }
          ]
        }
      }
    }
    
    
    #高亮查询
    #高亮查询就是你用户输入的关键字,以一定的特殊样式展示给用户,让用户知道为什么这个结果被检索出来。
    
    #高亮展示的数据,本身就是文档中的一个Field,单独将Field以highlight的形式返回给你。
    
    #ES提供了一个highlight属性,和query同级别的。
    
    # fragment_size:指定高亮数据展示多少个字符回来。
    # pre_tags:指定前缀标签,举个栗子< font color="red" >
    # post_tags:指定后缀标签,举个栗子< /font >
    # fields:指定哪几个Field以高亮形式返回
    
    
    POST /sms-logs-index/sms-logs-type/_search
    {
      "query": {
        "match": {
          "smsContent": "盒马"
        }
      },
      "highlight": {
        "fields": {
          "smsContent": {}
        },
        "pre_tags": "<font color='red'>",
        "post_tags": "</font>",
        "fragment_size":10
      }
    }
    
    #去重计数,即Cardinality,第一步先将返回的文档中的一个指定的field进行去重,统计一共有多少条
    
    
    POST /sms-logs-index/sms-logs-type/_search
    {
      "aggs":{
        "agg":{
          "cardinality": {
            "field": "province"
          }
        }
      }
    }
    
    
    #范围计数
    POST /sms-logs-index/sms-logs-type/_search
    {
      "aggs":{
        "agg":{
          "range": {
            "field": "fee",
            "ranges": [
              {
                "from": 5,
                "to": 10
              }
            ]
          }
        }
      }
    }
    
    
    #统计聚合查询
    #他可以帮你查询指定Field的最大值,最小值,平均值,平方和等
    #使用:extended_stats
    
    POST /sms-logs-index/sms-logs-type/_search
    {
      "aggs": {
        "agg": {
          "extended_stats": {
            "field": "fee"
          }
        }
      }
    }
    
    展开全文
  • Add global search

    2020-12-05 06:44:29
    </strong> (sentence, sentence, paragraph, page and full summaries of the book).</li><li><strong>Added full word search option</strong>.</li><li><strong>Navigation and highlighting of searches results...
  • When searching for the book to be scrapped, the results do not return what should be returned. Removing all but the first word returns the results you'd expect. WHAT STEPS WILL REPRODUCE THIS ...
  • </li><li>[x] Are you experiencing this issue with one of our built-in root or book themes?</li><li>[x] Did you ;+is%3Aissue+repo%3Apressbooks%2Fpressbooks">perform a cursory search</a> to see ...
  • For example, type in the word <strong>Book, and you will see the 3 dots on nearly every line. Type in the word <strong>Books, and you will only see the 3 dots on every line. <p>William</p><p>该提问...
  • ElasticSearch 查询语法

    2018-12-05 21:47:26
    ElasticSearch6.4.2 以下查询请求方式均为Post 索引名:book 索引结构: { &quot;mappings&quot;: { &quot;novel&quot;: { &quot;properties&quot;: { &quot;word_count&...

    环境

    • ElasticSearch6.4.2
    • 以下查询请求方式均为Post
    • 索引名:book
    • 索引结构:
    {
    	"mappings": {
    		"novel": {
    			"properties": {
    				"word_count": {
    					"type": "interger"
    				},
    				"author": {
    					"type": "keyword"
    				},
    				"title": {
    					"type": "text"
    				},
    				"publish_date": {
    					"format": "yyyy-MM-dd HH:mm:ss||yyy-MM-dd||epoch_mills",
    					"type": "date"
    				}
    			}
    		}
    	}
    }
    

    基本查询

    查询全部

    form指定从哪里返回
    size指定返回数量

    {
    	"query": {
    		"match_all": {}
    		}
    		"from": 1 
    		"size": 1 
    }
    

    关键词查询

    • url:~/_search
    • 在title中匹关键词joker, 并按照出场日期的降序排序
    {
    	"query": {
    		"match": {
    			"title": "joker"
    		},
    		"sort": [
    			{"publish_date":{"order":"desc}}
    		]
    	}
    }
    

    聚合查询

    • 分别根据word_count字段和publish_date字段分组聚合查询,实际上就是统计同样字数的有几本书,同样出版日期的又有几本书。
    {
    	"aggs": {
    		"group_by_word_count": {
    			"terms": {
    				"field": "word_count"
    			}
    		},
    		"group_by_publish_date": {
    			"term": {
    				"field": "publish_date"
    			}
    		}
    	}
    }
    
    • 计算word_count字段的总数,最小值,最大值,平均值,总和。
    • 分别对应count,min,max,avg,sum。将stats替换为以上单词则查询只对应结果。
    {
    	"aggs": {
    		"grades_word_count": {
    			"stats": {
    				"field": "word_count"
    			}
    		}
    	}
    }
    

    高级查询

    子条件查询

    特定字段查询所指特定值

    Query Context

    会根据匹配程度生成不同的匹配分数

    全文本查询 针对文本类型
    • 模糊匹配
      • 根据title模糊匹配“ElasticSearch入门”
    {
    	"query": {
    		"match": {
    			"title": "ElasticSearch入门"
    		}
    	}
    }
    
    • 词语匹配
      • 把“ElasticSearch入门”当作一个词语匹配
    {
    	"query": {
    		"match_phrase": {
    			"title": "ElasticSearch入门"
    		}
    	}
    }
    
    • 多个字段模糊匹配查询
      • 在author和title字段中模糊匹配joker
      • 适用于单关键词多字段查询
    {
    	"query": {
    		"multi_match": {
    			"query": "joker"
    			"fields": ["author", "title"]
    		}
    	}
    }
    
    • 语法查询
      • 在title和author字段中匹配,其中某个字段需同时含有‘ElasticSearch’和’大法’,或者含有’Python’
      • 适用于多关键词多字段查询
    {
    	"query": {
    		"query_string": {
    			"query": "(ElasticSearch AND 大法) OR Python",
    			"fields": ["title", "author"]
    		}
    	}
    }
    
    字段级别查询 针对结构化数据:数字,日期等。
    • 查询字段word_count为1000的数据
    {
    	"query": {
    		"term": {
    			"word_count": 1000 
    		}
    	}
    }
    
    • 查询字段word_count大于等于1000小于2000的数据
    {
    	"query": {
    		"range": {
    			"word_count": {
    				"gte": 1000,
    				"lg": 2000
    			}
    		}
    	}
    }
    
    • 查询字段publish_date从2018-1-1到现在的的数据
    {
    	"query": {
    		"range": {
    			"publish_date": {
    				"gte": "2018-1-1",
    				"lg": "now"
    			}
    		}
    	}
    }
    

    Filter Context

    只判断该文档是否满足条件,只有是或者不是
    而且Filter的结果会加入缓存,比Query快一些

    {
    	"query": {
    		"bool": {
    			"filter": {
    				"term": {
    					"word_count": 1000
    				}
    			}
    		}
    	}
    }
    

    常用复合条件查询

    以一定的逻辑组合子条件查询

    • 固定分数查询
      模糊匹配ElasticSearch, 查询出所有匹配分数都为2,由boost指定,默认为1
      只支持Filter查询
    {
    	"query": {
    		"constant_score": {
    			"filter": {
    				"match": {
    					"title": "ElasticSearch"
    				}
    			}
    		}, 
    		"boost": 2
    	}
    }
    
    • 布尔查询
      should是模糊匹配,must, must_not为精确匹配
      filter指定过滤条件,word_count必须为1000
    {
    	"query": {
    		"bool": {
    			"must": [
    				{
    					"match": {
    						"title": "joker"
    					},
    					"match": {
    						"title": "ElasticSearch"
    					}
    				}
    			],
    			"filter": [
    				"term": {
    					"word_count": 1000
    				}
    			]
    		}
    	}
    }
    
    展开全文
  • Deep Learning for Search.pdf

    2019-06-11 04:16:20
    in writing a book on search engines and neural networks. When Manning came back to me, expressing interest, I was kind of surprised, and wondered, do I really want to write a book on that? I realized ...
  • That's why this book is so material and important. Not only are neural networks, Al, and deep 1earning automating routine jobs and decisions and making them easier, but they are also making search ...
  • (六)ElasticSearch常用查询语法 简单查询、条件查询、聚合查询 (1)创建book索引 代码: { "settings":{ "number_of_shards":3, "number_of_replicas":1 }, "mappings":{ "novel":{ "properties":{ ...
  • ElasticSearch ---- 查询

    2017-10-31 10:34:00
    模拟数据创建 首先利用head差检查创建book索引 然后修改mappings配置 http方法: post 链接地址: http://192.168.253.129:9200/ book/novel/_mappings { ... "word_count": { "type": "i...
  • About This Book Everything you need to get your WordPress site to the top of search engines and bring thousands of new customers to your blog or business Learn everything from keyword research and ...
  • <div><p>Is this getting a low match rate because the last name and first word of the title are attached? If i lower match rate to 59, it will match it. makes me think it doesnt like them joined ...
  • oracle学习文档 笔记 全面 深刻 详细 通俗易懂 doc word格式 清晰 第一章 Oracle入门 一、 数据库概述 数据库(Database)是按照数据结构来组织、存储和管理数据的仓库,它产生于距今五十年前。简单来说是本身可视...
  • (八)ElasticSearch常用查询语法

    千次阅读 2017-10-17 00:16:07
    (1)创建book索引 代码: { "settings":{ "number_of_shards":3, "number_of_replicas":1 }, "mappings":{ "novel":{ "properties":{ "word_count":{ "type":"integer" },
  • <div><p>Searching for single word issues "one" "Rose" "Demon" Give you a 500 Internal Server Error <p>This is all the log says: <p><code>19-Mar-2020 06:54:54 - DEBUG :: mylar....
  • [book] Memory Systems --- Cache, DRAM, Disk

    热门讨论 2010-11-16 00:31:50
    Book (Jacob2008) Bruce Jacob; Spencer W. Ng; David T. Wang & Samuel Rodriguez Memory Systems --- Cache, DRAM, Disk Elsevier, 2008 Abstract: Overview On Memory Systems and Their Design ...................
  • <p>Where do you host your Elasticsearch server: elasticpress.io <p>Other plugins installed (WooCommerce, Simple Redirect Manager, etc..): <pre><code> +-------------------------------------+---...
  • <p>my means is for example when user make search for "a book for php and mysql" we send query in For loop, word to word to DB by: <pre><code>SELECT * FROM table WHERE title LIKE %i% LIMIT 5 </code>...
  • <p>The incorrect index adjustment was causing the script to search 2 words before the query word, rather than directly in front of the word and it happened to match in this case. <pre><code> 0 1 2 3 ...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 127
精华内容 50
关键字:

booksearchword