content large_stringlengths 3 20.5k | url large_stringlengths 53 192 ⌀ | branch large_stringclasses 4
values | source large_stringclasses 51
values | embeddings listlengths 384 384 | score float64 -0.21 0.65 |
|---|---|---|---|---|---|
up text into same-sized fragments. `span`::: Breaks up text into same-sized fragments, but tried to avoid breaking up text between highlighted terms. This is helpful when you're querying for phrases. Default. fragment\_offset:: Controls the margin from which you want to start highlighting. Only valid when using the `fv... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/search/request/highlighting.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.0216438639909029,
0.054853156208992004,
0.07476601004600525,
0.017677798867225647,
0.0786876305937767,
0.06338725984096527,
0.03238963335752487,
0.029800711199641228,
0.0139224324375391,
-0.023255182430148125,
-0.02066933736205101,
-0.044860899448394775,
0.017866607755422592,
-0.0357933... | 0.032378 |
{ "match": { "user": "kimchy" } }, "highlight" : { "number\_of\_fragments" : 3, "fragment\_size" : 150, "fields" : { "\_all" : { "pre\_tags" : ["*"], "post\_tags" : ["*"] }, "blog.title" : { "number\_of\_fragments" : 0 }, "blog.author" : { "number\_of\_fragments" : 0 }, "blog.comment" : { "number\_of\_fragments" : 5, "... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/search/request/highlighting.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.015035395510494709,
0.09919025748968124,
0.03648119419813156,
0.03635892644524574,
0.07416538894176483,
0.03131501376628876,
0.09826710820198059,
0.03931634873151779,
0.01026098057627678,
-0.014481586404144764,
-0.042255301028490067,
-0.06012251600623131,
0.020488141104578972,
0.0287859... | -0.005036 |
} }, "highlight" : { "require\_field\_match": false, "fields": { "\_all" : { "pre\_tags" : ["*"], "post\_tags" : ["*"] } } } } -------------------------------------------------- // CONSOLE // TEST[setup:twitter] [[matched-fields]] [float] === Combine matches on multiple fields WARNING: This is only supported by the `fv... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/search/request/highlighting.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.024997245520353317,
0.04502712935209274,
-0.0023468618746846914,
-0.019467920064926147,
0.10974830389022827,
0.014209317043423653,
0.04637521132826805,
-0.048037994652986526,
0.05495484918355942,
-0.0324392095208168,
0.0024656665045768023,
-0.05785617232322693,
0.032535258680582047,
0.0... | 0.012154 |
=== Control highlighted fragments Each field highlighted can control the size of the highlighted fragment in characters (defaults to `100`), and the maximum number of fragments to return (defaults to `5`). For example: [source,js] -------------------------------------------------- GET /\_search { "query" : { "match": {... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/search/request/highlighting.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.054436095058918,
0.05496642738580704,
0.07464128732681274,
0.043446559458971024,
0.03360503539443016,
0.08151356875896454,
0.06287164241075516,
0.07868475466966629,
0.044608309864997864,
-0.021396318450570107,
-0.04849063605070114,
0.012198797427117825,
0.004425418097525835,
0.019877418... | -0.008506 |
"date": "2009-11-15T14:12:12", "likes": 1 }, "highlight": { "message": [ " with the *number*", " *1*" ] } } ] } } -------------------------------------------------- // TESTRESPONSE[s/\.\.\./"took": $body.took,"timed\_out": false,"\_shards": $body.\_shards,/] [source,js] -------------------------------------------------... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/search/request/highlighting.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.03286231309175491,
0.1067783385515213,
0.05752364918589592,
0.07118148356676102,
0.08558810502290726,
0.033344920724630356,
0.05599541589617729,
-0.02872788906097412,
0.10890819132328033,
-0.0349196121096611,
0.009319493547081947,
-0.037565309554338455,
0.02723088301718235,
-0.006295944... | 0.075912 |
[[search-request-collapse]] === Field Collapsing Allows to collapse search results based on field values. The collapsing is done by selecting only the top sorted document per collapse key. For instance the query below retrieves the best tweet for each user and sorts them by number of likes. [source,js] ----------------... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/search/request/collapse.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.026751553639769554,
0.13137103617191315,
0.04163626208901405,
0.0884111225605011,
0.027427682653069496,
0.02519383653998375,
0.016673652455210686,
0.07979908585548401,
0.08193498849868774,
-0.019159439951181412,
-0.027054615318775177,
0.08412276953458786,
0.04367781803011894,
-0.0350950... | 0.016921 |
[[search-request-search-type]] === Search Type There are different execution paths that can be done when executing a distributed search. The distributed search operation needs to be scattered to all the relevant shards and then all the results are gathered back. When doing scatter/gather type execution, there are sever... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/search/request/search-type.asciidoc | 6.2 | elasticsearch-6-2 | [
0.05873769894242287,
-0.04744827374815941,
0.0464317761361599,
0.026443086564540863,
-0.014400322921574116,
-0.028115572407841682,
-0.07171177119016647,
-0.007179548963904381,
0.0669327825307846,
-0.0094442218542099,
-0.03618549555540085,
0.03956836089491844,
0.06344927102327347,
-0.005247... | 0.037221 |
[[search-request-search-after]] === Search After Pagination of results can be done by using the `from` and `size` but the cost becomes prohibitive when the deep pagination is reached. The `index.max\_result\_window` which defaults to 10,000 is a safeguard, search requests take heap memory and time proportional to `from... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/search/request/search-after.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.14453125,
0.042627036571502686,
0.01708149164915085,
0.005906390957534313,
-0.01688872091472149,
0.031288594007492065,
-0.02062455378472805,
-0.03760908171534538,
0.03950289636850357,
-0.02408253774046898,
-0.002736907685175538,
0.08107688277959824,
0.04207553341984749,
-0.0625773221254... | 0.026082 |
[[search-request-rescore]] === Rescoring Rescoring can help to improve precision by reordering just the top (eg 100 - 500) documents returned by the <> and <> phases, using a secondary (usually more costly) algorithm, instead of applying the costly algorithm to all documents in the index. A `rescore` request is execute... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/search/request/rescore.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.03087003156542778,
0.03263529762625694,
-0.04485996812582016,
0.051517896354198456,
-0.01258546020835638,
0.022328048944473267,
-0.07110192626714706,
0.051110751926898956,
-0.006905073765665293,
0.04691115766763687,
-0.0755460113286972,
0.012565074488520622,
0.1028035581111908,
-0.01564... | 0.034526 |
so it is possible to use a large window on the first rescore to pull documents into a smaller window for the second rescore. | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/search/request/rescore.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.02476450614631176,
-0.009012998081743717,
-0.0399770550429821,
0.10472384095191956,
0.05898657813668251,
-0.026752470061182976,
-0.08052778244018555,
0.09590867906808853,
-0.004215773660689592,
0.018290158361196518,
-0.05300290882587433,
0.058465927839279175,
-0.024746883660554886,
-0.0... | 0.033341 |
[[search-request-preference]] === Preference Controls a `preference` of which shard copies on which to execute the search. By default, Elasticsearch selects from the available shard copies in an unspecified order, taking the <> and <> configuration into account. However, it may sometimes be desirable to try and route c... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/search/request/preference.asciidoc | 6.2 | elasticsearch-6-2 | [
0.037154678255319595,
0.012728311121463776,
0.02902625873684883,
0.017670171335339546,
0.0024938464630395174,
0.014149758964776993,
-0.030928904190659523,
-0.06992673873901367,
0.08020660281181335,
-0.0012920870212838054,
0.017998527735471725,
0.04739133641123772,
-0.005463693756610155,
-0... | 0.046917 |
web session id or the user name. For instance, use the user's session ID `xyzabc123` as follows: [source,js] ------------------------------------------------ GET /\_search?preference=xyzabc123 { "query": { "match": { "title": "elasticsearch" } } } ------------------------------------------------ // CONSOLE NOTE: The `\... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/search/request/preference.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.010584921576082706,
0.0948423221707344,
-0.00883669126778841,
0.04481067135930061,
0.013088920153677464,
0.022885819897055626,
0.045202624052762985,
-0.021864153444767,
0.04372578486800194,
-0.03212296590209007,
-0.06434663385152817,
-0.03783629462122917,
0.006915752775967121,
-0.013189... | 0.04827 |
[[testing-framework]] == Java Testing Framework [[testing-intro]] Testing is a crucial part of your application, and as information retrieval itself is already a complex topic, there should not be any additional complexity in setting up a testing infrastructure, which uses Elasticsearch. This is the main reason why we ... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/testing/testing-framework.asciidoc | 6.2 | elasticsearch-6-2 | [
0.08030780404806137,
0.033056389540433884,
-0.014374727383255959,
0.029583415016531944,
0.07707106322050095,
-0.026057563722133636,
-0.04869306832551956,
0.0054033431224524975,
-0.019254030659794807,
0.037358734756708145,
-0.009161633439362049,
-0.01390465721487999,
0.06563352793455124,
-0... | 0.096516 |
settings. The rule of thumb is not to specify the number of shards unless needed, so that each test will use a different one all the time. Alternatively you can override the `numberOfShards()` method. The same applies to the `numberOfReplicas()` method. [[helper-methods]] ==== Generic helper methods There are a couple ... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/testing/testing-framework.asciidoc | 6.2 | elasticsearch-6-2 | [
0.04965706169605255,
-0.0375848188996315,
0.04480714350938797,
0.04592162370681763,
0.015618688426911831,
-0.06320268660783768,
-0.08007856458425522,
0.014509438537061214,
-0.0014586610486730933,
-0.0219226386398077,
0.028635287657380104,
-0.038148943334817886,
0.03274963051080704,
-0.0363... | 0.131735 |
not want to load it for every test. You can use the `@ClusterScope` annotation at class level to configure this behaviour [source,java] ----------------------------------------- @ClusterScope(scope=TEST, numDataNodes=1) public class CustomSuggesterSearchTests extends ESIntegTestCase { // ... tests go here } -----------... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/testing/testing-framework.asciidoc | 6.2 | elasticsearch-6-2 | [
0.015220938250422478,
-0.014843382872641087,
-0.014756220392882824,
0.010827714577317238,
0.014394337311387062,
-0.049620307981967926,
-0.03342558443546295,
-0.0029406908433884382,
-0.039558738470077515,
-0.002106752712279558,
-0.007570287678390741,
-0.057555489242076874,
0.07799363881349564... | 0.111347 |
`randomInt(max)`:: Returns a random integer between 0 and max `between()`:: Returns a random between the supplied range `atLeast()`:: Returns a random integer of at least the specified integer `atMost()`:: Returns a random integer of at most the specified integer `randomLocale()`:: Returns a random locale `randomTimeZo... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/testing/testing-framework.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.013342206366360188,
0.035932425409555435,
-0.042580604553222656,
0.014535014517605305,
-0.008389054797589779,
-0.049084536731243134,
0.02879757061600685,
-0.024361226707696915,
-0.007172638550400734,
-0.030549466609954834,
0.008949999697506428,
-0.049083516001701355,
0.04156837612390518,
... | 0.03725 |
[[query-dsl-span-near-query]] === Span Near Query Matches spans which are near one another. One can specify \_slop\_, the maximum number of intervening unmatched positions, as well as whether matches are required to be in-order. The span near query maps to Lucene `SpanNearQuery`. Here is an example: [source,js] -------... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/span-near-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.010982712730765343,
0.05289182811975479,
0.04231772944331169,
0.03466978296637535,
0.006715210620313883,
0.050517886877059937,
-0.022110803052783012,
-0.02840028889477253,
0.041027799248695374,
-0.09343626350164413,
-0.03718705475330353,
-0.0070439171977341175,
0.013255172409117222,
-0.... | 0.005267 |
[[query-dsl-span-within-query]] === Span Within Query Returns matches which are enclosed inside another span query. The span within query maps to Lucene `SpanWithinQuery`. Here is an example: [source,js] -------------------------------------------------- GET /\_search { "query": { "span\_within" : { "little" : { "span\... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/span-within-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.017393657937645912,
0.07355199754238129,
0.10358648002147675,
0.08388182520866394,
0.025988388806581497,
0.005586833693087101,
0.026340186595916748,
-0.033058349043130875,
0.026068123057484627,
-0.08999775350093842,
-0.04829007759690285,
-0.005286820232868195,
0.002678654855117202,
-0.0... | 0.013429 |
[[joining-queries]] == Joining queries Performing full SQL-style joins in a distributed system like Elasticsearch is prohibitively expensive. Instead, Elasticsearch offers two forms of join which are designed to scale horizontally. <>:: Documents may contain fields of type <>. These fields are used to index arrays of o... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/joining-queries.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.009899094700813293,
0.0892895758152008,
0.033138275146484375,
0.08906563371419907,
0.05700289085507393,
-0.00849929079413414,
-0.03703716769814491,
0.048119500279426575,
0.07563979923725128,
-0.011382833123207092,
-0.020853642374277115,
-0.01946830190718174,
0.04588628560304642,
-0.0082... | 0.118187 |
[[query-dsl-parent-id-query]] === Parent Id Query The `parent\_id` query can be used to find child documents which belong to a particular parent. Given the following mapping definition: [source,js] -------------------------------------------- PUT my\_index { "mappings": { "\_doc": { "properties": { "my\_join\_field": {... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/parent-id-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.028587283566594124,
0.05581178143620491,
0.10844102501869202,
0.10582826286554337,
0.01669670082628727,
0.003991041798144579,
-0.03312675654888153,
0.06059746816754341,
0.0880354717373848,
-0.022067131474614143,
-0.039370305836200714,
-0.010125069878995419,
0.01488358061760664,
0.001091... | 0.008833 |
[[query-dsl-has-child-query]] === Has Child Query The `has\_child` filter accepts a query and the child type to run against, and results in parent documents that have child docs matching the query. Here is an example: [source,js] -------------------------------------------------- GET /\_search { "query": { "has\_child"... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/has-child-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.08305492997169495,
0.10322844982147217,
0.05595706030726433,
0.09550654888153076,
0.0765790119767189,
-0.03584287315607071,
0.011546925641596317,
0.0034469778183847666,
0.07276690006256104,
-0.03858611732721329,
-0.03901972621679306,
-0.04024422913789749,
-0.010745182633399963,
0.002042... | 0.028882 |
[[query-dsl-geo-distance-query]] === Geo Distance Query Filters documents that include only hits that exists within a specific distance from a geo point. Assuming the following mapping and indexed document: [source,js] -------------------------------------------------- PUT /my\_locations { "mappings": { "\_doc": { "pro... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/geo-distance-query.asciidoc | 6.2 | elasticsearch-6-2 | [
0.021101873368024826,
0.05885227024555206,
0.09463747590780258,
-0.0034582384396344423,
0.014081073924899101,
-0.0006952056428417563,
0.008039058186113834,
0.011355232447385788,
0.0646146833896637,
-0.042450301349163055,
-0.03872401639819145,
0.00456169992685318,
0.01534095499664545,
-0.00... | 0.02559 |
to `false` (the default value) the query will throw an exception if the field is not mapped. | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/geo-distance-query.asciidoc | 6.2 | elasticsearch-6-2 | [
0.06492508947849274,
0.027042530477046967,
-0.00939260981976986,
0.032629143446683884,
-0.059415303170681,
-0.02906378172338009,
0.015060040168464184,
-0.023177821189165115,
0.023416055366396904,
-0.006156289950013161,
0.0434679314494133,
-0.051490891724824905,
0.06866330653429031,
-0.0474... | -0.024617 |
[[query-dsl-term-query]] === Term Query The `term` query finds documents that contain the \*exact\* term specified in the inverted index. For instance: [source,js] -------------------------------------------------- POST \_search { "query": { "term" : { "user" : "Kimchy" } <1> } } ---------------------------------------... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/term-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.06233496591448784,
0.0689084529876709,
0.004592463374137878,
0.06226768717169762,
0.0029419970232993364,
-0.0028514014557003975,
0.03910017013549805,
0.012395636178553104,
0.03740645945072174,
-0.07127627730369568,
-0.04378563165664673,
-0.04191678762435913,
0.029441118240356445,
-0.063... | 0.065256 |
// TEST[continued] <1> This query matches because the `exact\_value` field contains the exact term `Quick Foxes!`. <2> This query does not match, because the `full\_text` field only contains the terms `quick` and `foxes`. It does not contain the exact term `Quick Foxes!`. <3> A `term` query for the term `foxes` matches... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/term-query.asciidoc | 6.2 | elasticsearch-6-2 | [
0.0162205770611763,
0.08264327049255371,
0.060388416051864624,
0.001416099607013166,
0.016255825757980347,
0.00002607083661132492,
0.03461412712931633,
-0.03961031511425972,
0.02363990992307663,
0.005942256655544043,
0.07614246010780334,
-0.0760900229215622,
0.007607751991599798,
-0.018098... | -0.005663 |
[[query-dsl-multi-term-rewrite]] == Multi Term Query Rewrite Multi term queries, like <> and <> are called multi term queries and end up going through a process of rewrite. This also happens on the <>. All of those queries allow to control how they will get rewritten using the `rewrite` parameter: \* `constant\_score` ... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/multi-term-rewrite.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.04250313714146614,
0.010357853025197983,
-0.0063042002730071545,
0.051758963614702225,
-0.05784956365823746,
0.01487540639936924,
-0.0245806984603405,
-0.004939026199281216,
0.02844260260462761,
0.015022329986095428,
-0.06710419803857803,
0.004847089294344187,
0.07646790146827698,
-0.04... | 0.07604 |
[[regexp-syntax]] ==== Regular expression syntax Regular expression queries are supported by the `regexp` and the `query\_string` queries. The Lucene regular expression engine is not Perl-compatible but supports a smaller range of operators. [NOTE] ===== We will not attempt to explain regular expressions, but just expl... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/regexp-syntax.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.020159613341093063,
0.007460850290954113,
0.11154449731111526,
0.049089204519987106,
-0.08813559263944626,
0.0576745830476284,
0.039691828191280365,
-0.03883619233965874,
0.015901288017630577,
-0.018378157168626785,
-0.04965467378497124,
-0.03066999278962612,
0.007971419021487236,
0.016... | 0.0573 |
match a+|b+ # no match a+b+|b+a+ # match a+(b|c)+ # match -- Character classes:: + -- Ranges of potential characters may be represented as character classes by enclosing them in square brackets `"[]"`. A leading `^` negates the character class. The allowed forms are: [abc] # 'a' or 'b' or 'c' [a-c] # 'a' or 'b' or 'c' ... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/regexp-syntax.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.07058947533369064,
0.050125714391469955,
0.06484545022249222,
-0.005651767831295729,
-0.05305786803364754,
0.07112348079681396,
0.039506737142801285,
-0.06414356082677841,
-0.02920885570347309,
-0.015704447403550148,
0.014533456414937973,
-0.009742407128214836,
0.09310334175825119,
0.05... | 0.057322 |
[[query-dsl-fuzzy-query]] === Fuzzy Query The fuzzy query uses similarity based on Levenshtein edit distance. ==== String fields The `fuzzy` query generates matching terms that are within the maximum edit distance specified in `fuzziness` and then checks the term dictionary to find out which of those generated terms ac... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/fuzzy-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.040139731019735336,
0.036724988371133804,
0.019664784893393517,
0.02444393001496792,
-0.04589301720261574,
-0.020378325134515762,
0.06303879618644714,
-0.018510805442929268,
0.06330171227455139,
-0.08792508393526077,
0.011282095685601234,
-0.026108184829354286,
0.052426815032958984,
-0.... | 0.029246 |
[[term-level-queries]] == Term level queries While the <> will analyze the query string before executing, the \_term-level queries\_ operate on the exact terms that are stored in the inverted index, and will normalize terms before executing only for <> fields with <> property. These queries are usually used for structu... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/term-level-queries.asciidoc | 6.2 | elasticsearch-6-2 | [
0.021086063235998154,
0.08453323692083359,
0.006036426406353712,
0.05244062468409538,
0.014708387665450573,
-0.015402466990053654,
0.018551651388406754,
0.016576196998357773,
0.026715973392128944,
0.03186226263642311,
0.03280716389417648,
-0.05352314934134483,
0.039409007877111435,
-0.0789... | 0.141821 |
[[query-dsl-span-multi-term-query]] === Span Multi Term Query The `span\_multi` query allows you to wrap a `multi term query` (one of wildcard, fuzzy, prefix, range or regexp query) as a `span query`, so it can be nested. Example: [source,js] -------------------------------------------------- GET /\_search { "query": {... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/span-multi-term-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.08496280014514923,
0.04618024080991745,
0.03168148174881935,
0.0659194216132164,
-0.02025485970079899,
0.027840467169880867,
0.027767153456807137,
-0.013606606982648373,
0.035531461238861084,
-0.09181055426597595,
-0.0327472947537899,
-0.058924511075019836,
0.025139426812529564,
-0.0242... | 0.006179 |
[[query-dsl-query-string-query]] === Query String Query A query that uses a query parser in order to parse its content. Here is an example: [source,js] -------------------------------------------------- GET /\_search { "query": { "query\_string" : { "default\_field" : "content", "query" : "this AND that OR thus" } } } ... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/query-string-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.05282368138432503,
0.08805615454912186,
0.03295513242483139,
0.07027649879455566,
-0.03826076164841652,
0.010574353858828545,
0.06356418132781982,
0.037894077599048615,
0.06604307889938354,
-0.08952023088932037,
-0.0683312863111496,
-0.017828620970249176,
-0.013849536888301373,
-0.04739... | 0.049081 |
best effort will be made to analyze those as well. |`max\_determinized\_states` |Limit on how many automaton states regexp queries are allowed to create. This protects against too-difficult (e.g. exponentially hard) regexps. Defaults to 10000. |`minimum\_should\_match` |A value controlling how many "should" clauses in ... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/query-string-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.013320173136889935,
0.054531607776880264,
-0.00047288008499890566,
0.0068161762319505215,
0.02568729780614376,
0.023140616714954376,
-0.022379666566848755,
0.03768691420555115,
-0.030938290059566498,
-0.026198305189609528,
-0.024117738008499146,
-0.07384421676397324,
-0.027728328481316566... | 0.09552 |
string itself (properly escaping the `\*` sign), for example: `city.\\*:something`: [source,js] -------------------------------------------------- GET /\_search { "query": { "query\_string" : { "query" : "city.\\\*:(this AND that OR thus)" } } } -------------------------------------------------- // CONSOLE NOTE: Since ... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/query-string-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.033317048102617264,
0.07728906720876694,
0.03148487210273743,
0.04733311012387276,
-0.030304422602057457,
0.03213882818818092,
0.0232382882386446,
-0.0026917262002825737,
0.02683931402862072,
-0.04507599398493767,
-0.014826370403170586,
-0.05513828247785568,
0.01218889094889164,
-0.0060... | 0.025949 |
[[query-dsl-span-containing-query]] === Span Containing Query Returns matches which enclose another span query. The span containing query maps to Lucene `SpanContainingQuery`. Here is an example: [source,js] -------------------------------------------------- GET /\_search { "query": { "span\_containing" : { "little" : ... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/span-containing-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.016172640025615692,
0.06832128763198853,
0.10306062549352646,
0.08185917139053345,
0.015805043280124664,
0.032366663217544556,
0.02544795721769333,
-0.037180665880441666,
0.024452807381749153,
-0.08869478106498718,
-0.046815577894449234,
-0.006070420145988464,
-0.00017219116853084415,
-... | 0.009594 |
[[query-dsl-simple-query-string-query]] === Simple Query String Query A query that uses the SimpleQueryParser to parse its context. Unlike the regular `query\_string` query, the `simple\_query\_string` query will never throw an exception, and discards invalid parts of the query. Here is an example: [source,js] --------... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/simple-query-string-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.024058738723397255,
0.06300099194049835,
0.07864399254322052,
0.0761522576212883,
-0.02984730340540409,
-0.005474829114973545,
0.014538971707224846,
0.04353487119078636,
0.01779020205140114,
-0.12029590457677841,
-0.038595713675022125,
-0.04657457768917084,
-0.004782344680279493,
-0.080... | -0.035044 |
syntax may have a different behavior depending on the `default\_operator` value. For example, consider the following query: [source,js] -------------------------------------------------- GET /\_search { "query": { "simple\_query\_string" : { "fields" : ["content"], "query" : "foo bar -baz" } } } -----------------------... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/simple-query-string-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.06614895164966583,
0.05387919768691063,
0.08771204948425293,
0.07616764307022095,
-0.0063523827120661736,
-0.006654457189142704,
0.03347688540816307,
0.006071525160223246,
0.10901396721601486,
-0.03944709151983261,
0.012997444719076157,
0.00002710569606279023,
-0.011586620472371578,
-0.... | 0.015283 |
[[query-dsl-match-query-phrase]] === Match Phrase Query The `match\_phrase` query analyzes the text and creates a `phrase` query out of the analyzed text. For example: [source,js] -------------------------------------------------- GET /\_search { "query": { "match\_phrase" : { "message" : "this is a test" } } } -------... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/match-phrase-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.09172318130731583,
0.10440108180046082,
0.003819947363808751,
0.08606187254190445,
-0.003330410458147526,
-0.011147590354084969,
0.10691947489976883,
-0.0027950452640652657,
0.059630025178194046,
-0.04122563451528549,
-0.013294274918735027,
-0.030462412163615227,
0.012630382552742958,
0... | 0.146147 |
[[query-dsl-wrapper-query]] === Wrapper Query A query that accepts any other query as base64 encoded string. [source,js] -------------------------------------------------- GET /\_search { "query" : { "wrapper": { "query" : "eyJ0ZXJtIiA6IHsgInVzZXIiIDogIktpbWNoeSIgfX0=" <1> } } } ----------------------------------------... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/wrapper-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.04744753986597061,
0.09984138607978821,
-0.03815825656056404,
0.049375418573617935,
-0.041177619248628616,
0.021645866334438324,
-0.012551089748740196,
0.0333537757396698,
0.04448745399713516,
-0.05300762876868248,
-0.03336479887366295,
-0.048110783100128174,
0.012773015536367893,
-0.01... | 0.048084 |
[[query-dsl-terms-set-query]] === Terms Set Query experimental[The terms\_set query is a new query and its syntax may change in the future] Returns any documents that match with at least one or more of the provided terms. The terms are not analyzed and thus must match exactly. The number of terms that must match varies... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/terms-set-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.02883405052125454,
0.05437078699469566,
0.07008159905672073,
0.051171671599149704,
-0.02428235113620758,
0.03804442286491394,
0.023795895278453827,
0.0018560371827334166,
0.07491183280944824,
0.006834189407527447,
-0.06280041486024857,
-0.06601011008024216,
0.04328553378582001,
-0.04239... | 0.059735 |
[[geo-queries]] == Geo queries Elasticsearch supports two types of geo data: <> fields which support lat/lon pairs, and <> fields, which support points, lines, circles, polygons, multi-polygons etc. The queries in this group are: <> query:: Find document with geo-shapes which either intersect, are contained by, or do n... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/geo-queries.asciidoc | 6.2 | elasticsearch-6-2 | [
0.08809497207403183,
0.06457024067640305,
0.027482954785227776,
0.020922929048538208,
0.06007631868124008,
-0.015210923738777637,
0.013998523354530334,
-0.013600372709333897,
0.053456295281648636,
-0.047411710023880005,
-0.0694427341222763,
-0.0025246937293559313,
0.03407961502671242,
-0.0... | 0.128892 |
[[query-dsl-minimum-should-match]] == Minimum Should Match The `minimum\_should\_match` parameter possible values: [cols="<,<,<",options="header",] |======================================================================= |Type |Example |Description |Integer |`3` |Indicates a fixed value regardless of the number of opti... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/minimum-should-match.asciidoc | 6.2 | elasticsearch-6-2 | [
0.006240845657885075,
0.1205359399318695,
0.016683466732501984,
0.019396554678678513,
-0.032721955329179764,
0.002267910400405526,
0.07858739793300629,
0.0906711146235466,
-0.004287590738385916,
-0.0481940321624279,
-0.00017191635561175644,
-0.11252594739198685,
0.03809419274330139,
-0.012... | -0.034887 |
[[query-string-syntax]] ==== Query string syntax The query string ``mini-language'' is used by the <> and by the `q` query string parameter in the <>. The query string is parsed into a series of \_terms\_ and \_operators\_. A term can be a single word -- `quick` or `brown` -- or a phrase, surrounded by double quotes --... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/query-string-syntax.asciidoc | 6.2 | elasticsearch-6-2 | [
0.012606950476765633,
0.061576418578624725,
0.02765262871980667,
0.08090078085660934,
-0.062015749514102936,
0.0652616024017334,
0.10782603919506073,
-0.029360923916101456,
-0.03536304458975792,
0.0054426416754722595,
0.020765552297234535,
-0.012537593953311443,
0.06292044371366501,
-0.036... | 0.076629 |
a maximum of two changes, where a change is the insertion, deletion or substitution of a single character, or transposition of two adjacent characters. The default \_edit distance\_ is `2`, but an edit distance of `1` should be sufficient to catch 80% of all human misspellings. It can be specified as: quikc~1 ===== Pro... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/query-string-syntax.asciidoc | 6.2 | elasticsearch-6-2 | [
0.004777688067406416,
-0.0031688131857663393,
0.05230157449841499,
-0.01961999014019966,
-0.06669392436742783,
0.048927921801805496,
-0.021042492240667343,
0.03243740648031235,
0.10049143433570862,
0.002339091384783387,
0.06185746565461159,
0.05481530725955963,
0.07230851799249649,
-0.0923... | 0.069974 |
operators can be more complicated than is obvious at first glance. `NOT` takes precedence over `AND`, which takes precedence over `OR`. While the `+` and `-` only affect the term to the right of the operator, `AND` and `OR` can affect the terms to the left and right. \*\*\*\* Rewriting the above query using `AND`, `OR`... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/query-string-syntax.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.00937051884829998,
0.04673462733626366,
0.05514341965317726,
0.027749214321374893,
-0.02214423380792141,
0.009491227567195892,
-0.01172464620321989,
-0.09129280596971512,
0.052784036844968796,
-0.016362616792321205,
0.01612979546189308,
-0.004406315740197897,
0.05074983090162277,
-0.025... | 0.009493 |
[[query-dsl-range-query]] === Range Query Matches documents with fields that have terms within a certain range. The type of the Lucene query depends on the field type, for `string` fields, the `TermRangeQuery`, while for number/date fields, the query is a `NumericRangeQuery`. The following example returns all documents... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/range-query.asciidoc | 6.2 | elasticsearch-6-2 | [
0.024575455114245415,
0.09953505545854568,
0.013721165247261524,
0.0765795037150383,
-0.015561757609248161,
0.10446527600288391,
-0.02722618728876114,
0.06382747739553452,
0.013671820983290672,
-0.07319429516792297,
-0.03021782636642456,
-0.04377463087439537,
-0.023541774600744247,
-0.0124... | 0.010614 |
[[query-dsl-constant-score-query]] === Constant Score Query A query that wraps another query and simply returns a constant score equal to the query boost for every document in the filter. Maps to Lucene `ConstantScoreQuery`. [source,js] -------------------------------------------------- GET /\_search { "query": { "cons... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/constant-score-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.06017502024769783,
0.10012029111385345,
-0.015892116352915764,
0.09098818153142929,
0.002357639605179429,
0.04382820799946785,
-0.0027369551826268435,
-0.0027901811990886927,
-0.026448240503668785,
-0.05845676362514496,
-0.05515024811029434,
-0.056844357401132584,
-0.007134832441806793,
... | 0.054309 |
[[query-filter-context]] == Query and filter context The behaviour of a query clause depends on whether it is used in \_query context\_ or in \_filter context\_: Query context:: + -- A query clause used in query context answers the question ``\_\_How well does this document match this query clause?\_\_'' Besides decidi... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/query_filter_context.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.05658251419663429,
0.0913817510008812,
0.026253461837768555,
0.041098762303590775,
0.015585754066705704,
0.02675030380487442,
0.08047091960906982,
0.015386348590254784,
0.019139422103762627,
-0.028506537899374962,
-0.028910411521792412,
-0.07211551070213318,
0.07578428089618683,
-0.0152... | 0.094074 |
[[query-dsl-multi-match-query]] === Multi Match Query The `multi\_match` query builds on the <> to allow multi-field queries: [source,js] -------------------------------------------------- GET /\_search { "query": { "multi\_match" : { "query": "this is a test", <1> "fields": [ "subject", "message" ] <2> } } } ---------... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/multi-match-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.0827016606926918,
0.10242531448602676,
0.002525873715057969,
0.06756242364645004,
0.04025738313794136,
0.022309014573693275,
0.04112866893410683,
-0.0019916193559765816,
0.033633165061473846,
-0.07332358509302139,
-0.0493168942630291,
-0.09347820281982422,
0.002103971317410469,
-0.02630... | 0.012285 |
`boost`, `operator`, `minimum\_should\_match`, `fuzziness`, `lenient`, `prefix\_length`, `max\_expansions`, `rewrite`, `zero\_terms\_query`, `cutoff\_frequency`, `auto\_generate\_synonyms\_phrase\_query` and `fuzzy\_transpositions`, as explained in <>. [IMPORTANT] [[operator-min]] .`operator` and `minimum\_should\_matc... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/multi-match-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.029836399480700493,
0.027342353016138077,
0.02775053307414055,
-0.03360087051987648,
-0.08120304346084595,
0.0015555992722511292,
0.06452794373035431,
0.0028109364211559296,
-0.04055149480700493,
0.00030415572109632194,
-0.024563457816839218,
-0.1005609929561615,
0.04853072389960289,
-0... | 0.075204 |
relevance: the different term frequencies in the `first\_name` and `last\_name` fields can produce unexpected results. For instance, imagine we have two people: ``Will Smith'' and ``Smith Jones''. ``Smith'' as a last name is very common (and so is of low importance) but ``Smith'' as a first name is very uncommon (and s... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/multi-match-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.06049532815814018,
-0.01748519018292427,
0.02273714356124401,
-0.013079733587801456,
-0.03626348823308945,
-0.02787022292613983,
0.03609760105609894,
-0.0037045544013381004,
0.04371084272861481,
0.009222228080034256,
0.014508255757391453,
-0.015929481014609337,
0.04369961842894554,
-0.0... | 0.101149 |
<> as `most\_fields` or `best\_fields`. You can easily rewrite this query yourself as two separate `cross\_fields` queries combined with a `bool` query, and apply the `minimum\_should\_match` parameter to just one of them: [source,js] -------------------------------------------------- GET /\_search { "query": { "bool":... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/multi-match-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.05462176352739334,
0.07152273505926132,
0.06324010342359543,
-0.016716578975319862,
0.02262570708990097,
0.042142633348703384,
0.024532373994588852,
0.020668696612119675,
0.06548582017421722,
-0.03518376871943474,
-0.060069676488637924,
-0.06866681575775146,
0.01140317227691412,
0.01749... | 0.004084 |
[[query-dsl-terms-query]] === Terms Query Filters documents that have fields that match any of the provided terms (\*not analyzed\*). For example: [source,js] -------------------------------------------------- GET /\_search { "query": { "terms" : { "user" : ["kimchy", "elasticsearch"]} } } -----------------------------... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/terms-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.04747442156076431,
0.1223054751753807,
-0.011955881491303444,
0.07710206508636475,
0.036335691809654236,
0.004077444318681955,
0.04464433342218399,
-0.006322764791548252,
0.0734562873840332,
-0.048306290060281754,
-0.04287022352218628,
-0.06409278512001038,
-0.012034899555146694,
-0.025... | 0.0306 |
[[query-dsl-mlt-query]] === More Like This Query The More Like This Query finds documents that are "like" a given set of documents. In order to do so, MLT selects a set of representative terms of these input documents, forms a query using these terms, executes the query and returns the results. The user controls the in... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/mlt-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.092302106320858,
0.06234654784202576,
0.02434297278523445,
0.0906827300786972,
-0.010082485154271126,
0.0661424919962883,
0.06761021167039871,
-0.007435536943376064,
0.11173126101493835,
-0.10175008326768875,
-0.024179819971323013,
0.007882559671998024,
0.0320243313908577,
-0.0228584948... | 0.085282 |
We can still perform MLT on the "description" and "tags" fields, as `\_source` is enabled by default, but there will be no speed up on analysis for these fields. [source,js] -------------------------------------------------- PUT /imdb { "mappings": { "movies": { "properties": { "title": { "type": "text", "term\_vector"... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/mlt-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.030570736154913902,
-0.026302680373191833,
-0.003958292305469513,
0.040958747267723083,
0.0697951391339302,
-0.002190724713727832,
-0.018562588840723038,
-0.000712063629180193,
0.047203656286001205,
-0.036945607513189316,
0.004390781279653311,
-0.038787659257650375,
-0.027557194232940674,... | -0.003031 |
of terms that must match. The syntax is the same as the <>. (Defaults to `"30%"`). `fail\_on\_unsupported\_field`:: Controls whether the query should fail (throw an exception) if any of the specified fields are not of the supported types (`text` or `keyword'). Set this to `false` to ignore the field and continue proces... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/mlt-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.023371540009975433,
0.01830616220831871,
-0.053788576275110245,
0.04885507747530937,
0.02214788645505905,
0.07069655507802963,
0.022647744044661522,
-0.01163232047110796,
-0.05685034021735191,
0.003381317714229226,
0.052383240312337875,
-0.03909813612699509,
0.059038195759058,
-0.031316... | 0.050684 |
[[query-dsl-match-all-query]] == Match All Query The most simple query, which matches all documents, giving them all a `\_score` of `1.0`. [source,js] -------------------------------------------------- GET /\_search { "query": { "match\_all": {} } } -------------------------------------------------- // CONSOLE The `\_s... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/match-all-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.09739828109741211,
0.07629986852407455,
-0.03533494845032692,
0.08638745546340942,
0.020332096144557,
0.060225892812013626,
0.03193105012178421,
0.035145435482263565,
0.034673646092414856,
-0.06585326790809631,
-0.0674125924706459,
-0.03290793299674988,
0.02543502300977707,
-0.058561801... | 0.025742 |
[[query-dsl-span-field-masking-query]] === Span Field Masking Query Wrapper to allow span queries to participate in composite single-field span queries by 'lying' about their search field. The span field masking query maps to Lucene's `SpanFieldMaskingQuery` This can be used to support queries like `span-near` or `span... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/span-field-masking-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.06482572853565216,
0.07491794228553772,
0.030049802735447884,
0.10042894631624222,
0.004806379321962595,
0.015359065495431423,
0.005168686155229807,
-0.061379291117191315,
0.03390687331557274,
-0.07599923014640808,
-0.0493626706302166,
-0.009155120700597763,
0.031591448932886124,
0.0170... | 0.056887 |
[[query-dsl-has-parent-query]] === Has Parent Query The `has\_parent` query accepts a query and a parent type. The query is executed in the parent document space, which is specified by the parent type. This query returns child documents which associated parents have matched. For the rest `has\_parent` query has the sam... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/has-parent-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.08011796325445175,
0.06812578439712524,
0.07789208739995956,
0.08213135600090027,
0.030073214322328568,
0.0008142614387907088,
-0.01458719465881586,
0.012981708161532879,
0.07883284986019135,
-0.05744856968522072,
-0.01568988896906376,
-0.05212731286883354,
-0.009716165252029896,
0.0147... | 0.02578 |
[[query-dsl-nested-query]] === Nested Query Nested query allows to query nested objects / docs (see <>). The query is executed against the nested objects / docs as if they were indexed as separate docs (they are, internally) and resulting in the root parent doc (or parent nested mapping). Here is a sample mapping we wi... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/nested-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.029734168201684952,
0.07940138876438141,
0.07755225151777267,
0.09499077498912811,
-0.01629999838769436,
-0.036636292934417725,
-0.05848101153969765,
0.06661076843738556,
0.053498104214668274,
0.006533878389745951,
-0.06658272445201874,
-0.012143916450440884,
-0.01893807388842106,
0.019... | 0.001507 |
[[query-dsl-script-query]] === Script Query A query allowing to define <> as queries. They are typically used in a filter context, for example: [source,js] ---------------------------------------------- GET /\_search { "query": { "bool" : { "must" : { "script" : { "script" : { "source": "doc['num1'].value > 1", "lang":... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/script-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.07811343669891357,
0.07261575758457184,
-0.022379962727427483,
0.10860695689916611,
-0.028262121602892876,
0.019570529460906982,
0.06502112746238708,
0.04690029099583626,
0.049993276596069336,
-0.06877207010984421,
-0.0401344895362854,
-0.023700417950749397,
0.04629555344581604,
-0.0748... | 0.066606 |
[[query-dsl-percolate-query]] === Percolate Query The `percolate` query can be used to match queries stored in an index. The `percolate` query itself contains the document that will be used as query to match with the stored queries. [float] === Sample Usage Create an index with two fields: [source,js] -----------------... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/percolate-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.030784625560045242,
0.08965644240379333,
0.07289766520261765,
0.12452332675457001,
-0.010424434207379818,
0.009527579881250858,
0.051006071269512177,
0.013369868509471416,
0.11379095166921616,
-0.032492078840732574,
-0.06423728913068771,
-0.06831759959459305,
0.00978854950517416,
0.0006... | 0.060413 |
Percolating in a filter context In case you are not interested in the score, better performance can be expected by wrapping the percolator query in a `bool` query's filter clause or in a `constant\_score` query: [source,js] -------------------------------------------------- GET /my-index/\_search { "query" : { "constan... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/percolate-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.03423606976866722,
0.07360424846410751,
0.06560011953115463,
0.08936390280723572,
0.05231764167547226,
0.03177521377801895,
0.03789467737078667,
-0.04475647956132889,
0.1139865443110466,
-0.03102639503777027,
-0.058518558740615845,
-0.03077409416437149,
-0.0194484181702137,
-0.002733377... | 0.056339 |
"\_doc", "id" : "2", "version" : 1 <1> } } } -------------------------------------------------- // CONSOLE // TEST[continued] <1> The version is optional, but useful in certain cases. We can ensure that we are trying to percolate the document we just have indexed. A change may be made after we have indexed, and if that... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/percolate-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.06749624013900757,
0.07357991486787796,
0.11797783523797989,
0.06062450632452965,
0.07441388070583344,
0.009844478219747543,
-0.057254452258348465,
-0.03702402487397194,
0.07231252640485764,
-0.03541791811585426,
-0.04353799670934677,
0.011445057578384876,
0.03766538202762604,
-0.042284... | 0.020973 |
1, 3] }, "highlight" : { <1> "0\_message" : [ "*bonsai* *tree*" ], "3\_message" : [ "office *tree*" ], "1\_message" : [ "new *tree*" ] } } ] } } -------------------------------------------------- // TESTRESPONSE[s/"took": 13,/"took": "$body.took",/] <1> The highlight fields have been prefixed with the document slot the... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/percolate-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.01294359564781189,
0.09002066403627396,
0.08721579611301422,
0.10434100031852722,
0.06467480957508087,
0.03414217010140419,
0.07728055119514465,
-0.033374566584825516,
0.10600853711366653,
-0.04744277521967888,
-0.0347614660859108,
-0.06903395801782608,
0.04876963049173355,
-0.046130947... | 0.043058 |
the percolator document). These queries are marked by the percolator and can be found by running the following search: [source,js] --------------------------------------------------- GET /\_search { "query": { "term" : { "query.extraction\_result" : "failed" } } } --------------------------------------------------- // ... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/percolate-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.047841548919677734,
-0.01036386750638485,
0.01147411484271288,
0.07628888636827469,
-0.00781948957592249,
0.02059260383248329,
0.014782785438001156,
-0.042638782411813736,
0.03864946961402893,
-0.03466484695672989,
-0.03129447624087334,
-0.04821106046438217,
0.01710772141814232,
-0.0320... | 0.098903 |
[[query-dsl-function-score-query]] === Function Score Query The `function\_score` allows you to modify the score of documents that are retrieved by a query. This can be useful if, for example, a score function is computationally expensive and it is sufficient to compute the score on a filtered set of documents. To use ... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/function-score-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.09743360430002213,
0.07186246663331985,
-0.032694220542907715,
0.10156609863042831,
0.016520939767360687,
0.0634467601776123,
0.02855236642062664,
0.06175685301423073,
0.07016045600175858,
-0.06696745753288269,
-0.07522295415401459,
0.0015561756445094943,
0.045061010867357254,
-0.032410... | 0.058834 |
meet a certain score threshold the `min\_score` parameter can be set to the desired score threshold. NOTE: For `min\_score` to work, \*\*all\*\* documents returned by the query need to be scored and then filtered out one by one. [[score-functions]] The `function\_score` query provides several types of score functions. ... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/function-score-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.0338316336274147,
0.06212751939892769,
-0.031360309571027756,
0.09071001410484314,
-0.008952726610004902,
0.0623980276286602,
0.0561441145837307,
0.08924984931945801,
0.011707954108715057,
0.004130041226744652,
-0.06377731263637543,
-0.03327628970146179,
0.10524073243141174,
-0.00937717... | 0.038903 |
of memory. [source,js] -------------------------------------------------- GET /\_search { "query": { "function\_score": { "random\_score": { "seed": 10, "field": "\_seq\_no" } } } } -------------------------------------------------- // CONSOLE // TEST[setup:twitter] [[function-field-value-factor]] ==== Field Value fact... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/function-score-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.011386341415345669,
0.08062639087438583,
-0.10724280029535294,
0.09122086316347122,
0.06658989936113358,
0.0563075877726078,
0.060184117406606674,
0.051201216876506805,
0.08678004145622253,
-0.04671524837613106,
0.0061714365147054195,
0.008988792076706886,
0.060509417206048965,
-0.06224... | 0.049581 |
<2> The specified field must be a numeric, date, or geo-point field. In the above example, the field is a <> and origin can be provided in geo format. `scale` and `offset` must be given with a unit in this case. If your field is a date field, you can set `scale` and `offset` as days, weeks, and so on. Example: [source,... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/function-score-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.001985767390578985,
0.08397559821605682,
0.01126586552709341,
0.06543352454900742,
0.0033996470738202333,
0.09941727668046951,
-0.0654987320303917,
0.048641081899404526,
0.024543508887290955,
-0.03184972330927849,
-0.026344692334532738,
-0.041457757353782654,
-0.012124355882406235,
-0.0... | 0.036402 |
score takes the value `decay` at distance `scale` from `origin`+-`offset` image:images/s\_calc.png[] In contrast to the normal and exponential decay, this function actually sets the score to 0 if the field value exceeds twice the user given scale value. -- For single functions the three decay functions together with th... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/function-score-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.010922162793576717,
0.0453459694981575,
-0.04808105528354645,
-0.017955206334590912,
0.03515971079468727,
-0.011528071947395802,
-0.052395254373550415,
0.05867372825741768,
0.0942334458231926,
-0.0196396317332983,
0.03326814994215965,
-0.01948367804288864,
0.03438906371593475,
0.0195103... | 0.080064 |
cheap (about 13 Euros) so it gets a low factor a factor of 0.56. "BnB Bellevue" and "Backback Nap" are both pretty close to the defined location but "BnB Bellevue" is cheaper, so it gets a multiplier of 0.86 whereas "Backpack Nap" gets a value of 0.66. [[exp-decay]] ===== Exponential decay, keyword `exp` When choosing ... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/function-score-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.023805195465683937,
0.043206579983234406,
-0.02711191214621067,
-0.0015580967301502824,
0.10307265818119049,
-0.09297619014978409,
-0.005533973686397076,
0.07507094740867615,
0.07448859512805939,
0.023485371842980385,
0.07284057885408401,
-0.042070839554071426,
0.006455208640545607,
0.0... | 0.027238 |
[[query-dsl-bool-query]] === Bool Query A query that matches documents matching boolean combinations of other queries. The bool query maps to Lucene `BooleanQuery`. It is built using one or more boolean clauses, each clause with a typed occurrence. The occurrence types are: [cols="<,<",options="header",] |=============... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/bool-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.012832489795982838,
0.05699903890490532,
0.02319028601050377,
0.04753377288579941,
-0.018882500007748604,
0.03240842744708061,
0.08531887084245682,
-0.051039960235357285,
0.004601737484335899,
-0.0355985127389431,
-0.055010221898555756,
-0.054121825844049454,
0.0538422130048275,
0.00401... | 0.07773 |
{ "constant\_score": { "filter": { "term": { "status": "active" } } } } } --------------------------------- // CONSOLE ==== Using named queries to see which clauses matched If you need to know which of the clauses in the bool query matched the documents returned from the query, you can use <> to assign a name to each c... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/bool-query.asciidoc | 6.2 | elasticsearch-6-2 | [
0.0430227555334568,
0.12485996633768082,
-0.013973929919302464,
0.10227601230144501,
0.015029995702207088,
0.052358128130435944,
0.03569608926773071,
-0.03685757517814636,
0.0015228352276608348,
0.030579503625631332,
-0.030590226873755455,
-0.1081780344247818,
0.004079224541783333,
0.02338... | 0.056759 |
[[full-text-queries]] == Full text queries The high-level full text queries are usually used for running full text queries on full text fields like the body of an email. They understand how the field being queried is <> and will apply each field's `analyzer` (or `search\_analyzer`) to the query string before executing.... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/full-text-queries.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.0217914916574955,
0.06465333700180054,
0.07858158648014069,
0.048316072672605515,
0.026278721168637276,
-0.02017177641391754,
0.07324805855751038,
-0.008381196297705173,
0.024964231997728348,
-0.0199238583445549,
0.013380533084273338,
0.008029397577047348,
0.05325338616967201,
-0.028574... | 0.129851 |
[[query-dsl-exists-query]] === Exists Query Returns documents that have at least one non-`null` value in the original field: [source,js] -------------------------------------------------- GET /\_search { "query": { "exists" : { "field" : "user" } } } -------------------------------------------------- // CONSOLE For ins... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/exists-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.0706552118062973,
0.0952702984213829,
0.02072962373495102,
0.05725260451436043,
0.000978844822384417,
-0.0025815994013100863,
0.010882500559091568,
0.022968599572777748,
0.1019020676612854,
-0.08201173692941666,
-0.017937030643224716,
-0.0828709825873375,
0.019088970497250557,
-0.051878... | 0.019151 |
[[query-dsl-span-not-query]] === Span Not Query Removes matches which overlap with another span query or which are within x tokens before (controlled by the parameter `pre`) or y tokens after (controled by the parameter `post`) another SpanQuery. The span not query maps to Lucene `SpanNotQuery`. Here is an example: [so... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/span-not-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.012348353862762451,
0.08915559947490692,
0.05649779736995697,
0.08187050372362137,
0.03700904920697212,
-0.006080604624003172,
0.03135405108332634,
-0.07642107456922531,
0.0359744168817997,
-0.10509735345840454,
0.010475916787981987,
-0.01429289486259222,
0.026594186201691628,
-0.048572... | 0.029157 |
[[query-dsl-match-query-phrase-prefix]] === Match Phrase Prefix Query The `match\_phrase\_prefix` is the same as `match\_phrase`, except that it allows for prefix matches on the last term in the text. For example: [source,js] -------------------------------------------------- GET /\_search { "query": { "match\_phrase\_... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/match-phrase-prefix-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.08340345323085785,
0.02512085996568203,
0.06054777652025223,
0.045604854822158813,
-0.006949920207262039,
0.006532587110996246,
0.06547867506742477,
0.028164248913526535,
0.07137878984212875,
-0.07005888968706131,
-0.030047744512557983,
-0.0020776093006134033,
0.0024483094457536936,
-0.... | 0.066965 |
[[query-dsl-match-query]] === Match Query `match` queries accept text/numerics/dates, analyzes them, and constructs a query. For example: [source,js] -------------------------------------------------- GET /\_search { "query": { "match" : { "message" : "this is a test" } } } ---------------------------------------------... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/match-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.07129529863595963,
0.14043405652046204,
0.004660457838326693,
0.09993178397417068,
-0.0017159857088699937,
0.011936384253203869,
0.06916233152151108,
0.007541805040091276,
0.07192566990852356,
-0.06428466737270355,
-0.06688814610242844,
-0.05398143082857132,
-0.02129983715713024,
0.0160... | 0.086091 |
the total number of documents if in the range `[0..1)` or absolute if greater or equal to `1.0`. Here is an example showing a query composed of stopwords exclusively: [source,js] -------------------------------------------------- GET /\_search { "query": { "match" : { "message" : { "query" : "to be or not to be", "cuto... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/match-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.03560619801282883,
0.07054581493139267,
0.012418100610375404,
0.07124064862728119,
0.0024194936268031597,
0.022877663373947144,
0.025005482137203217,
0.03433971852064133,
0.0652133896946907,
-0.008042432367801666,
0.0025468512903898954,
0.0029565177392214537,
0.012396316044032574,
-0.05... | 0.046602 |
[[query-dsl-geo-bounding-box-query]] === Geo Bounding Box Query A query allowing to filter hits based on a point location using a bounding box. Assuming the following indexed document: [source,js] -------------------------------------------------- PUT /my\_locations { "mappings": { "\_doc": { "properties": { "pin": { "... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/geo-bounding-box-query.asciidoc | 6.2 | elasticsearch-6-2 | [
0.047188207507133484,
0.08217350393533707,
0.10405917465686798,
0.04829845204949379,
0.00808827392756939,
-0.012688137590885162,
0.02190721221268177,
0.010729419998824596,
0.04135093465447426,
-0.0351058691740036,
-0.10298410058021545,
0.034581612795591354,
0.0015753413317725062,
-0.004433... | 0.011826 |
of setting the values pairwise, one can use the simple names `top`, `left`, `bottom` and `right` to set the values separately. [source,js] -------------------------------------------------- GET /\_search { "query": { "bool" : { "must" : { "match\_all" : {} }, "filter" : { "geo\_bounding\_box" : { "pin.location" : { "to... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/geo-bounding-box-query.asciidoc | 6.2 | elasticsearch-6-2 | [
0.018381716683506966,
0.07354193925857544,
0.035679809749126434,
0.03731798753142357,
0.008364474400877953,
0.03302391618490219,
0.05346451327204704,
-0.012285670265555382,
0.041944168508052826,
-0.08091801404953003,
-0.11640971153974533,
-0.006322737317532301,
0.005869320593774319,
-0.025... | -0.028994 |
[[query-dsl-geo-shape-query]] === GeoShape Query Filter documents indexed using the `geo\_shape` type. Requires the <>. The `geo\_shape` query uses the same grid square representation as the `geo\_shape` mapping to find documents that have a shape that intersects with the query shape. It will also use the same PrefixTr... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/geo-shape-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.027885692194104195,
0.06257570534944534,
0.08258552104234695,
0.08418808877468109,
-0.0440223328769207,
-0.04293021187186241,
0.012929420918226242,
-0.007303270511329174,
0.0447063222527504,
-0.08069723099470139,
-0.06444534659385681,
0.015136647038161755,
0.008743331767618656,
-0.03236... | 0.026241 |
an exception if the field is not mapped. | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/geo-shape-query.asciidoc | 6.2 | elasticsearch-6-2 | [
0.08034753799438477,
0.047812025994062424,
-0.011319809593260288,
0.011079231277108192,
-0.0350085124373436,
-0.015672793611884117,
0.006229921244084835,
0.02044473960995674,
0.007109116762876511,
-0.00160536530893296,
0.06778351962566376,
-0.005568084307014942,
0.06024480611085892,
-0.080... | 0.014405 |
[[specialized-queries]] == Specialized queries This group contains queries which do not fit into the other groups: <>:: This query finds documents which are similar to the specified text, document, or collection of documents. <>:: This query allows a script to act as a filter. Also see the <>. <>:: This query finds que... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/special-queries.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.02695947326719761,
0.06630656868219376,
0.0015461251605302095,
0.07380171865224838,
0.014329942874610424,
-0.018917622044682503,
0.07430969923734665,
0.011434908956289291,
0.027665400877594948,
-0.08191990852355957,
0.03850739076733589,
-0.03377567604184151,
0.007357426919043064,
-0.021... | 0.132905 |
[[query-dsl-dis-max-query]] === Dis Max Query A query that generates the union of documents produced by its subqueries, and that scores each document with the maximum score for that document as produced by any subquery, plus a tie breaking increment for any additional matching subqueries. This is useful when searching ... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/dis-max-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.04751284793019295,
0.0502740703523159,
0.014318469911813736,
0.00035256947739981115,
-0.0313774049282074,
0.030187463387846947,
0.034469764679670334,
0.018364207819104195,
-0.0005509202601388097,
-0.013295643031597137,
-0.11992321908473969,
-0.03401726856827736,
0.03800031170248985,
-0.... | 0.016891 |
[[query-dsl-regexp-query]] === Regexp Query The `regexp` query allows you to use regular expression term queries. See <> for details of the supported regular expression language. The "term queries" in that first sentence means that Elasticsearch will apply the regexp to the terms produced by the tokenizer for that fiel... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/regexp-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.04423593729734421,
0.08843988925218582,
0.09530249238014221,
0.059418439865112305,
0.0013918105978518724,
-0.003612404689192772,
0.025884991511702538,
-0.010020418092608452,
0.09479567408561707,
-0.018110694363713264,
-0.09061525762081146,
-0.023168466985225677,
-0.03670383617281914,
0.... | 0.035908 |
[[query-dsl-span-term-query]] === Span Term Query Matches spans containing a term. The span term query maps to Lucene `SpanTermQuery`. Here is an example: [source,js] -------------------------------------------------- GET /\_search { "query": { "span\_term" : { "user" : "kimchy" } } } ----------------------------------... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/span-term-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.06263700127601624,
0.03943074867129326,
-0.0072051892057061195,
0.08481362462043762,
-0.011136505752801895,
0.056346867233514786,
0.02728419192135334,
-0.02274535782635212,
-0.00550872553139925,
-0.0967797189950943,
-0.05315014719963074,
-0.037284255027770996,
0.016629047691822052,
-0.0... | 0.035932 |
[[query-dsl-prefix-query]] === Prefix Query Matches documents that have fields containing terms with a specified prefix (\*not analyzed\*). The prefix query maps to Lucene `PrefixQuery`. The following matches documents where the user field contains a term that starts with `ki`: [source,js] -----------------------------... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/prefix-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.10067646205425262,
0.0769786611199379,
-0.027526844292879105,
0.07015042752027512,
-0.041642386466264725,
0.028473004698753357,
0.061502426862716675,
-0.01804489642381668,
0.017754971981048584,
-0.09675261378288269,
-0.005839565768837929,
-0.05330049246549606,
0.024891046807169914,
-0.0... | 0.085977 |
[[compound-queries]] == Compound queries Compound queries wrap other compound or leaf queries, either to combine their results and scores, to change their behaviour, or to switch from query to filter context. The queries in this group are: <>:: A query which wraps another query, but executes it in filter context. All m... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/compound-queries.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.020169759169220924,
0.04270491003990173,
-0.011057063937187195,
0.02671349048614502,
0.027833854779601097,
-0.023477710783481598,
0.0066457451321184635,
-0.005186782218515873,
0.03827133774757385,
0.04775046929717064,
0.03186989203095436,
-0.04026661440730095,
0.06015791743993759,
-0.01... | 0.111096 |
[[query-dsl-geo-polygon-query]] === Geo Polygon Query A query allowing to include hits that only fall within a polygon of points. Here is an example: [source,js] -------------------------------------------------- GET /\_search { "query": { "bool" : { "must" : { "match\_all" : {} }, "filter" : { "geo\_polygon" : { "pers... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/geo-polygon-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.0018835854716598988,
0.09547611325979233,
0.08426569402217865,
0.03087124042212963,
0.06793104112148285,
-0.002670089015737176,
0.0783843845129013,
-0.02150687575340271,
0.027307480573654175,
-0.07406643778085709,
-0.0501101091504097,
-0.058234963566064835,
0.011673224158585072,
-0.0268... | 0.037496 |
[[query-dsl-wildcard-query]] === Wildcard Query Matches documents that have fields matching a wildcard expression (\*not analyzed\*). Supported wildcards are `\*`, which matches any character sequence (including the empty one), and `?`, which matches any single character. Note that this query can be slow, as it needs t... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/wildcard-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.008677687495946884,
0.06661796569824219,
0.02724243700504303,
0.07735242694616318,
-0.030825048685073853,
0.02573498524725437,
0.010780714452266693,
-0.0028168968856334686,
0.0382898673415184,
-0.10261540859937668,
-0.04108022153377533,
-0.06412903219461441,
-0.01814456097781658,
0.0157... | 0.048663 |
[[span-queries]] == Span queries Span queries are low-level positional queries which provide expert control over the order and proximity of the specified terms. These are typically used to implement very specific queries on legal documents or patents. Span queries cannot be mixed with non-span queries (with the excepti... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/span-queries.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.030079372227191925,
0.05428712069988251,
0.020472107455134392,
0.04413065314292908,
0.0054103899747133255,
-0.010646147653460503,
0.025465302169322968,
-0.03719472885131836,
0.05324563384056091,
0.005485426168888807,
0.034823786467313766,
0.02662305347621441,
0.09281719475984573,
-0.067... | 0.115706 |
[[query-dsl-common-terms-query]] === Common Terms Query The `common` terms query is a modern alternative to stopwords which improves the precision and recall of search results (by taking stopwords into account), without sacrificing performance. [float] ==== The problem Every term in a query has a cost. A search for `"T... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/common-terms-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.05207045003771782,
0.032572001218795776,
0.02147660031914711,
0.0517645962536335,
0.010132663883268833,
-0.010780835524201393,
0.039315566420555115,
-0.01829114556312561,
0.05844167619943619,
0.008036930114030838,
-0.011330696754157543,
-0.004476331174373627,
0.01979498751461506,
-0.034... | 0.044055 |
<> (`high\_freq`, `low\_freq`), `low\_freq\_operator` (default `"or"`) and `high\_freq\_operator` (default `"or"`) parameters. For low frequency terms, set the `low\_freq\_operator` to `"and"` to make all terms required: [source,js] -------------------------------------------------- GET /\_search { "query": { "common":... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/query-dsl/common-terms-query.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.008916255086660385,
0.052446819841861725,
0.021350184455513954,
0.044972117990255356,
-0.08041096478700638,
0.02261197380721569,
0.016884591430425644,
0.036249127238988876,
0.04064220190048218,
-0.038856521248817444,
-0.00881808903068304,
-0.07426434755325317,
0.023515505716204643,
-0.0... | -0.007829 |
[[index-modules-slowlog]] == Slow Log [float] [[search-slow-log]] === Search Slow Log Shard level slow search log allows to log slow search (query and fetch phases) into a dedicated log file. Thresholds can be set for both the query phase of the execution, and fetch phase, here is a sample: [source,yaml] --------------... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/index-modules/slowlog.asciidoc | 6.2 | elasticsearch-6-2 | [
0.03331250324845314,
0.03972741588950157,
-0.02183951996266842,
0.06341300159692764,
0.05661066994071007,
-0.09227056801319122,
0.006217256188392639,
-0.028044626116752625,
0.08153298497200012,
0.025957617908716202,
0.03502175956964493,
-0.02704651840031147,
0.03873370960354805,
-0.0278831... | 0.085319 |
[[index-modules-similarity]] == Similarity module A similarity (scoring / ranking model) defines how matching documents are scored. Similarity is per field, meaning that via the mapping one can define a different similarity per field. Configuring a custom similarity is considered an expert feature and the builtin simil... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/index-modules/similarity.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.06085962429642677,
-0.01935099996626377,
-0.047856975346803665,
0.0569903627038002,
0.014467291533946991,
0.04310208931565285,
-0.06214200705289841,
0.01978340558707714,
0.03636282682418823,
-0.10083455592393875,
0.0002053350181085989,
0.012714563868939877,
0.03372202813625336,
0.058325... | 0.08272 |
noise. This similarity has the following options: [horizontal] `lambda`:: The optimal value depends on both the collection and the query. The optimal value is around `0.1` for title queries and `0.7` for long queries. Default to `0.1`. When value approaches `0`, documents that match more query terms will be ranked high... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/index-modules/similarity.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.02355792373418808,
-0.04878713935613632,
-0.04381553828716278,
-0.018225574865937233,
-0.0025300749111920595,
-0.01245935633778572,
0.018217958509922028,
-0.01736113242805004,
0.07418898493051529,
-0.03232325240969658,
-0.013260887004435062,
-0.03538317605853081,
0.07794657349586487,
0.... | -0.015445 |
{ "field": "foo bar foo" } PUT /index/\_doc/2 { "field": "bar baz" } POST /index/\_refresh GET /index/\_search?explain=true { "query": { "query\_string": { "query": "foo^1.7", "default\_field": "field" } } } -------------------------------------------------- // CONSOLE // TEST[continued] [source,js] -------------------... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/index-modules/similarity.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.027720896527171135,
0.09863844513893127,
0.06480385363101959,
0.12032634019851685,
-0.019194381311535835,
0.02578103169798851,
-0.014123758301138878,
0.010955044999718666,
0.09399451315402985,
-0.029752470552921295,
-0.03099551796913147,
-0.0047383601777255535,
-0.02572689764201641,
-0.... | 0.080318 |
[[index-modules-store]] == Store The store module allows you to control how index data is stored and accessed on disk. [float] [[file-system]] === File system storage types There are different file system implementations or \_storage types\_. By default, Elasticsearch will pick the best implementation based on the oper... | https://github.com/elastic/elasticsearch/blob/6.2/docs/reference/index-modules/store.asciidoc | 6.2 | elasticsearch-6-2 | [
0.01055145263671875,
0.055477842688560486,
-0.031091934069991112,
0.08470050245523453,
0.00496898265555501,
-0.015476391650736332,
-0.02746165730059147,
0.015672098845243454,
0.08780549466609955,
0.04361940920352936,
-0.011217198334634304,
0.037240080535411835,
-0.012433657422661781,
-0.01... | 0.12499 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.