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 |
|---|---|---|---|---|---|
allocation {pull}20589[#20589] Analysis:: \* AsciiFoldingFilter's multi-term component should never preserve the original token. {pull}21982[#21982] \* Pre-built analysis factories do not implement MultiTermAware correctly. {pull}21981[#21981] \* Can load non-PreBuiltTokenFilter in Analyze API {pull}20396[#20396] \* Na... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/release-notes/6.2.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.07364671677350998,
0.0368175134062767,
0.0011307339882478118,
-0.03817487880587578,
0.019397126510739326,
-0.05614376440644264,
-0.02406204864382744,
-0.00847842451184988,
-0.005712378770112991,
0.03480108082294464,
-0.002321983687579632,
-0.11669253557920456,
-0.0314163975417614,
-0.01... | 0.097038 |
on a stored keyword field {pull}21645[#21645] (issue: {issue}21636[#21636]) \* Fix highlighting of MultiTermQuery within a FunctionScoreQuery {pull}20400[#20400] (issue: {issue}20392[#20392]) Index APIs:: \* Fixes restore of a shrunken index when initial recovery node is gone {pull}24322[#24322] (issue: {issue}24257[#2... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/release-notes/6.2.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.015316013246774673,
0.04156147688627243,
0.04103044420480728,
0.04666783660650253,
0.04381240904331207,
0.015215173363685608,
0.004684089682996273,
-0.046742234379053116,
-0.024355700239539146,
0.02586466073989868,
-0.017103634774684906,
-0.020557057112455368,
0.022639896720647812,
-0.1... | 0.018707 |
Assert status logger does not warn on Log4j usage {pull}21339[#21339] \* Fix logger names for Netty {pull}21223[#21223] (issue: {issue}20457[#20457]) \* Fix logger when you can not create an azure storage client {pull}20670[#20670] (issues: {issue}20633[#20633], {issue}20669[#20669]) \* Avoid unnecessary creation of pr... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/release-notes/6.2.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.001850778004154563,
0.034858256578445435,
0.03825323283672333,
0.05178409442305565,
0.02606813795864582,
-0.03715112805366516,
0.029872501268982887,
-0.058273788541555405,
0.022175928577780724,
0.18593156337738037,
0.03174972906708717,
-0.06774832308292389,
0.05754415690898895,
0.085172... | 0.048591 |
Discovery EC2:: \* Fix ec2 discovery when used with IAM profiles. {pull}21048[#21048] (issue: {issue}21039[#21039]) Plugin Ingest GeoIp:: \* [ingest-geoip] update geoip to not include null-valued results from {pull}20455[#20455] Plugin Lang Painless:: \* painless: Fix method references to ctor with the new LambdaBootst... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/release-notes/6.2.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.05546044930815697,
0.018090741708874702,
0.05579933896660805,
-0.015152025036513805,
-0.04749463498592377,
-0.011267884634435177,
0.031900566071271896,
0.00890516396611929,
-0.050316113978624344,
-0.004557692911475897,
0.057867519557476044,
-0.09165087342262268,
0.014291912317276001,
0.... | 0.082952 |
{pull}23094[#23094] (issue: {issue}21125[#21125]) \* Strict level parsing for indices stats {pull}21577[#21577] (issue: {issue}21024[#21024]) \* The routing query string param is supported by mget but was missing from the rest spec {pull}21357[#21357] \* fix thread\_pool\_patterns path variable definition {pull}21332[#... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/release-notes/6.2.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.04824262112379074,
0.006951136980205774,
0.0033244944643229246,
0.03256111219525337,
-0.015726396813988686,
0.016692372038960457,
-0.003483432810753584,
0.037545427680015564,
-0.05382158234715462,
0.004298222251236439,
-0.03958507627248764,
-0.06513587385416031,
0.001190383918583393,
-0... | 0.02492 |
\* Fix boost\_mode propagation when the function score query builder is rewritten {pull}22172[#22172] (issue: {issue}22138[#22138]) \* FiltersAggregationBuilder: rewriting filter queries, the same way as in FilterAggregationBuilder {pull}22076[#22076] \* Fix cross\_fields type on multi\_match query with synonyms {pull}... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/release-notes/6.2.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.08487357199192047,
0.06854066252708435,
0.04542278125882149,
0.0442228689789772,
-0.0020899653900414705,
0.08118314296007156,
0.008122486993670464,
-0.014645651914179325,
-0.06472442299127579,
-0.022253837436437607,
-0.023781027644872665,
-0.05919260531663895,
-0.013377401977777481,
-0.... | -0.012075 |
tribe nodes {pull}21546[#21546] (issues: {issue}16392[#16392], {issue}21122[#21122]) [float] === Regressions Bulk:: \* Fix \_bulk response when it can't create an index {pull}24048[#24048] (issues: {issue}22488[#22488], {issue}24028[#24028]) Core:: \* Source filtering: only accept array items if the previous include pa... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/release-notes/6.2.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.05965481325984001,
0.048083726316690445,
0.04865044355392456,
0.0651916041970253,
0.048015955835580826,
-0.05433494225144386,
0.001239549950696528,
-0.0696389228105545,
-0.03149465471506119,
0.03383543714880943,
0.03868583217263222,
-0.06972835212945938,
0.00852733850479126,
-0.01461250... | 0.064915 |
[[tune-for-indexing-speed]] == Tune for indexing speed [float] === Use bulk requests Bulk requests will yield much better performance than single-document index requests. In order to know the optimal size of a bulk request, you should run a benchmark on a single node with a single shard. First try to index 100 document... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/how-to/indexing-speed.asciidoc | 6.2 | elasticsearch-6-2 | [
0.045440539717674255,
0.030592404305934906,
-0.03797014057636261,
0.04489479959011078,
0.002562195062637329,
-0.0622667521238327,
-0.057021364569664,
-0.0013247038004919887,
0.017143260687589645,
0.04103171452879906,
-0.08058663457632065,
-0.016597187146544456,
0.0023285187780857086,
-0.04... | 0.085272 |
skip this check, which makes indexing faster. [float] === Use faster hardware If indexing is I/O bound, you should investigate giving more memory to the filesystem cache (see above) or buying faster drives. In particular SSD drives are known to perform better than spinning disks. Always use local storage, remote filesy... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/how-to/indexing-speed.asciidoc | 6.2 | elasticsearch-6-2 | [
0.0333700068295002,
0.04945921152830124,
0.00688703591004014,
0.03978170454502106,
0.03244709223508835,
-0.020412735641002655,
-0.07350537180900574,
-0.006064724177122116,
0.029282866045832634,
0.018470214679837227,
-0.06171061471104622,
-0.0011917188530787826,
0.012156739830970764,
0.0337... | -0.027866 |
[[tune-for-search-speed]] == Tune for search speed [float] === Give memory to the filesystem cache Elasticsearch heavily relies on the filesystem cache in order to make search fast. In general, you should make sure that at least half the available memory goes to the filesystem cache so that Elasticsearch can keep hot r... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/how-to/search-speed.asciidoc | 6.2 | elasticsearch-6-2 | [
0.04598875716328621,
0.06850302219390869,
-0.005590887274593115,
0.04046029970049858,
0.026669815182685852,
-0.009139969944953918,
-0.0856621041893959,
-0.005874329246580601,
0.03320222720503807,
0.041965655982494354,
-0.056025974452495575,
0.05846336856484413,
0.011853940784931183,
-0.004... | 0.028359 |
cacheable since the range that is being matched changes all the time. However switching to a rounded date is often acceptable in terms of user experience, and has the benefit of making better use of the query cache. For instance the below query: [source,js] -------------------------------------------------- PUT index/\... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/how-to/search-speed.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.04550072178244591,
0.07854925096035004,
0.017436614260077477,
0.08888926357030869,
0.00003668944918899797,
0.0410991795361042,
-0.0467851385474205,
0.020563391968607903,
0.06918816268444061,
-0.015179676003754139,
-0.08504772186279297,
0.03013119474053383,
-0.028164450079202652,
-0.0568... | 0.025785 |
will make search \_slower\_ if the filesystem cache is not large enough to hold all the data. Use with caution. [float] [[\_map\_identifiers\_as\_literal\_keyword\_literal]] === Map identifiers as `keyword` When you have numeric identifiers in your documents, it is tempting to map them as numbers, which is consistent w... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/how-to/search-speed.asciidoc | 6.2 | elasticsearch-6-2 | [
0.010355008766055107,
0.05837519094347954,
0.013617442920804024,
0.03479868546128273,
0.014123262837529182,
-0.008327837102115154,
0.0030579452868551016,
0.0016629646997898817,
0.06226063147187233,
0.019766919314861298,
-0.002114679431542754,
0.0571025125682354,
-0.0014440970262512565,
-0.... | 0.08905 |
Tune your queries with the Profile API You can also analyse how expensive each component of your queries and aggregations are using the {ref}/search-profile.html[Profile API]. This might allow you to tune your queries to be less expensive, resulting in a positive performance result and reduced load. Also note that Prof... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/how-to/search-speed.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.0019715253729373217,
0.007948169484734535,
0.007011534180492163,
0.09319810569286346,
0.06968888640403748,
-0.02309785783290863,
-0.038551073521375656,
0.033553048968315125,
-0.007670966442674398,
-0.024753322824835777,
-0.04598616436123848,
-0.055566225200891495,
0.09166369587182999,
-... | 0.01997 |
[[tune-for-disk-usage]] == Tune for disk usage [float] === Disable the features you do not need By default Elasticsearch indexes and adds doc values to most fields so that they can be searched and aggregated out of the box. For instance if you have a numeric field called `foo` that you need to run histograms on but tha... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/how-to/disk-usage.asciidoc | 6.2 | elasticsearch-6-2 | [
0.07110632210969925,
0.11264939606189728,
0.027233758941292763,
0.08126366883516312,
0.024776766076683998,
0.028037352487444878,
-0.010724073275923729,
-0.009846980683505535,
0.05488879233598709,
0.004793785512447357,
-0.09253160655498505,
-0.013682070188224316,
0.016313733533024788,
-0.01... | 0.029314 |
fields at the same time, it can be disabled. [float] [[disable-source]] === Disable `\_source` The <> field stores the original JSON body of the document. If you don’t need access to it you can disable it. However, APIs that needs access to `\_source` such as update and reindex won’t work. [float] [[best-compression]] ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/how-to/disk-usage.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.03880318999290466,
0.09463672339916229,
-0.030663782730698586,
0.07018225640058517,
-0.0026741267647594213,
-0.031774986535310745,
-0.07329820841550827,
-0.026860903948545456,
0.09077364951372147,
0.02881580777466297,
-0.0201881043612957,
0.1054389625787735,
0.019495025277137756,
-0.022... | 0.088905 |
[[general-recommendations]] == General recommendations [float] [[large-size]] === Don't return large result sets Elasticsearch is designed as a search engine, which makes it very good at getting back the top documents that match a query. However, it is not as good for workloads that fall into the database domain, such ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/how-to/general.asciidoc | 6.2 | elasticsearch-6-2 | [
0.006255867891013622,
0.05780363827943802,
0.019930660724639893,
0.06444568186998367,
0.04520764946937561,
0.0074944267980754375,
-0.05411925166845322,
0.0959373190999031,
0.004292823374271393,
0.06302609294652939,
-0.07439855486154556,
0.00820862129330635,
0.027900777757167816,
0.00687791... | 0.048166 |
[[mixing-exact-search-with-stemming]] === Mixing exact search with stemming When building a search application, stemming is often a must as it is desirable for a query on `skiing` to match documents that contain `ski` or `skis`. But what if a user wants to search for `skiing` specifically? The typical way to do this wo... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/how-to/recipes/stemming.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.043282657861709595,
0.09137891978025436,
0.07932683080434799,
0.027593404054641724,
0.022760897874832153,
0.029766716063022614,
-0.009034196846187115,
-0.02931915409862995,
0.05349596589803696,
-0.04107312485575676,
-0.024220339953899384,
0.0027625663205981255,
0.035282015800476074,
0.0... | 0.023132 |
exact search with stemmed search as they like. | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/how-to/recipes/stemming.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.048933859914541245,
0.05313974246382713,
0.0027789431624114513,
-0.021781284362077713,
0.003286700462922454,
-0.02119012363255024,
-0.054365124553442,
-0.000972761947195977,
-0.02684570662677288,
-0.010437441989779472,
0.020025962963700294,
0.02008114941418171,
0.02971033751964569,
0.03... | 0.070526 |
[[consistent-scoring]] === Getting consistent scoring The fact that Elasticsearch operates with shards and replicas adds challenges when it comes to having good scoring. [float] ==== Scores are not reproducible Say the same user runs the same request twice in a row and documents do not come back in the same order both ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/how-to/recipes/scoring.asciidoc | 6.2 | elasticsearch-6-2 | [
0.022341012954711914,
0.004920675419270992,
0.07222875207662582,
0.05520416796207428,
0.008375418372452259,
-0.021098235622048378,
-0.06057951971888542,
-0.056323401629924774,
0.13195295631885529,
0.015604469925165176,
-0.05712883174419403,
0.06089593842625618,
0.08542405813932419,
0.00291... | 0.000812 |
single shard (`index.number\_of\_shards: 1`). Then index statistics will be the same for all documents and scores will be consistent. Otherwise the recommended way to work around this issue is to use the <> search type. This will make Elasticsearch perform an inital round trip to all involved shards, asking them for th... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/how-to/recipes/scoring.asciidoc | 6.2 | elasticsearch-6-2 | [
0.10380729287862778,
-0.00725881103426218,
0.046208228915929794,
0.07264824956655502,
-0.00983159989118576,
0.017077062278985977,
-0.057129036635160446,
-0.0035263733007013798,
0.08707962930202484,
0.027844978496432304,
-0.06239839643239975,
-0.02175699919462204,
0.0711374282836914,
0.0020... | 0.007264 |
[[search-multi-search]] == Multi Search API The multi search API allows to execute several search requests within the same API. The endpoint for it is `\_msearch`. The format of the request is similar to the bulk API format and makes use of the newline delimited JSON (NDJSON) format. the structure is as follows (the st... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/multi-search.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.1365649253129959,
0.06562826037406921,
-0.025991588830947876,
0.005697709508240223,
-0.011619442142546177,
-0.0633268654346466,
-0.033004872500896454,
0.018115749582648277,
0.03628813847899437,
-0.051539719104766846,
-0.0007503960514441133,
-0.033320363610982895,
0.012527963146567345,
-... | 0.16192 |
also create search templates: [source,js] ------------------------------------------ POST /\_scripts/my\_template\_1 { "script": { "lang": "mustache", "source": { "query": { "match": { "message": "{{query\_string}}" } } } } } ------------------------------------------ // CONSOLE // TEST[setup:twitter] [source,js] -----... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/multi-search.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.07600913941860199,
0.06414628028869629,
0.03767223656177521,
0.03492281585931778,
0.0066126021556556225,
0.06899600476026535,
0.03525200113654137,
0.04636595398187637,
0.06008776277303696,
-0.09986931830644608,
-0.010522431693971157,
-0.03412094712257385,
0.029678599908947945,
-0.016738... | 0.033053 |
[[search-search]] == Search The search API allows you to execute a search query and get back search hits that match the query. The query can either be provided using a simple <>, or using a <>. ["float",id="search-multi-index-type"] === Multi-Index, Multi-Type All search APIs can be applied across multiple types within... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/search.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.03200649097561836,
0.06247922405600548,
-0.015975365415215492,
0.09094427525997162,
0.04037468507885933,
0.026170238852500916,
0.02208922989666462,
-0.0008244389900937676,
0.06846839934587479,
-0.09104031324386597,
-0.0450524277985096,
-0.06135282292962074,
0.06261022388935089,
-0.01603... | 0.071202 |
[[search-count]] == Count API The count API allows to easily execute a query and get the number of matches for that query. It can be executed across one or more indices and across one or more types. The query can either be provided using a simple query string as a parameter, or using the <> defined within the request b... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/count.asciidoc | 6.2 | elasticsearch-6-2 | [
0.0010329040233045816,
0.03803962841629982,
0.004597800783813,
0.11528506129980087,
-0.04578284174203873,
0.07942706346511841,
0.009074350818991661,
0.03494169935584068,
0.1144568994641304,
-0.04936365783214569,
-0.021264007315039635,
-0.07227173447608948,
0.09979664534330368,
-0.051916085... | 0.064286 |
[[search-validate]] == Validate API The validate API allows a user to validate a potentially expensive query without executing it. We'll use the following test data to explain \_validate: [source,js] -------------------------------------------------- PUT twitter/\_doc/\_bulk?refresh {"index":{"\_id":1}} {"user" : "kimc... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/validate.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.05114731937646866,
0.08857626467943192,
0.028816720470786095,
0.07587142288684845,
0.016069777309894562,
-0.037434451282024384,
-0.005673892796039581,
-0.011386929079890251,
0.06867647171020508,
-0.03785876929759979,
-0.016339169815182686,
-0.06355368345975876,
0.05401024967432022,
-0.0... | 0.066319 |
query may depend on which shard is being hit, and therefore may vary from one request to another. So, in case of query rewrite the `all\_shards` parameter should be used to get response from all available shards. For Fuzzy Queries: [source,js] -------------------------------------------------- GET twitter/\_doc/\_valid... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/validate.asciidoc | 6.2 | elasticsearch-6-2 | [
0.02913709357380867,
0.062146224081516266,
0.08169030398130417,
0.05203652381896973,
-0.002994186244904995,
-0.042444098740816116,
0.0230861809104681,
-0.026691045612096786,
0.09210333228111267,
-0.030411070212721825,
-0.01923637092113495,
-0.03446495160460472,
0.02260981872677803,
-0.0420... | -0.017346 |
[[search-uri-request]] == URI Search A search request can be executed purely using a URI by providing request parameters. Not all search options are exposed when executing a search using this mode, but it can be handy for quick "curl tests". Here is an example: [source,js] ----------------------------------------------... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/uri-request.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.06645991653203964,
0.10758204013109207,
-0.04158025607466698,
0.04451233893632889,
-0.011153732426464558,
-0.04776106774806976,
-0.032885316759347916,
-0.01751822978258133,
0.04066813364624977,
-0.08332082629203796,
-0.0063276332803070545,
-0.023749494925141335,
0.027799295261502266,
-0... | 0.06171 |
be `dfs\_query\_then\_fetch` or `query\_then\_fetch`. Defaults to `query\_then\_fetch`. See <> for more details on the different types of search that can be performed. |======================================================================= | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/uri-request.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.01872641034424305,
-0.027929779142141342,
-0.013542743399739265,
0.03012215718626976,
-0.0043313284404575825,
-0.08625778555870056,
0.004276568535715342,
0.014006099663674831,
-0.0007521588704548776,
0.005646844860166311,
0.019887249916791916,
0.010190472938120365,
0.026639726012945175,
... | -0.002097 |
[[search-profile]] == Profile API WARNING: The Profile API is a debugging tool and adds significant overhead to search execution. The Profile API provides detailed timing information about the execution of individual components in a search request. It gives the user insight into how search requests are executed at a lo... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/profile.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.008358628489077091,
0.08890469372272491,
-0.009969575330615044,
0.09259921312332153,
0.06628351658582687,
-0.042144324630498886,
-0.0002938191464636475,
0.03232184424996376,
0.02806786820292473,
-0.05957183614373207,
-0.01561996340751648,
-0.044073686003685,
0.075731061398983,
-0.001424... | 0.019844 |
cover one or more indices, the top level element in the profile response is an array of `shard` objects. Each shard object lists it's `id` which uniquely identifies the shard. The ID's format is `[nodeID][indexName][shardID]`. The profile itself may consist of one or more "searches", where a search is a query executed ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/profile.asciidoc | 6.2 | elasticsearch-6-2 | [
0.012546803802251816,
-0.0020293365232646465,
-0.034601226449012756,
0.09005223959684372,
0.014651279896497726,
0.004870615433901548,
-0.0042947339825332165,
0.02181893400847912,
0.004581746645271778,
-0.06844460219144821,
-0.05592414736747742,
-0.02148742415010929,
0.06575019657611847,
-0... | 0.099052 |
The `time\_in\_nanos` field shows that this query took ~1.8ms for the entire BooleanQuery to execute. The recorded time is inclusive of all children. The `breakdown` field will give detailed stats about how the time was spent, we'll look at that in a moment. Finally, the `children` array lists any sub-queries that may ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/profile.asciidoc | 6.2 | elasticsearch-6-2 | [
0.024945147335529327,
-0.0009551470284350216,
-0.029297571629285812,
0.12040896713733673,
0.056777648627758026,
-0.07320872694253922,
0.02036304399371147,
-0.0176114272326231,
0.0818682387471199,
0.007568982429802418,
-0.01404785830527544,
-0.047599636018276215,
-0.021194150671362877,
-0.0... | 0.071458 |
in a boolean) are typical consumers of `advance` `matches`:: Some queries, such as phrase queries, match documents using a "Two Phase" process. First, the document is "approximately" matched, and if it matches approximately, it is checked a second time with a more rigorous (and expensive) process. The second phase veri... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/profile.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.034823402762413025,
0.03994686156511307,
-0.0014746725792065263,
0.04865693300962448,
0.06433811038732529,
-0.016288496553897858,
0.03244518116116524,
-0.012107644230127335,
0.1681889444589615,
0.054462891072034836,
0.022698555141687393,
-0.06938344240188599,
0.10529002547264099,
-0.046... | 0.146308 |
seen when combinations of search, aggregations, global aggs and post\_filters are combined in a single search. `search\_timeout`:: A collector that halts execution after a specified period of time. This is seen when a `timeout` top-level parameter has been specified. `aggregation`:: A collector that Elasticsearch uses ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/profile.asciidoc | 6.2 | elasticsearch-6-2 | [
0.006308343727141619,
0.026404786854982376,
0.027309274300932884,
0.08815021067857742,
0.025435589253902435,
-0.023458847776055336,
-0.04878159239888191,
-0.014328421093523502,
0.0797605887055397,
-0.012481769546866417,
-0.04415154457092285,
-0.0013248699251562357,
-0.020047472789883614,
-... | 0.158512 |
the query are represented: 1. The first `TermQuery` (user:test) represents the main `term` query 2. The second `TermQuery` (message:some) represents the `post\_filter` query The Collector tree is fairly straightforward, showing how a single CancellableCollector wraps a MultiCollector which also wraps a FilteredCollecto... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/profile.asciidoc | 6.2 | elasticsearch-6-2 | [
0.030552750453352928,
0.00842057354748249,
-0.013279791921377182,
0.06320004910230637,
-0.04177768900990486,
0.008606821298599243,
0.059570152312517166,
-0.04589574784040451,
0.01611175388097763,
-0.02057652547955513,
-0.06062852963805199,
-0.10487021505832672,
0.03647885099053383,
-0.0714... | 0.094739 |
TESTRESPONSE[s/\.\.\.//] // TESTRESPONSE[s/(?<=[" ])\d+(\.\d+)?/$body.$\_path/] // TESTRESPONSE[s/"id": "\[P6-vulHtQRWuD4YnubWb7A\]\[test\]\[0\]"/"id": $body.profile.shards.0.id/] From the profile structure we can see that the `my\_scoped\_agg` is internally being run as a `LongTermsAggregator` (because the field it is... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/profile.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.03925720974802971,
0.016497936099767685,
0.043388482183218,
0.09052757173776627,
0.03337234631180763,
-0.030451901257038116,
0.022042350843548775,
0.004409493412822485,
0.11479238420724869,
-0.013797388412058353,
0.02351708896458149,
-0.04714052751660347,
-0.010620773769915104,
0.018225... | 0.02612 |
you find obviously wrong numbers, strange query structures or other bugs, please report them! | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/profile.asciidoc | 6.2 | elasticsearch-6-2 | [
0.008072896860539913,
-0.016777565702795982,
-0.0189801175147295,
0.05406387522816658,
-0.0834919735789299,
-0.00472819060087204,
-0.027992552146315575,
-0.007036272902041674,
-0.0019538733176887035,
0.007574888411909342,
0.03264335170388222,
-0.059039484709501266,
0.06193101778626442,
-0.... | 0.058277 |
[[search-rank-eval]] == Ranking Evaluation API experimental["The ranking evaluation API is experimental and may be changed or removed completely in a future release, as well as change in non-backwards compatible ways on minor versions updates. Elastic will take a best effort approach to fix any issues, but experimental... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/rank-eval.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.03631611540913582,
0.03624378889799118,
-0.03735411539673805,
0.05568678304553032,
0.03612878918647766,
-0.000032651634683134034,
0.03397156298160553,
0.05092537775635719,
0.011398867703974247,
0.0013347917702049017,
-0.04556511342525482,
0.01003349106758833,
0.0709424540400505,
0.00850... | 0.104111 |
"doc1", "rating": 0 }, { "\_index": "my\_index", "\_id": "doc2", "rating": 3}, { "\_index": "my\_index", "\_id": "doc3", "rating": 1 } ] }, { "id": "berlin\_query", "request": { "query": { "match": { "text": "berlin" }} }, "ratings": [ { "\_index": "my\_index", "\_id": "doc1", "rating": 1 } ] } ] ----------------------... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/rank-eval.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.03550811856985092,
0.14460095763206482,
-0.020441392436623573,
0.09510235488414764,
0.008237685076892376,
0.09213332831859589,
0.040223944932222366,
0.05315250903367996,
0.04292887821793556,
-0.014483419246971607,
-0.02234615758061409,
-0.060647424310445786,
0.0703500434756279,
0.004081... | 0.076196 |
/twitter/\_rank\_eval { "requests": [ { "id": "JFK query", "request": { "query": { "match\_all": {}}}, "ratings": [] }], "metric": { "precision": { "k" : 20, "relevant\_rating\_threshold": 1, "ignore\_unlabeled": false } } } -------------------------------- // CONSOLE // TEST[setup:twitter] The `precision` metric takes... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/rank-eval.asciidoc | 6.2 | elasticsearch-6-2 | [
0.002754698507487774,
0.03012268804013729,
-0.05794487148523331,
0.0534457266330719,
-0.05104446783661842,
0.013241218402981758,
0.02544434554874897,
0.039356838911771774,
0.006075053010135889,
-0.0020819439087063074,
-0.03587694093585014,
-0.0684080421924591,
0.03791826218366623,
0.004089... | -0.029618 |
"relevant\_docs\_retrieved": 6, "docs\_retrieved": 10 } }, "my\_query\_id2" : { [...] } }, "failures": { [...] } } } -------------------------------- // NOTCONSOLE <1> the overall evaluation quality calculated by the defined metric <2> the `details` section contains one entry for every query in the original `requests` ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/rank-eval.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.08199232816696167,
0.0765090137720108,
-0.05111721530556679,
0.11049934476613998,
0.02418408915400505,
0.008850431069731712,
0.03760984167456627,
0.06229439750313759,
0.03343527391552925,
-0.020717894658446312,
-0.01505668368190527,
-0.06435512751340866,
0.14190274477005005,
-0.04146944... | 0.104157 |
[[search-explain]] == Explain API The explain api computes a score explanation for a query and a specific document. This can give useful feedback whether a document matches or didn't match a specific query. The `index` and `type` parameters expect a single index and a single type respectively. [float] === Usage Full qu... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/explain.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.0771942287683487,
0.11498221755027771,
0.007714399602264166,
0.12596659362316132,
0.07628674805164337,
-0.020350882783532143,
0.05144147574901581,
0.025286216288805008,
0.08988915383815765,
-0.05948454886674881,
-0.046612612903118134,
-0.07868688553571701,
0.038760002702474594,
-0.02587... | 0.074458 |
[[search-template]] == Search Template The `/\_search/template` endpoint allows to use the mustache language to pre render search requests, before they are executed and fill existing templates with template parameters. [source,js] ------------------------------------------ GET \_search/template { "source" : { "query": ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/search-template.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.01795561984181404,
0.1566663235425949,
0.044475436210632324,
0.08739203959703445,
0.01059146411716938,
0.06463109701871872,
0.015666194260120392,
0.04242096468806267,
0.08070597797632217,
-0.07023945450782776,
-0.03920111432671547,
-0.008992671966552734,
-0.010367271490395069,
-0.012269... | 0.039405 |
------------------------------------------ { "range": { "line\_no": { "gte": "10", "lte": "15" } } } ------------------------------------------ // NOTCONSOLE But when `params` is `{ "start": 10 }` this query would use the default value for `end`: [source,js] ------------------------------------------ { "range": { "line... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/search-template.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.054528649896383286,
0.049283117055892944,
-0.0021756694186478853,
0.049310073256492615,
-0.06419704109430313,
0.05308999493718147,
-0.025009356439113617,
0.07227130979299545,
0.021278157830238342,
-0.07965640723705292,
-0.00016567157581448555,
-0.06122265383601189,
-0.02439045161008835,
... | 0.01292 |
////////////////////////// We want to be sure that the template has been created, because we'll use it later. [source,js] -------------------------------------------------- { "acknowledged" : true } -------------------------------------------------- // TESTRESPONSE ////////////////////////// To use a stored template at... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/search-template.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.10902589559555054,
0.09202729910612106,
-0.021973052993416786,
0.10401393473148346,
0.0175999253988266,
0.058498356491327286,
0.009434451349079609,
0.01612362451851368,
0.038437310606241226,
-0.061522226780653,
-0.01387761626392603,
-0.0372612401843071,
-0.04788735881447792,
-0.07400318... | 0.060854 |
[[search-request-body]] == Request Body Search The search request can be executed with a search DSL, which includes the <>, within its body. Here is an example: [source,js] -------------------------------------------------- GET /twitter/\_search { "query" : { "term" : { "user" : "kimchy" } } } -------------------------... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/request-body.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.0653342753648758,
0.09545797109603882,
-0.024025022983551025,
0.052944593131542206,
0.010300260968506336,
-0.0647454634308815,
0.0029423933010548353,
-0.004168674349784851,
0.052596744149923325,
-0.06987268477678299,
-0.02373773790895939,
-0.010109508410096169,
0.030478080734610558,
-0.... | 0.036765 |
`terminated\_early` flag will be set to `true` in the response. [source,js] -------------------------------------------------- { "took": 3, "timed\_out": false, "terminated\_early": true, "\_shards": { "total": 1, "successful": 1, "skipped" : 0, "failed": 0 }, "hits": { "total": 1, "max\_score": 0.0, "hits": [] } } ---... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/request-body.asciidoc | 6.2 | elasticsearch-6-2 | [
0.009675096720457077,
0.07173731178045273,
0.008027383126318455,
0.061870213598012924,
0.05466241016983986,
-0.09566450864076614,
-0.04151954874396324,
-0.016937479376792908,
0.11110756546258926,
0.01601705700159073,
-0.003065418219193816,
-0.04053319990634918,
-0.04503001645207405,
-0.014... | 0.029022 |
[[search-suggesters]] == Suggesters The suggest feature suggests similar looking terms based on a provided text by using a suggester. Parts of the suggest feature are still under development. The suggest request part is defined alongside the query part in a `\_search` request. NOTE: `\_suggest` endpoint has been deprec... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/suggesters.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.07135817408561707,
0.058578863739967346,
0.06693276017904282,
0.03319800645112991,
0.07554058730602264,
-0.0016427449882030487,
0.031381864100694656,
0.04911404475569725,
0.05745422840118408,
-0.04180537536740303,
-0.025410812348127365,
-0.041676685214042664,
0.019523657858371735,
0.021... | 0.111765 |
[[search-field-caps]] == Field Capabilities API The field capabilities API allows to retrieve the capabilities of fields among multiple indices. The field capabilities api by default executes on all indices: [source,js] -------------------------------------------------- GET \_field\_caps?fields=rating -----------------... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/field-caps.asciidoc | 6.2 | elasticsearch-6-2 | [
0.004564153030514717,
0.05592598766088486,
-0.0764610543847084,
0.06423713266849518,
0.03797278180718422,
0.023674294352531433,
0.04009411111474037,
-0.0019355426775291562,
0.014790649525821209,
-0.09001082926988602,
-0.0065052686259150505,
-0.08129078894853592,
0.018994787707924843,
0.023... | 0.028538 |
[[search-shards]] == Search Shards API The search shards api returns the indices and shards that a search request would be executed against. This can give useful feedback for working out issues or planning optimizations with routing and shard preferences. When filtered aliases are used, the filter is returned as part o... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/search-shards.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.007210283540189266,
0.08004964143037796,
0.04856809601187706,
0.04275219142436981,
0.056050755083560944,
-0.03269724175333977,
0.023271627724170685,
-0.037352681159973145,
0.09377378970384598,
-0.04762939736247063,
-0.034884966909885406,
-0.028297867625951767,
0.00772048206999898,
-0.02... | 0.066905 |
[[search-suggesters-phrase]] === Phrase Suggester NOTE: In order to understand the format of suggestions, please read the <> page first. The `term` suggester provides a very convenient API to access word alternatives on a per token basis within a certain string distance. The API allows accessing each token in the strea... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/suggesters/phrase-suggest.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.12118826061487198,
-0.02648271434009075,
0.0649532899260521,
0.023744599893689156,
0.0542992539703846,
0.01796516589820385,
0.06586594879627228,
0.04279734566807747,
0.043396688997745514,
-0.031244460493326187,
-0.017930809408426285,
-0.06260683387517929,
0.043934911489486694,
0.0140326... | 0.131303 |
suggest candidates. Only candidates that score higher than the threshold will be included in the result. For instance a confidence level of `1.0` will only return suggestions that score higher than the input phrase. If set to `0.0` the top N candidates are returned. The default is `1.0`. `max\_errors`:: the maximum per... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/suggesters/phrase-suggest.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.006254531908780336,
-0.027313271537423134,
-0.02305925264954567,
0.015210386365652084,
0.018588818609714508,
0.03360004350543022,
0.033418137580156326,
0.11432106792926788,
-0.00760994665324688,
0.002866556867957115,
-0.025567498058080673,
-0.04972164332866669,
0.04716305062174797,
-0.0... | 0.114084 |
The `{{suggestion}}` variable will be replaced by the text of each suggestion. <3> An additional `field\_name` variable has been specified in `params` and is used by the `match` query. <4> All suggestions will be returned with an extra `collate\_match` option indicating whether the generated phrase matched any document... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/suggesters/phrase-suggest.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.1217280924320221,
-0.0753038227558136,
0.04999230057001114,
0.0702415332198143,
0.013398010283708572,
0.03530561923980713,
0.02132999897003174,
0.049860429018735886,
0.013788641430437565,
-0.03415558487176895,
0.04862827807664871,
0.033957310020923615,
0.048092424869537354,
-0.099712923... | 0.081472 |
text term must have in order to be included. Defaults to 4. (Old name "min\_word\_len" is deprecated) `max\_inspections`:: A factor that is used to multiply with the `shards\_size` in order to inspect more candidate spell corrections on the shard level. Can improve accuracy at the cost of performance. Defaults to 5. `m... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/suggesters/phrase-suggest.asciidoc | 6.2 | elasticsearch-6-2 | [
0.03542954474687576,
-0.022458333522081375,
0.01020977646112442,
-0.009217789396643639,
-0.026133986189961433,
0.020774953067302704,
-0.014538261108100414,
0.07281731814146042,
0.052622370421886444,
0.016537534072995186,
-0.008549015037715435,
-0.012584047392010689,
0.06469838321208954,
0.... | 0.071928 |
[[returning-suggesters-type]] === Returning the type of the suggester Sometimes you need to know the exact type of a suggester in order to parse its results. The `typed\_keys` parameter can be used to change the suggester's name in the response so that it will be prefixed by its type. Considering the following example ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/suggesters/misc.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.05891750380396843,
0.02768930234014988,
0.08743705600500107,
0.07214133441448212,
0.010754480957984924,
-0.01377423107624054,
0.04074142500758171,
0.026319632306694984,
0.07742421329021454,
-0.0648965984582901,
-0.006409152876585722,
-0.04310835525393486,
0.005091703496873379,
0.0114306... | 0.015826 |
[[suggester-context]] === Context Suggester The completion suggester considers all documents in the index, but it is often desirable to serve suggestions filtered and/or boosted by some criteria. For example, you want to suggest song titles filtered by certain artists or you want to boost song titles based on their gen... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/suggesters/context-suggest.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.07274439185857773,
0.018266549333930016,
0.058580104261636734,
0.029737967997789383,
0.06238536164164543,
0.015435595996677876,
0.05893778055906296,
-0.001727607916109264,
0.020593104884028435,
-0.07853470742702484,
-0.05600105971097946,
-0.026815097779035568,
0.013532483018934727,
0.04... | 0.088948 |
documents are considered. Querying with no categories on a category enabled completion field should be avoided, as it will degrade search performance. Suggestions with certain categories can be boosted higher than others. The following filters suggestions by categories and additionally boosts suggestions associated wit... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/suggesters/context-suggest.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.03178216516971588,
0.06033671647310257,
0.05959482491016388,
0.09315717220306396,
0.032599370926618576,
0.03694941848516464,
-0.011471635662019253,
0.00856873020529747,
0.04279661551117897,
-0.1057434156537056,
-0.048221487551927567,
0.012180861085653305,
-0.018479270860552788,
0.001227... | 0.019041 |
be considered. Suggestions that are within an area represented by a geohash can also be boosted higher than others, as shown by the following: [source,js] -------------------------------------------------- POST place/\_search?pretty { "suggest": { "place\_suggestion" : { "prefix" : "tim", "completion" : { "field" : "su... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/suggesters/context-suggest.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.022941436618566513,
0.019322210922837257,
0.06479419767856598,
-0.008920895867049694,
0.05403175577521324,
0.002085006097331643,
0.027183616533875465,
-0.006015014834702015,
0.01410665176808834,
-0.0684317797422409,
-0.05616080388426781,
0.005968931596726179,
0.049734871834516525,
0.004... | 0.033491 |
[[search-suggesters-term]] === Term suggester NOTE: In order to understand the format of suggestions, please read the <> page first. The `term` suggester suggests terms based on edit distance. The provided suggest text is analyzed before terms are suggested. The suggested terms are provided per analyzed suggest text to... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/suggesters/term-suggest.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.019405722618103027,
0.03235705569386482,
-0.026167282834649086,
0.02618822082877159,
0.03239143639802933,
0.03274812176823616,
0.04060487821698189,
0.08595047891139984,
-0.014617592096328735,
0.001768929767422378,
0.009458400309085846,
-0.05992976203560829,
0.07713951170444489,
0.006285... | 0.057907 |
and is not enabled. If a value higher than 1 is specified then the number cannot be fractional. The shard level document frequencies are used for this option. `max\_term\_freq`:: The maximum threshold in number of documents a suggest text token can exist in order to be included. Can be a relative percentage number (e.g... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/suggesters/term-suggest.asciidoc | 6.2 | elasticsearch-6-2 | [
0.031278789043426514,
-0.03927381709218025,
-0.05455334484577179,
-0.06548584997653961,
-0.044443726539611816,
0.013039846904575825,
-0.017046794295310974,
0.029308514669537544,
0.0371534526348114,
-0.023488899692893028,
-0.015469393692910671,
0.01425210852175951,
0.036261484026908875,
-0.... | 0.061958 |
[[search-suggesters-completion]] === Completion Suggester NOTE: In order to understand the format of suggestions, please read the <> page first. The `completion` suggester provides auto-complete/search-as-you-type functionality. This is a navigational feature to guide users to relevant results as they are typing, impro... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/suggesters/completion-suggest.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.08628790080547333,
-0.017435606569051743,
0.06049566715955734,
0.03190295770764351,
0.009644867852330208,
-0.0022423435002565384,
0.07470782101154327,
-0.00658355001360178,
0.03889615088701248,
-0.06285912543535233,
-0.028129318729043007,
0.05071244388818741,
-0.006183498539030552,
-0.0... | 0.110265 |
following shorthand form. Note that you can not specify a weight with suggestion(s) in the shorthand form. [source,js] -------------------------------------------------- PUT music/\_doc/1?refresh { "suggest" : [ "Nevermind", "Nirvana" ] } -------------------------------------------------- // CONSOLE // TEST[continued] ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/suggesters/completion-suggest.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.09592226147651672,
-0.01385260745882988,
0.04476979374885559,
0.11918363720178604,
0.04342779889702797,
0.0522998683154583,
0.09498347342014313,
0.00389780942350626,
0.07954017072916031,
-0.0813920646905899,
-0.03125612437725067,
-0.014471331611275673,
0.042904987931251526,
-0.059169497... | 0.055674 |
a single shard is more performant due to the document fetch overhead when the suggest spans multiple shards. To get best performance for completions, it is recommended to index completions into a single shard index. In case of high heap usage due to shard size, it is still recommended to break index into multiple shard... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/suggesters/completion-suggest.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.03265586867928505,
-0.020453687757253647,
0.09617099165916443,
0.02312150038778782,
0.022149045020341873,
0.007386248558759689,
-0.019720803946256638,
-0.036068204790353775,
0.11299343407154083,
-0.07447788864374161,
-0.01706552505493164,
0.04845252260565758,
0.04160785675048828,
-0.037... | -0.014235 |
[[search-request-sort]] === Sort Allows to add one or more sort on specific fields. Each sort can be reversed as well. The sort is defined on a per field level, with special field name for `\_score` to sort by score, and `\_doc` to sort by index order. Assuming the following index mapping: [source,js] -----------------... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/request/sort.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.005601842422038317,
0.08339439332485199,
0.07242512702941895,
0.06543583422899246,
-0.029056645929813385,
0.0762714073061943,
-0.047056980431079865,
0.043098028749227524,
0.04957154765725136,
0.028488365933299065,
-0.0403251126408577,
0.05280167981982231,
0.015875304117798805,
0.0231197... | -0.021827 |
favor of the options documented above. ============================================ ===== Nested sorting examples In the below example `offer` is a field of type `nested`. The nested `path` needs to be specified; otherwise, Elasticsearch doesn't know on what nested level sort values need to be captured. [source,js] ---... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/request/sort.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.0006026285700500011,
0.0803600624203682,
0.06745690107345581,
0.0694238543510437,
0.005471701733767986,
0.03696078807115555,
-0.05268356576561928,
0.023097485303878784,
0.07809454202651978,
0.01456126756966114,
-0.04840250313282013,
0.007148078177124262,
-0.02673744596540928,
0.03485972... | -0.035671 |
geo points. By default, the shortest distance is taken into account when sorting in ascending order and the longest distance when sorting in descending order. Supported values are `min`, `max`, `median` and `avg`. `unit`:: The unit to use when computing sort values. The default is `m` (meters). NOTE: geo distance sorti... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/request/sort.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.04494126886129379,
-0.004065839573740959,
0.007408574689179659,
0.004347173031419516,
-0.004184602294117212,
0.02306491509079933,
-0.028668692335486412,
0.03948187828063965,
0.10592612624168396,
-0.05765453726053238,
0.027366729453206062,
0.07697958499193192,
-0.015884924679994583,
0.02... | 0.058411 |
sorted on should not be analyzed / tokenized. For numeric types, if possible, it is recommended to explicitly set the type to narrower types (like `short`, `integer` and `float`). | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/request/sort.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.0010403681080788374,
0.009418259374797344,
0.038490790873765945,
-0.001777532510459423,
-0.019259104505181313,
-0.0138609753921628,
-0.01261479314416647,
0.02439868077635765,
-0.008947822265326977,
0.005086270626634359,
0.009167619049549103,
0.07653262466192245,
-0.02540736272931099,
0.... | -0.016493 |
[[search-request-from-size]] === From / Size Pagination of results can be done by using the `from` and `size` parameters. The `from` parameter defines the offset from the first result you want to fetch. The `size` parameter allows you to configure the maximum amount of hits to be returned. Though `from` and `size` can ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/request/from-size.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.013873985968530178,
0.0642157793045044,
-0.02330184355378151,
0.019256245344877243,
-0.06487568467855453,
0.05839571729302406,
-0.021010739728808403,
0.017324356362223625,
0.018100569024682045,
-0.03234749659895897,
-0.01167039480060339,
-0.01738657057285309,
0.019330330193042755,
-0.06... | 0.007794 |
[[search-request-docvalue-fields]] === Doc value Fields Allows to return the <> representation of a field for each hit, for example: [source,js] -------------------------------------------------- GET /\_search { "query" : { "match\_all": {} }, "docvalue\_fields" : ["test1", "test2"] } ----------------------------------... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/request/docvalue-fields.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.0006422945880331099,
0.12165747582912445,
-0.0010197445517405868,
0.09264952689409256,
0.024864133447408676,
-0.010797843337059021,
0.00445889588445425,
0.053713761270046234,
0.10746924579143524,
-0.01447116769850254,
-0.06851570308208466,
0.01204640232026577,
-0.020843645557761192,
-0.... | 0.021153 |
[[search-request-index-boost]] === Index Boost Allows to configure different boost level per index when searching across more than one indices. This is very handy when hits coming from one index matter more than hits coming from another index (think social graph where each user has an index). deprecated[5.2.0, This for... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/request/index-boost.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.03723178431391716,
0.06630634516477585,
-0.006721532437950373,
0.10225225985050201,
0.04155314341187477,
0.014310149475932121,
0.0007019708282314241,
-0.025040291249752045,
-0.006186820100992918,
-0.057369787245988846,
-0.0443987138569355,
-0.04641428589820862,
-0.006921892520040274,
-0... | 0.020905 |
[[search-request-stored-fields]] === Fields WARNING: The `stored\_fields` parameter is about fields that are explicitly marked as stored in the mapping, which is off by default and generally not recommended. Use <> instead to select subsets of the original source document to be returned. Allows to selectively load spec... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/request/stored-fields.asciidoc | 6.2 | elasticsearch-6-2 | [
0.008224481716752052,
0.08834788203239441,
0.0157149825245142,
0.11013400554656982,
-0.006042733322829008,
0.01804562658071518,
-0.026189757511019707,
0.056243445724248886,
0.0501323826611042,
-0.04594956338405609,
-0.017600899562239647,
-0.04700080677866936,
0.002593353856354952,
-0.08036... | -0.007925 |
[[search-request-script-fields]] === Script Fields Allows to return a <> (based on different fields) for each hit, for example: [source,js] -------------------------------------------------- GET /\_search { "query" : { "match\_all": {} }, "script\_fields" : { "test1" : { "script" : { "lang": "painless", "source": "doc[... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/request/script-fields.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.020487423986196518,
0.09062133729457855,
0.025166694074869156,
0.0678807869553566,
0.020534619688987732,
0.045551616698503494,
0.016603028401732445,
0.06515826284885406,
0.06021123751997948,
-0.05459007993340492,
-0.03492436930537224,
-0.0380701944231987,
0.018129875883460045,
-0.042456... | 0.006472 |
[[search-request-inner-hits]] === Inner hits The <> and <> features allow the return of documents that have matches in a different scope. In the parent/child case, parent documents are returned based on matches in child documents or child documents are returned based on matches in parent documents. In the nested case, ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/request/inner-hits.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.11398366093635559,
0.10159534960985184,
0.06522104144096375,
0.10247170925140381,
0.08654838800430298,
-0.049965307116508484,
-0.042808543890714645,
-0.008165153674781322,
0.09409860521554947,
-0.04815222695469856,
-0.03396821394562721,
-0.024074608460068703,
0.018773958086967468,
-0.04... | 0.091124 |
{ "total": 1, "max\_score": 1.0, "hits": [ { "\_index": "test", "\_type": "\_doc", "\_id": "1", "\_nested": { "field": "comments", "offset": 1 }, "\_score": 1.0, "\_source": { "author": "nik9000", "number": 2 } } ] } } } } ] } } -------------------------------------------------- // TESTRESPONSE[s/"\_source": \.\.\./"\_... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/request/inner-hits.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.013872439973056316,
0.07211139053106308,
0.014803467318415642,
0.10162416100502014,
0.030288532376289368,
0.004766963422298431,
0.027223173528909683,
0.01569186896085739,
0.08517182618379593,
0.03741936385631561,
-0.008812420070171356,
-0.08210904151201248,
0.044294971972703934,
0.01434... | 0.032101 |
mapping has multiple levels of hierarchical nested object fields each level can be accessed via dot notated path. For example if there is a `comments` nested field that contains a `votes` nested field and votes should directly be returned with the root hits then the following path can be defined: [source,js] ----------... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/request/inner-hits.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.03345222398638725,
0.006561518181115389,
0.08810529112815857,
0.09409983456134796,
0.004984868690371513,
-0.006448585540056229,
-0.0917569100856781,
0.028818318620324135,
0.08805127441883087,
0.020023398101329803,
-0.039087582379579544,
0.03579384461045265,
0.026032406836748123,
0.04450... | 0.006066 |
[[search-request-scroll]] === Scroll While a `search` request returns a single ``page'' of results, the `scroll` API can be used to retrieve large numbers of results (or even all results) from a single search request, in much the same way as you would use a cursor on a traditional database. Scrolling is not intended fo... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/request/scroll.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.07813703268766403,
0.05155516788363457,
-0.049810368567705154,
0.04376072436571121,
-0.04094589501619339,
-0.008475277572870255,
-0.0014163358137011528,
0.003044800367206335,
-0.007993847131729126,
0.007349343039095402,
-0.03303280100226402,
0.06876642256975174,
0.10265547782182693,
-0.... | 0.062314 |
segments, at which time the smaller segments are deleted. This process continues during scrolling, but an open search context prevents the old segments from being deleted while they are still in use. This is how Elasticsearch is able to return the results of the initial search request, regardless of subsequent changes ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/request/scroll.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.02516254223883152,
0.08998695015907288,
0.02882780320942402,
0.07654023915529251,
0.10737034678459167,
-0.017775295302271843,
-0.07600781321525574,
-0.030409183353185654,
0.13300848007202148,
0.026185300201177597,
-0.047809869050979614,
0.11212863028049469,
-0.007400999311357737,
-0.087... | 0.068631 |
to avoid the memory explosion. To avoid this cost entirely it is possible to use the `doc\_values` of another field to do the slicing but the user must ensure that the field has the following properties: \* The field is numeric. \* `doc\_values` are enabled on that field \* Every document should contain a single value.... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/request/scroll.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.0827735885977745,
0.11239781230688095,
0.0032864147797226906,
0.0858025774359703,
0.017213022336363792,
0.015062971971929073,
-0.01313014980405569,
0.04853704199194908,
0.13087162375450134,
-0.0029899151995778084,
-0.04613782837986946,
0.04357654228806496,
-0.031091617420315742,
-0.0134... | 0.067361 |
[[search-request-post-filter]] === Post filter The `post\_filter` is applied to the search `hits` at the very end of a search request, after aggregations have already been calculated. Its purpose is best explained by example: Imagine that you are selling shirts that have the following properties: [source,js] ----------... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/request/post-filter.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.06654069572687149,
0.0691138356924057,
0.07408031821250916,
0.13093094527721405,
-0.02730555087327957,
0.05638180300593376,
-0.03234589099884033,
0.01496952772140503,
0.09195327758789062,
-0.03681456670165062,
-0.008684960193932056,
-0.0007984419353306293,
0.04456455260515213,
-0.046295... | 0.032966 |
[[search-request-named-queries-and-filters]] === Named Queries Each filter and query can accept a `\_name` in its top level definition. [source,js] -------------------------------------------------- GET /\_search { "query": { "bool" : { "should" : [ {"match" : { "name.first" : {"query" : "shay", "\_name" : "first"} }},... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/request/named-queries-and-filters.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.07292778044939041,
0.09555531293153763,
0.04574645310640335,
0.0093343835324049,
-0.01188899576663971,
0.00645225727930665,
0.01681610941886902,
-0.02435792237520218,
0.044869277626276016,
-0.051832087337970734,
-0.03993009775876999,
-0.0805206447839737,
-0.011792288161814213,
0.0190093... | 0.074689 |
[[search-request-source-filtering]] === Source filtering Allows to control how the `\_source` field is returned with every hit. By default operations return the contents of the `\_source` field unless you have used the `stored\_fields` parameter or if the `\_source` field is disabled. You can turn off `\_source` retrie... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/request/source-filtering.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.031898435205221176,
0.07895918190479279,
-0.01219596341252327,
0.09842327982187271,
0.031076131388545036,
0.011449828743934631,
0.06693440675735474,
-0.04554735869169235,
0.09280559420585632,
-0.06324067711830139,
-0.021579857915639877,
-0.03647491708397865,
-0.0287700816988945,
-0.0736... | 0.036835 |
[[search-request-highlighting]] === Highlighting Highlighters enable you to get highlighted snippets from one or more fields in your search results so you can show users where the query matches are. When you request highlights, the response contains an additional `highlight` element for each search hit that includes th... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/request/highlighting.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.06365688145160675,
0.049482688307762146,
0.05125917121767998,
0.07096248120069504,
0.07680515944957733,
0.04347281530499458,
0.05638429895043373,
-0.042736250907182693,
0.03124029003083706,
-0.0608774796128273,
-0.06389278918504715,
-0.04094863310456276,
0.045888740569353104,
-0.0690359... | 0.01616 |
limiting the collection to the highlighted documents. This is important if you have large fields because it doesn't require reanalyzing the text to be highlighted. It also requires less disk space than using `term\_vectors`. \* Term vectors. If `term\_vector` information is provided by setting `term\_vector` to `with\_... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/search/request/highlighting.asciidoc | 6.2 | elasticsearch-6-2 | [
0.029431099072098732,
0.012402432039380074,
-0.012342680245637894,
0.002982610370963812,
0.06696336716413498,
0.01396661065518856,
-0.06608780473470688,
0.02834324724972248,
0.02750234678387642,
-0.032387081533670425,
-0.03264579921960831,
0.008729912340641022,
-0.022914333269000053,
-0.04... | 0.099038 |
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.