content large_stringlengths 3 20.5k | url large_stringlengths 54 193 | branch large_stringclasses 4
values | source large_stringclasses 42
values | embeddings listlengths 384 384 | score float64 -0.21 0.65 |
|---|---|---|---|---|---|
[[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 |
that are actively searched, you might want to set it to `["nvd", "dvd"]`, which will cause norms and doc values to be loaded eagerly into physical memory. These are the two first extensions to look at since Elasticsearch performs random access on them. A wildcard can be used in order to indicate that all files should b... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/index-modules/store.asciidoc | 6.2 | elasticsearch-6-2 | [
0.055978335440158844,
0.03640057146549225,
-0.02872389927506447,
0.08121277391910553,
0.02384774200618267,
0.0274385754019022,
-0.035638753324747086,
0.008564461022615433,
0.10786271095275879,
0.04733465984463692,
-0.024180490523576736,
0.07758621871471405,
0.01093283761292696,
0.005808218... | 0.0817 |
[[index-modules-merge]] == Merge A shard in Elasticsearch is a Lucene index, and a Lucene index is broken down into segments. Segments are internal storage elements in the index where the index data is stored, and are immutable. Smaller segments are periodically merged into larger segments to keep the index size at bay... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/index-modules/merge.asciidoc | 6.2 | elasticsearch-6-2 | [
0.01141262799501419,
-0.029323147609829903,
0.022977503016591072,
0.02900865115225315,
-0.01856408454477787,
-0.07893270254135132,
-0.05147845298051834,
-0.017537817358970642,
0.07199743390083313,
-0.014505485072731972,
-0.01020438689738512,
0.06058437377214432,
-0.02500428631901741,
-0.00... | 0.136324 |
[[index-modules-index-sorting]] == Index Sorting beta[] When creating a new index in Elasticsearch it is possible to configure how the Segments inside each Shard will be sorted. By default Lucene does not apply any sort. The `index.sort.\*` settings define which fields should be used to sort the documents inside each S... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/index-modules/index-sorting.asciidoc | 6.2 | elasticsearch-6-2 | [
0.02860996685922146,
0.05969217047095299,
0.068672314286232,
0.027830258011817932,
-0.01580551639199257,
0.014184304513037205,
-0.0690104141831398,
-0.0028569060377776623,
0.07439517974853516,
0.025791266933083534,
-0.04636310040950775,
0.09125965088605881,
-0.03316056355834007,
0.04080673... | 0.017087 |
"sort.order" : "desc" <1> } }, "mappings": { "doc": { "properties": { "timestamp": { "type": "date" } } } } } -------------------------------------------------- // CONSOLE <1> This index is sorted by timestamp in descending order (most recent first) You can search for the last 10 events with: [source,js] --------------... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/index-modules/index-sorting.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.0035773993004113436,
0.05182868242263794,
0.08347707986831665,
0.0053873914293944836,
0.014779477380216122,
0.07107417285442352,
-0.04168829321861267,
0.04079999774694443,
0.11856833845376968,
0.02073834463953972,
-0.04947907477617264,
0.04880775511264801,
-0.09442926198244095,
0.039147... | -0.007799 |
[[index-modules-translog]] == Translog Changes to Lucene are only persisted to disk during a Lucene commit, which is a relatively expensive operation and so cannot be performed after every index or delete operation. Changes that happen after one commit and before another will be removed from the index by Lucene in the ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/index-modules/translog.asciidoc | 6.2 | elasticsearch-6-2 | [
0.05368557199835777,
-0.010775706730782986,
0.054144132882356644,
0.07372032850980759,
-0.011551165021955967,
-0.02757634036242962,
-0.026927437633275986,
-0.06644991040229797,
0.08423017710447311,
0.05020950734615326,
-0.03459734842181206,
0.08915060013532639,
-0.0494779497385025,
-0.0144... | 0.152097 |
back to a file based sync. Defaults to `512mb` `index.translog.retention.age`:: The maximum duration for which translog files will be kept. Defaults to `12h`. [float] [[corrupt-translog-truncation]] === What to do if the translog becomes corrupted? In some cases (a bad drive, user error) the translog on a shard copy ca... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/index-modules/translog.asciidoc | 6.2 | elasticsearch-6-2 | [
0.02745375968515873,
0.04722117632627487,
0.02577059715986252,
0.004111393354833126,
0.01732289232313633,
-0.059213750064373016,
-0.029968300834298134,
-0.018049446865916252,
0.021515563130378723,
0.07236813753843307,
-0.011032591573894024,
0.07733912765979767,
0.02309168316423893,
-0.0122... | 0.071325 |
[[delayed-allocation]] === Delaying allocation when a node leaves When a node leaves the cluster for whatever reason, intentional or otherwise, the master reacts by: \* Promoting a replica shard to primary to replace any primaries that were on the node. \* Allocating replica shards to replace the missing replicas (assu... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/index-modules/allocation/delayed.asciidoc | 6.2 | elasticsearch-6-2 | [
0.004684184677898884,
-0.01235736533999443,
0.061289966106414795,
0.04820053651928902,
0.07725390791893005,
0.03343439847230911,
-0.018918542191386223,
-0.09020579606294632,
0.0842776894569397,
0.03464988246560097,
0.032759517431259155,
0.06535196304321289,
0.06742969155311584,
-0.06276883... | 0.092826 |
shards The number of shards whose allocation has been delayed by this timeout setting can be viewed with the <>: [source,js] ------------------------------ GET \_cluster/health <1> ------------------------------ // CONSOLE <1> This request will return a `delayed\_unassigned\_shards` value. ==== Removing a node permanen... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/index-modules/allocation/delayed.asciidoc | 6.2 | elasticsearch-6-2 | [
0.03281685709953308,
0.045765336602926254,
0.017092682421207428,
0.12046975642442703,
0.01478863786906004,
-0.023033970966935158,
-0.0621965266764164,
-0.06566663831472397,
0.0984284058213234,
0.005296103190630674,
0.027054045349359512,
0.007923698052763939,
0.011964053846895695,
-0.046507... | 0.03325 |
[[recovery-prioritization]] === Index recovery prioritization Unallocated shards are recovered in order of priority, whenever possible. Indices are sorted into priority order as follows: \* the optional `index.priority` setting (higher before lower) \* the index creation date (higher before lower) \* the index name (hi... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/index-modules/allocation/prioritization.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.0328843928873539,
0.013642479665577412,
0.07749888300895691,
0.05667562037706375,
-0.004149055108428001,
0.006527051329612732,
-0.055571578443050385,
-0.06406669318675995,
0.0742233395576477,
0.00239595677703619,
-0.004391193389892578,
0.08823558688163757,
-0.04035460203886032,
-0.00183... | 0.012281 |
[[shard-allocation-filtering]] === Shard Allocation Filtering Shard allocation filtering allows you to specify which nodes are allowed to host the shards of a particular index. NOTE: The per-index shard allocation filters explained below work in conjunction with the cluster-wide allocation filters explained in <>. It i... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/index-modules/allocation/filtering.asciidoc | 6.2 | elasticsearch-6-2 | [
0.11408616602420807,
0.03897561505436897,
0.014712815172970295,
0.04006312042474747,
0.039825085550546646,
-0.011641230434179306,
-0.022753747180104256,
-0.06716826558113098,
0.007523599546402693,
0.01566939800977707,
-0.06635266542434692,
-0.007372951600700617,
0.04923929646611214,
0.0031... | 0.044452 |
[[allocation-total-shards]] === Total Shards Per Node The cluster-level shard allocator tries to spread the shards of a single index across as many nodes as possible. However, depending on how many shards and indices you have, and how big they are, it may not always be possible to spread shards evenly. The following \_... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/index-modules/allocation/total_shards.asciidoc | 6.2 | elasticsearch-6-2 | [
0.09084205329418182,
-0.033960696309804916,
0.028841841965913773,
0.045457664877176285,
-0.0045175375416874886,
-0.05139965936541557,
-0.03557725250720978,
-0.03172723948955536,
0.000443206139607355,
0.026984812691807747,
-0.03145943582057953,
0.00436474708840251,
0.019573088735342026,
0.0... | 0.025513 |
[[modules-scripting]] == Scripting The scripting module enables you to use scripts to evaluate custom expressions. For example, you could use a script to return "script fields" as part of a search request or evaluate a custom score for a query. The default scripting language is <>. Additional `lang` plugins enable you ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/modules/scripting.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.037537459284067154,
0.08396963775157928,
-0.08201344311237335,
0.068011574447155,
-0.005985076539218426,
0.05247296020388603,
0.03347879275679588,
0.05373116955161095,
-0.01873823069036007,
-0.02378896065056324,
-0.029735928401350975,
-0.09500481188297272,
0.07077591866254807,
-0.005442... | 0.11895 |
[[modules-thrift]] == Thrift The https://thrift.apache.org/[thrift] transport module allows to expose the REST interface of Elasticsearch using thrift. Thrift should provide better performance over http. Since thrift provides both the wire protocol and the transport, it should make using Elasticsearch more efficient (t... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/modules/thrift.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.03925185278058052,
0.09058860689401627,
-0.05002722516655922,
0.04029802232980728,
0.018316462635993958,
-0.011944010853767395,
-0.053658775985240936,
0.03974101319909096,
-0.03224339336156845,
0.014916833490133286,
-0.07801060378551483,
0.01882709376513958,
0.03536475449800491,
-0.0340... | 0.093407 |
[[modules-gateway]] == Local Gateway The local gateway module stores the cluster state and shard data across full cluster restarts. The following \_static\_ settings, which must be set on every master node, control how long a freshly elected master should wait before it tries to recover the cluster state and the cluste... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/modules/gateway.asciidoc | 6.2 | elasticsearch-6-2 | [
0.0521073043346405,
-0.030562296509742737,
0.028081681579351425,
0.06694180518388748,
0.03501703217625618,
-0.002069137990474701,
-0.04377484694123268,
-0.048784174025058746,
0.058182716369628906,
0.013839281164109707,
0.030728479847311974,
0.03705768287181854,
0.02917926385998726,
-0.0343... | 0.08943 |
[[modules-network]] == Network Settings Elasticsearch binds to localhost only by default. This is sufficient for you to run a local development server (or even a development cluster, if you start multiple nodes on the same machine), but you will need to configure some <> in order to run a real production cluster across... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/modules/network.asciidoc | 6.2 | elasticsearch-6-2 | [
0.08248692750930786,
0.0025324623566120863,
-0.028592152521014214,
0.024251310154795647,
-0.008372055366635323,
-0.03342612832784653,
-0.09131792187690735,
-0.044692881405353546,
-0.008735922165215015,
0.046838898211717606,
-0.051874373108148575,
-0.06522110849618912,
0.029193704947829247,
... | 0.077909 |
should bind to in order to listen for incoming requests. A node can bind to multiple interfaces, e.g. two network cards, or a site-local address and a local address. Defaults to `network.host`. `network.publish\_host`:: The publish host is the single interface that the node advertises to other nodes in the cluster, so ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/modules/network.asciidoc | 6.2 | elasticsearch-6-2 | [
0.05317342281341553,
0.0009643422672525048,
-0.026834432035684586,
0.03787221014499664,
-0.0579252727329731,
-0.029062265530228615,
-0.08423466980457306,
-0.05842011794447899,
0.02104538306593895,
0.044011425226926804,
-0.11186239868402481,
0.0080694779753685,
0.003414782928302884,
-0.0474... | 0.066439 |
[[modules-http]] == HTTP The http module allows to expose \*Elasticsearch\* APIs over HTTP. The http mechanism is completely asynchronous in nature, meaning that there is no blocking thread waiting for a response. The benefit of using asynchronous communication for HTTP is solving the http://en.wikipedia.org/wiki/C10k\... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/modules/http.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.05967864766716957,
0.061241116374731064,
-0.035697031766176224,
0.03844641521573067,
0.0029072233010083437,
-0.0801592692732811,
-0.08822125941514969,
-0.08065414428710938,
0.06312738358974457,
0.015321561135351658,
-0.06612048298120499,
0.017974045127630234,
-0.022502150386571884,
-0.0... | 0.102678 |
Defaults to `X-Requested-With, Content-Type, Content-Length`. |`http.cors.allow-credentials` | Whether the `Access-Control-Allow-Credentials` header should be returned. Note: This header is only returned, when the setting is set to `true`. Defaults to `false` |`http.detailed\_errors.enabled` |Enables or disables the ou... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/modules/http.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.047370340675115585,
0.03608259931206703,
-0.07330527901649475,
0.010152405127882957,
-0.025570033118128777,
-0.0949479341506958,
-0.06221085786819458,
-0.000458455178886652,
0.00258879573084414,
0.017752502113580704,
-0.005372064188122749,
0.0018739411607384682,
-0.03749508410692215,
-0... | 0.022436 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.