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 |
|---|---|---|---|---|---|
that we want to run. The `match\_all` query is simply a search for all documents in the specified index. In addition to the `query` parameter, we also can pass other parameters to influence the search results. In the example in the section above we passed in `sort`, here we pass in `size`: [source,js] -----------------... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/getting-started.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.04245537891983986,
0.08350396901369095,
-0.002255119616165757,
0.06914176791906357,
0.018134932965040207,
0.04308466985821724,
0.02341405488550663,
0.049479275941848755,
0.027797339484095573,
-0.04282099008560181,
-0.012649742886424065,
0.010522931814193726,
-0.017668215557932854,
-0.04... | 0.042553 |
"match\_phrase": { "address": "mill lane" } } } -------------------------------------------------- // CONSOLE // TEST[continued] Let's now introduce the {ref}/query-dsl-bool-query.html[`bool` query]. The `bool` query allows us to compose smaller queries into bigger queries using boolean logic. This example composes two... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/getting-started.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.07125113904476166,
0.08006254583597183,
0.014591934159398079,
0.08253113925457001,
-0.019021183252334595,
-0.02111293189227581,
0.0684877336025238,
-0.07633000612258911,
0.108076311647892,
-0.10550642758607864,
-0.03620389476418495,
-0.06323515623807907,
0.012727821245789528,
-0.0032270... | 0.032199 |
balance that is greater than or equal to 20000 and less than or equal to 30000. [source,js] -------------------------------------------------- GET /bank/\_search { "query": { "bool": { "must": { "match\_all": {} }, "filter": { "range": { "balance": { "gte": 20000, "lte": 30000 } } } } } } ------------------------------... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/getting-started.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.029456324875354767,
0.12304910272359848,
-0.03168300539255142,
0.040442224591970444,
-0.005680541042238474,
0.019044464454054832,
0.016670992597937584,
0.024965358898043633,
0.0631837472319603,
-0.06382135301828384,
-0.04029908403754234,
-0.08953609317541122,
0.03540303185582161,
-0.023... | 0.06231 |
only for the top 10 states sorted by count in descending order): [source,js] -------------------------------------------------- GET /bank/\_search { "size": 0, "aggs": { "group\_by\_state": { "terms": { "field": "state.keyword" }, "aggs": { "average\_balance": { "avg": { "field": "balance" } } } } } } -----------------... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/getting-started.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.06196032464504242,
0.0554920956492424,
0.0027481308206915855,
0.0698375329375267,
-0.008118527941405773,
0.012213409878313541,
0.01166494470089674,
0.03815903514623642,
0.03532281517982483,
-0.02706604078412056,
-0.03046160191297531,
0.0017657496500760317,
0.011988289654254913,
-0.01411... | 0.071098 |
[[api-conventions]] = API Conventions [partintro] -- The \*Elasticsearch\* REST APIs are exposed using <>. The conventions listed in this chapter can be applied throughout the REST API, unless otherwise specified. \* <> \* <> \* <> \* <> -- [[multi-index]] == Multiple Indices Most APIs that refer to an `index` paramete... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/api-conventions.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.001589591964147985,
0.038018740713596344,
-0.018731430172920227,
0.033742696046829224,
0.014094430953264236,
-0.00457826117053628,
-0.04634230583906174,
-0.043195534497499466,
0.032996032387018204,
-0.028565755113959312,
-0.015971172600984573,
-0.02077993005514145,
0.04434169456362724,
... | 0.150712 |
`%2F` `{`:: `%7B` `}`:: `%7D` `|`:: `%7C` `+`:: `%2B` `:`:: `%3A` `,`:: `%2C` ====================================================== The following example shows different forms of date math index names and the final index names they resolve to given the current time is 22nd March 2024 noon utc. [options="header"] |====... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/api-conventions.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.05068957805633545,
0.044032271951436996,
-0.01604430191218853,
0.0618436336517334,
-0.03838402032852173,
-0.022839471697807312,
-0.0023993265349417925,
0.014461779966950417,
0.036783039569854736,
0.039236150681972504,
-0.029443444684147835,
-0.05417283996939659,
-0.028193211182951927,
-... | 0.112528 |
match any field or part of a field's name: [source,sh] -------------------------------------------------- GET /\_cluster/state?filter\_path=metadata.indices.\*.stat\* -------------------------------------------------- // CONSOLE // TEST[s/^/PUT twitter\n/] Responds: [source,sh] -----------------------------------------... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/api-conventions.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.02927672304213047,
0.13321535289287567,
0.020014189183712006,
-0.0015033113304525614,
0.04079849645495415,
0.01092105358839035,
0.0332774892449379,
-0.00780944200232625,
0.07393605262041092,
-0.021706242114305496,
-0.024686379358172417,
-0.08179083466529846,
0.009021221660077572,
-0.047... | 0.139593 |
providing numbered parameters as `string` on top of supporting the native JSON number types. [[time-units]] [float] === Time units Whenever durations need to be specified, e.g. for a `timeout` parameter, the duration must specify the unit, like `2d` for 2 days. The supported units are: [horizontal] `d`:: days `h`:: hou... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/api-conventions.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.02925751358270645,
0.051534589380025864,
-0.08967699855566025,
0.0010318191489204764,
-0.1265602856874466,
-0.05334669351577759,
-0.00033762387465685606,
0.06995423138141632,
-0.03550386801362038,
-0.0555102713406086,
-0.026814157143235207,
-0.07320456206798553,
-0.012199454940855503,
0... | 0.108478 |
string: \"surprise\_me\"" } }, "status" : 400 } ---------------------------------------------------------------------- // TESTRESPONSE But if you set `error\_trace=true`: [source,js] ---------------------------------------------------------------------- POST /twitter/\_search?size=surprise\_me&error\_trace=true -------... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/api-conventions.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.03957435116171837,
0.09078910946846008,
0.004627165384590626,
0.0553937703371048,
0.0020741454791277647,
-0.02759232372045517,
0.09525035321712494,
0.06750795245170593,
-0.0042495871894061565,
-0.036268629133701324,
0.027250153943896294,
-0.05355583503842354,
0.022307008504867554,
-0.10... | 0.036902 |
[[indices]] = Indices APIs [partintro] -- The indices APIs are used to manage individual indices, index settings, aliases, mappings, and index templates. [float] [[index-management]] == Index management: \* <> \* <> \* <> \* <> \* <> \* <> \* <> \* <> [float] [[mapping-management]] == Mapping management: \* <> \* <> \*... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/indices.asciidoc | 6.2 | elasticsearch-6-2 | [
0.02635696716606617,
0.05592626333236694,
-0.048815857619047165,
0.09974648058414459,
0.01624825969338417,
-0.0423344261944294,
0.06852630525827408,
-0.026873402297496796,
-0.03924930840730667,
0.02516164630651474,
0.02257450856268406,
-0.0861596018075943,
-0.008140605874359608,
-0.0273654... | 0.211422 |
[[search-aggregations]] = Aggregations [partintro] -- The aggregations framework helps provide aggregated data based on a search query. It is based on simple building blocks called aggregations, that can be composed in order to build complex summaries of the data. An aggregation can be seen as a \_unit-of-work\_ that b... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/aggregations.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.05502333492040634,
0.051151033490896225,
0.022072521969676018,
0.06120997667312622,
0.026510054245591164,
-0.0038378573954105377,
-0.0066393157467246056,
0.04604416713118553,
0.0976615846157074,
-0.0372675321996212,
-0.05276503786444664,
0.0005344019737094641,
0.06356658786535263,
-0.05... | 0.182962 |
the average will be calculated). At the same level of the aggregation type definition, one can optionally define a set of additional aggregations, though this only makes sense if the aggregation you defined is of a bucketing nature. In this scenario, the sub-aggregations you define on the bucketing aggregation level wi... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/aggregations.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.07474823296070099,
0.006581161171197891,
0.008906455710530281,
0.0784221813082695,
-0.06610719114542007,
-0.012806900776922703,
-0.03062513843178749,
0.0779639482498169,
0.08398136496543884,
-0.01682606153190136,
-0.05756762996315956,
-0.02278812974691391,
0.06526532024145126,
-0.053155... | 0.042183 |
[[cat-allocation]] == cat allocation `allocation` provides a snapshot of how many shards are allocated to each data node and how much disk space they are using. [source,js] -------------------------------------------------- GET /\_cat/allocation?v -------------------------------------------------- // CONSOLE // TEST[s/... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/cat/allocation.asciidoc | 6.2 | elasticsearch-6-2 | [
0.02941957674920559,
0.05033641681075096,
-0.0317821241915226,
0.04877570644021034,
-0.022986851632595062,
-0.0884605199098587,
-0.016594955697655678,
0.010252906940877438,
0.06503796577453613,
0.02429920807480812,
-0.006244634743779898,
0.0029757912270724773,
0.02046949416399002,
-0.05817... | 0.09408 |
[[cat-thread-pool]] == cat thread pool The `thread\_pool` command shows cluster wide thread pool statistics per node. By default the active, queue and rejected statistics are returned for all thread pools. [source,js] -------------------------------------------------- GET /\_cat/thread\_pool ---------------------------... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/cat/thread_pool.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.021603912115097046,
-0.0013993962202221155,
-0.06706216931343079,
0.08333352208137512,
0.01093677431344986,
-0.06157601624727249,
0.07315776497125626,
-0.047148216515779495,
0.05747455731034279,
-0.018185226246714592,
0.010365298949182034,
-0.09458471834659576,
-0.0034772807266563177,
-... | 0.138713 |
transport port for the current node |======================================================================= | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/cat/thread_pool.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.035272859036922455,
0.00898042879998684,
-0.08624153584241867,
-0.016292279586195946,
-0.004484932404011488,
-0.04763653874397278,
-0.0036418091040104628,
0.025871286168694496,
-0.08595901727676392,
-0.021598489955067635,
0.03361070528626442,
-0.0014753430150449276,
-0.020546169951558113,... | 0.13148 |
[[cat-nodes]] == cat nodes The `nodes` command shows the cluster topology. For example [source,js] -------------------------------------------------- GET /\_cat/nodes?v -------------------------------------------------- // CONSOLE Might look like: [source,txt] -------------------------------------------------- ip heap.... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/cat/nodes.asciidoc | 6.2 | elasticsearch-6-2 | [
0.022268403321504593,
0.025273816660046577,
-0.09179331362247467,
0.05388173460960388,
0.019533779472112656,
-0.07957328855991364,
-0.016102539375424385,
0.00002818727443809621,
-0.025710612535476685,
-0.0020439387299120426,
0.014535910449922085,
-0.048588600009679794,
0.02807086892426014,
... | 0.142403 |
master (-) |\* |`name` |`n` |Yes |Node name |I8hydUG |`completion.size` |`cs`, `completionSize` |No |Size of completion |0b |`fielddata.memory\_size` |`fm`, `fielddataMemory` |No |Used fielddata cache memory |0b |`fielddata.evictions` |`fe`, `fielddataEvictions` |No |Fielddata cache evictions |0 |`query\_cache.memory\_... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/cat/nodes.asciidoc | 6.2 | elasticsearch-6-2 | [
0.015692824497818947,
0.0024153804406523705,
-0.08096395432949066,
0.06196977198123932,
-0.053395576775074005,
-0.024757320061326027,
0.02871391549706459,
0.04967173561453819,
-0.011725206859409809,
0.06665249168872833,
0.021887587383389473,
-0.03809446841478348,
0.07937109470367432,
-0.07... | 0.090821 |
[[cat-fielddata]] == cat fielddata `fielddata` shows how much heap memory is currently being used by fielddata on every data node in the cluster. //// Hidden setup snippet to build an index with fielddata so our results are real: [source,js] -------------------------------------------------- PUT test { "mappings": { "t... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/cat/fielddata.asciidoc | 6.2 | elasticsearch-6-2 | [
0.022811230272054672,
0.06102854385972023,
0.0017258303705602884,
0.1313299983739853,
-0.04407973960042,
-0.015471131540834904,
0.0068230293691158295,
-0.00310264783911407,
0.04048145189881325,
-0.012769535183906555,
-0.012544817291200161,
0.024162400513887405,
-0.04343460500240326,
-0.038... | 0.05964 |
[[cat-count]] == cat count `count` provides quick access to the document count of the entire cluster, or individual indices. [source,js] -------------------------------------------------- GET /\_cat/count?v -------------------------------------------------- // CONSOLE // TEST[setup:big\_twitter] // TEST[s/^/POST test\/... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/cat/count.asciidoc | 6.2 | elasticsearch-6-2 | [
0.020350763574242592,
0.013023716397583485,
-0.034886084496974945,
0.15108442306518555,
-0.023325731977820396,
0.013716137036681175,
-0.039487075060606,
0.022579172626137733,
0.08971765637397766,
-0.02670280821621418,
0.051583871245384216,
-0.03304736688733101,
0.022027038037776947,
-0.095... | 0.120682 |
[[cat-snapshots]] == cat snapshots The `snapshots` command shows all snapshots that belong to a specific repository. To find a list of available repositories to query, the command `/\_cat/repositories` can be used. Querying the snapshots of a repository named `repo1` then looks as follows. [source,js] -----------------... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/cat/snapshots.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.03581424802541733,
0.0008117830730043352,
-0.029086535796523094,
0.01482378225773573,
0.03025929629802704,
-0.0006523321499116719,
0.017429988831281662,
-0.018191741779446602,
0.023679781705141068,
-0.05554427206516266,
0.03549583628773689,
-0.022837476804852486,
0.008057018741965294,
-... | 0.022103 |
[[cat-alias]] == cat aliases `aliases` shows information about currently configured aliases to indices including filter and routing infos. //// Hidden setup for example: [source,js] -------------------------------------------------- PUT test1 { "aliases": { "alias1": {}, "alias2": { "filter": { "match": { "user": "kimc... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/cat/alias.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.008073288947343826,
0.05219367891550064,
0.012683737091720104,
0.05983530730009079,
0.005714272614568472,
-0.017858002334833145,
0.04291408881545067,
0.01718713901937008,
0.005877379793673754,
-0.06951142847537994,
-0.07094467431306839,
-0.05626300722360611,
0.0012510211672633886,
-0.01... | 0.024811 |
[[cat-repositories]] == cat repositories The `repositories` command shows the snapshot repositories registered in the cluster. For example: [source,js] -------------------------------------------------- GET /\_cat/repositories?v -------------------------------------------------- // CONSOLE // TEST[s/^/PUT \/\_snapshot\... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/cat/repositories.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.007937501184642315,
0.016296863555908203,
-0.05038353428244591,
0.0364711619913578,
0.0007022595964372158,
0.0035985494032502174,
-0.03348430246114731,
0.012223223224282265,
0.015767203643918037,
-0.03126023709774017,
0.03208349645137787,
-0.045655880123376846,
-0.006793330889195204,
-0... | 0.128477 |
[[cat-plugins]] == cat plugins The `plugins` command provides a view per node of running plugins. This information \*spans nodes\*. [source,js] ------------------------------------------------------------------------------ GET /\_cat/plugins?v&s=component&h=name,component,version,description ---------------------------... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/cat/plugins.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.01542834285646677,
0.006187743507325649,
-0.058595191687345505,
0.0753437802195549,
0.03275159001350403,
0.03264343738555908,
0.0015788004966452718,
0.023172682151198387,
0.03292456269264221,
-0.035808175802230835,
0.009066123515367508,
-0.05497603490948677,
-0.055202607065439224,
-0.06... | 0.016956 |
[[cat-recovery]] == cat recovery The `recovery` command is a view of index shard recoveries, both on-going and previously completed. It is a more compact view of the JSON <> API. A recovery event occurs anytime an index shard moves to a different node in the cluster. This can happen during a snapshot recovery, a change... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/cat/recovery.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.00332009163685143,
0.001416567014530301,
0.05705529823899269,
0.0789835974574089,
0.055421750992536545,
-0.03291666880249977,
-0.029883140698075294,
-0.04845500364899635,
0.11711597442626953,
-0.029091160744428635,
0.01588224060833454,
0.06664105504751205,
-0.007997571490705013,
-0.0225... | 0.114098 |
[[cat-nodeattrs]] == cat nodeattrs The `nodeattrs` command shows custom node attributes. For example: [source,js] -------------------------------------------------- GET /\_cat/nodeattrs?v -------------------------------------------------- // CONSOLE Could look like: [source,txt] ----------------------------------------... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/cat/nodeattrs.asciidoc | 6.2 | elasticsearch-6-2 | [
0.009361803531646729,
0.09965681284666061,
-0.0352926068007946,
0.10848796367645264,
0.002901802770793438,
-0.036201197654008865,
0.006569035816937685,
-0.014655370265245438,
-0.006701486650854349,
-0.018352607265114784,
0.017057379707694054,
-0.08543450385332108,
0.015149280428886414,
-0.... | 0.050905 |
[[cat-health]] == cat health `health` is a terse, one-line representation of the same information from `/\_cluster/health`. [source,js] -------------------------------------------------- GET /\_cat/health?v -------------------------------------------------- // CONSOLE // TEST[s/^/PUT twitter\n{"settings":{"number\_of\_... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/cat/health.asciidoc | 6.2 | elasticsearch-6-2 | [
0.010235791094601154,
0.1268494427204132,
-0.054124847054481506,
0.04979369044303894,
0.016281496733427048,
-0.022829893976449966,
0.018736209720373154,
0.030723121017217636,
0.024332061409950256,
-0.04218617454171181,
0.028477754443883896,
-0.021153461188077927,
0.004695248790085316,
-0.0... | 0.174045 |
[[cat-shards]] == cat shards The `shards` command is the detailed view of what nodes contain which shards. It will tell you if it's a primary or replica, the number of docs, the bytes it takes on disk, and the node where it's located. Here we see a single index, with one primary shard and no replicas: [source,js] -----... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/cat/shards.asciidoc | 6.2 | elasticsearch-6-2 | [
0.03234477713704109,
0.03869852423667908,
0.0016352080274373293,
0.047473400831222534,
0.03835613280534744,
-0.08054661750793457,
-0.02209930680692196,
-0.025804532691836357,
0.14017146825790405,
0.00612539891153574,
0.004894688259810209,
-0.005058491136878729,
0.035584550350904465,
-0.065... | 0.077505 |
A better replica location is identified and causes the existing replica allocation to be cancelled. | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/cat/shards.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.01750904507935047,
-0.025468653067946434,
0.048278674483299255,
0.01580326445400715,
0.07839377224445343,
-0.026986999437212944,
-0.0637899711728096,
-0.0833074077963829,
0.12330424040555954,
0.05087071284651756,
0.013072521425783634,
0.13500867784023285,
0.02634471282362938,
-0.0078765... | 0.099452 |
[[cat-pending-tasks]] == cat pending tasks `pending\_tasks` provides the same information as the <> API in a convenient tabular format. For example: [source,js] -------------------------------------------------- GET /\_cat/pending\_tasks?v -------------------------------------------------- // CONSOLE Might look like: [... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/cat/pending_tasks.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.00021077859855722636,
0.02857242152094841,
-0.03717370703816414,
0.0453089214861393,
-0.020055698230862617,
-0.045960236340761185,
0.0394781157374382,
-0.01693742536008358,
0.03982420638203621,
0.0468706376850605,
0.0014703769702464342,
-0.006196837406605482,
-0.022571520879864693,
-0.0... | 0.10487 |
[[cat-master]] == cat master `master` doesn't have any extra options. It simply displays the master's node ID, bound IP address, and node name. For example: [source,js] -------------------------------------------------- GET /\_cat/master?v -------------------------------------------------- // CONSOLE might respond: [so... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/cat/master.asciidoc | 6.2 | elasticsearch-6-2 | [
0.026807405054569244,
0.08292274922132492,
-0.04994283244013786,
0.04577835276722908,
0.018473753705620766,
-0.027329333126544952,
-0.025329580530524254,
-0.01120744738727808,
-0.008770281448960304,
-0.023031119257211685,
-0.011455581523478031,
-0.0403655506670475,
0.009756207466125488,
-0... | 0.04632 |
[[cat-segments]] == cat segments The `segments` command provides low level information about the segments in the shards of an index. It provides information similar to the link:indices-segments.html[\_segments] endpoint. For example: [source,js] -------------------------------------------------- GET /\_cat/segments?v -... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/cat/segments.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.018052758648991585,
0.06209898367524147,
0.03563690930604935,
0.08480857312679291,
0.03731375187635422,
-0.03450280800461769,
0.013905961997807026,
0.004504338372498751,
0.07507986575365067,
-0.06963439285755157,
-0.023718783631920815,
-0.00028822783497162163,
-0.014895396307110786,
-0.... | 0.093481 |
[[cat-indices]] == cat indices The `indices` command provides a cross-section of each index. This information \*spans nodes\*. For example: [source,js] -------------------------------------------------- GET /\_cat/indices/twi\*?v&s=index -------------------------------------------------- // CONSOLE // TEST[setup:huge\_... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/cat/indices.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.02650800719857216,
0.0907488465309143,
-0.011709588579833508,
0.08689972758293152,
0.012184897437691689,
-0.024053048342466354,
0.03129187971353531,
-0.023526448756456375,
0.03256106376647949,
-0.027349920943379402,
0.015455865301191807,
-0.03504639491438866,
0.02296864613890648,
-0.082... | 0.100607 |
[[cat-templates]] == cat templates The `templates` command provides information about existing templates. [source,js] -------------------------------------------------- GET /\_cat/templates?v&s=name -------------------------------------------------- // CONSOLE // TEST[s/^/PUT \_template\/template0\n{"index\_patterns": ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/cat/templates.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.017067348584532738,
0.07364127784967422,
0.05869883671402931,
0.03026438131928444,
-0.010147732682526112,
0.06049405783414841,
0.004670106805860996,
-0.009492049925029278,
0.006914620287716389,
-0.05487823113799095,
0.0036157453432679176,
-0.00324510526843369,
-0.06353592127561569,
-0.0... | 0.03338 |
[[mapping-fields]] == Meta-Fields Each document has metadata associated with it, such as the `\_index`, mapping <>, and `\_id` meta-fields. The behaviour of some of these meta-fields can be customised when a mapping type is created. [float] === Identity meta-fields [horizontal] <>:: The index to which the document belo... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/fields.asciidoc | 6.2 | elasticsearch-6-2 | [
0.032128170132637024,
0.09443245083093643,
0.03326457366347313,
0.06528754532337189,
0.044802598655223846,
-0.038766805082559586,
-0.04713127389550209,
0.05910123139619827,
0.005578469485044479,
0.016319112852215767,
-0.026841169223189354,
0.07023952901363373,
-0.013764990493655205,
-0.012... | 0.073821 |
[[dynamic-mapping]] == Dynamic Mapping One of the most important features of Elasticsearch is that it tries to get out of your way and let you start exploring your data as quickly as possible. To index a document, you don't have to first create an index, define a mapping type, and define your fields -- you can just ind... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/dynamic-mapping.asciidoc | 6.2 | elasticsearch-6-2 | [
0.005411501042544842,
0.03646952658891678,
0.05085976421833038,
0.11376318335533142,
-0.021685712039470673,
0.056057464331388474,
-0.05404854565858841,
0.050326377153396606,
0.10632973909378052,
0.008424358442425728,
-0.03485792502760887,
0.013978738337755203,
0.03811725601553917,
-0.00333... | 0.113546 |
[[removal-of-types]] == Removal of mapping types IMPORTANT: Indices created in Elasticsearch 6.0.0 or later may only contain a single <>. Indices created in 5.x with multiple mapping types will continue to function as before in Elasticsearch 6.x. Types will be deprecated in APIs in Elasticsearch 7.0.0, and completely r... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/removal_of_types.asciidoc | 6.2 | elasticsearch-6-2 | [
0.03789408132433891,
0.03825762867927551,
0.07395409047603607,
0.05237149819731712,
0.02440142259001732,
-0.031459175050258636,
0.0038754241541028023,
-0.018102606758475304,
0.07272854447364807,
0.018281077966094017,
-0.01070720236748457,
0.03872232139110565,
-0.020915761590003967,
0.01230... | 0.12238 |
so benefit from compression techniques used in Lucene. \* The term statistics used for scoring in full text search are more likely to be accurate because all documents in the same index represent a single entity. Each index can be sized appropriately for the number of documents it will contain: you can use a smaller nu... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/removal_of_types.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.0005742328357882798,
0.06228433921933174,
0.023118995130062103,
0.07297733426094055,
0.0005487166345119476,
0.015487408265471458,
-0.017961852252483368,
0.0402187779545784,
0.08553782105445862,
-0.01697448268532753,
-0.038405776023864746,
0.02349756471812725,
0.032037049531936646,
0.029... | 0.086599 |
`\_doc`, so that index APIs have the same path as they will have in 7.0: `PUT {index}/\_doc/{id}` and `POST {index}/\_doc` \* The `\_type` name can no longer be combined with the `\_id` to form the `\_uid` field. The `\_uid` field has become an alias for the `\_id` field. \* New indices no longer support the old-style ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/removal_of_types.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.07867447286844254,
0.0356774777173996,
0.09046527743339539,
0.1083691343665123,
-0.03883201628923416,
-0.015142085030674934,
-0.052318770438432693,
0.01950201578438282,
0.010223799385130405,
0.025801166892051697,
-0.0318717285990715,
0.008528484962880611,
-0.02962597645819187,
0.0343338... | 0.124612 |
[[mapping-types]] == Field datatypes Elasticsearch supports a number of different datatypes for the fields in a document: [float] === Core datatypes string:: <> and <> <>:: `long`, `integer`, `short`, `byte`, `double`, `float`, `half\_float`, `scaled\_float` <>:: `date` <>:: `boolean` <>:: `binary` <>:: `integer\_range... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types.asciidoc | 6.2 | elasticsearch-6-2 | [
0.04414769262075424,
0.07306042313575745,
0.04654755815863609,
-0.007443316280841827,
-0.009472670964896679,
-0.05106060951948166,
-0.03773659095168114,
0.0349234975874424,
-0.01432410441339016,
0.0022882246412336826,
-0.05704271048307419,
-0.03966081142425537,
-0.012228744104504585,
0.061... | 0.117953 |
[[mapping-params]] == Mapping parameters The following pages provide detailed explanations of the various mapping parameters that are used by <>: The following mapping parameters are common to some or all field datatypes: \* <> \* <> \* <> \* <> \* <> \* <> \* <> \* <> \* <> \* <> \* <> \* <> \* <> \* <> \* <> \* <> \*... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.004867925308644772,
0.003697587177157402,
-0.09692298620939255,
0.01253272220492363,
-0.03961441293358803,
-0.008501102216541767,
0.007294767070561647,
0.09116160124540329,
-0.07496417313814163,
-0.052658211439847946,
0.09123840183019638,
-0.13935492932796478,
0.007348049432039261,
-0.0... | 0.14399 |
[[parent-join]] === `join` datatype The `join` datatype is a special field that creates parent/child relation within documents of the same index. The `relations` section defines a set of possible relations within the documents, each relation being a parent name and a child name. A parent/child relation can be defined a... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/parent-join.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.05125093460083008,
0.057699237018823624,
0.07714537531137466,
0.10879387706518173,
0.01236121915280819,
0.012439442798495293,
-0.008601021021604538,
0.07192640006542206,
0.10912056267261505,
-0.04414217919111252,
-0.05154523253440857,
-0.024701585993170738,
0.030988246202468872,
-0.0014... | 0.035345 |
An element can have multiple children but only one parent. \* It is possible to add a new relation to an existing `join` field. \* It is also possible to add a child to an existing element but only if the element is already a parent. ==== Searching with parent-join The parent-join creates one field to index the name of... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/parent-join.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.08618225157260895,
0.0008518926333636045,
0.038595907390117645,
0.11585836857557297,
0.01204795204102993,
-0.04842304810881615,
-0.018322531133890152,
0.025391748175024986,
0.056058693677186966,
-0.02796609327197075,
0.009576688520610332,
-0.009917113929986954,
0.12656360864639282,
-0.0... | 0.058151 |
This can add significant time to the refresh. However most of the times this is the right trade-off, otherwise global ordinals are rebuilt when the first parent-join query or aggregation is used. This can introduce a significant latency spike for your users and usually this is worse as multiple global ordinals for the ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/parent-join.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.08621598035097122,
0.012641942128539085,
0.08185262978076935,
0.11961964517831802,
0.020369481295347214,
-0.012169478461146355,
-0.06651343405246735,
-0.0010167312575504184,
0.11316182464361191,
-0.007408451288938522,
-0.052684854716062546,
0.060260120779275894,
-0.018344363197684288,
-... | 0.003693 |
[[percolator]] === Percolator type The `percolator` field type parses a json structure into a native query and stores that query, so that the <> can use it to match provided documents. Any field that contains a json object can be configured to be a percolator field. The percolator field type has no settings. Just confi... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/percolator.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.01738291047513485,
0.09572810679674149,
0.07367958128452301,
0.046485576778650284,
-0.016288677230477333,
0.03951500728726387,
-0.04179322347044945,
0.024732261896133423,
0.08647513389587402,
-0.01612638682126999,
-0.08071371167898178,
-0.040783025324344635,
-0.014078804291784763,
0.084... | 0.072528 |
: 0, "failed": 0 }, "hits": { "total": 1, "max\_score": 0.2876821, "hits": [ { "\_index": "new\_index", <1> "\_type": "\_doc", "\_id": "1", "\_score": 0.2876821, "\_source": { "query": { "match": { "body": "quick brown fox" } } }, "fields" : { "\_percolator\_document\_slot" : [0] } } ] } } -----------------------------... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/percolator.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.018297113478183746,
0.07323922961950302,
0.041742727160453796,
0.09697316586971283,
0.01641710475087166,
-0.008178649470210075,
0.05257463455200195,
0.006216336507350206,
0.08450976759195328,
-0.0023403926752507687,
-0.03835751488804817,
-0.060335975140333176,
0.029135219752788544,
-0.0... | 0.074492 |
important to select a whitespace analyzer here, otherwise the analyzer defined in the mapping will be used, which defeats the point of using this workflow. Note that `whitespace` is a built-in analyzer, if a different analyzer needs to be used, it needs to be configured first in the index's settings. The analyze api pr... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/percolator.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.056097544729709625,
0.037943512201309204,
0.05774923041462898,
0.08550950139760971,
0.023834174498915672,
-0.01977016218006611,
0.0023931050673127174,
-0.03128810599446297,
0.08383099734783173,
-0.06790740042924881,
-0.050941720604896545,
-0.04918215051293373,
-0.015414105728268623,
-0.... | 0.081159 |
also be used to speed up suffix wildcard searches. By using the `reverse` token filter before the `edge\_ngram` token filter. [source,js] -------------------------------------------------- PUT my\_queries2 { "settings": { "analysis": { "analyzer": { "wildcard\_suffix": { "type": "custom", "tokenizer": "standard", "filt... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/percolator.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.018782321363687515,
0.06654608994722366,
0.03706895932555199,
0.041205164045095444,
0.005867979023605585,
0.002913891104981303,
-0.002019670559093356,
0.044461384415626526,
-0.009565133601427078,
-0.04961668327450752,
-0.04307224974036217,
-0.04738803952932358,
-0.06289177387952805,
0.0... | 0.100048 |
indexed by the `percolator` field type then the get call is executed once. So each time the `percolator` query evaluates these queries, the fetches terms, shapes etc. as the were upon index time will be used. Important to note is that fetching of terms that these queries do, happens both each time the percolator query ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/percolator.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.02075223997235298,
0.007228197995573282,
0.04400902986526489,
0.08801338821649551,
-0.013745061121881008,
-0.06352482736110687,
0.02542627975344658,
-0.033384911715984344,
0.1480412483215332,
-0.017361870035529137,
0.007030209992080927,
0.006466880440711975,
0.023081962019205093,
-0.066... | 0.053429 |
[[geo-point]] === Geo-point datatype Fields of type `geo\_point` accept latitude-longitude pairs, which can be used: \* to find geo-points within a <>, within a certain <> of a central point, or within a <>. \* to aggregate documents <> or by <> from a central point. \* to integrate distance into a document's <>. \* to... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/geo-point.asciidoc | 6.2 | elasticsearch-6-2 | [
0.01759171485900879,
0.08223104476928711,
0.08511985093355179,
0.016702665016055107,
0.03229476884007454,
0.040380727499723434,
0.005577005911618471,
0.044226858764886856,
0.09841584414243698,
-0.015448592603206635,
-0.03750552237033844,
0.012319671921432018,
0.02544393204152584,
0.0428686... | 0.076679 |
[[token-count]] === Token count datatype A field of type `token\_count` is really an <> field which accepts string values, analyzes them, then indexes the number of tokens in the string. For instance: [source,js] -------------------------------------------------- PUT my\_index { "mappings": { "\_doc": { "properties": {... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/token-count.asciidoc | 6.2 | elasticsearch-6-2 | [
0.014199802652001381,
0.09628723561763763,
0.1013079583644867,
0.09196141362190247,
-0.03988473117351532,
0.034063857048749924,
0.035942066460847855,
0.03564884513616562,
0.09194564074277878,
-0.006934076547622681,
-0.04235956817865372,
-0.04214796796441078,
0.018676215782761574,
0.0119440... | 0.070778 |
[[ip]] === IP datatype An `ip` field can index/store either https://en.wikipedia.org/wiki/IPv4[IPv4] or https://en.wikipedia.org/wiki/IPv6[IPv6] addresses. [source,js] -------------------------------------------------- PUT my\_index { "mappings": { "\_doc": { "properties": { "ip\_addr": { "type": "ip" } } } } } PUT my\... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/ip.asciidoc | 6.2 | elasticsearch-6-2 | [
0.021409722045063972,
0.0824626162648201,
0.08434177935123444,
0.027242952957749367,
-0.0036184166092425585,
-0.00016577290080022067,
-0.012546466663479805,
-0.04568235203623772,
0.08657515794038773,
-0.010359260253608227,
-0.01440199464559555,
-0.0201986413449049,
-0.02593669481575489,
0.... | 0.061871 |
[[range]] === Range datatypes The following range types are supported: [horizontal] `integer\_range`:: A range of signed 32-bit integers with a minimum value of +-2^31^+ and maximum of +2^31^-1+. `float\_range`:: A range of single-precision 32-bit IEEE 754 floating point values. `long\_range`:: A range of signed 64-bit... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/range.asciidoc | 6.2 | elasticsearch-6-2 | [
0.011648125015199184,
0.04772159829735756,
-0.05630633234977722,
-0.03354054316878319,
-0.04483662545681,
0.00046715239295735955,
-0.04392791911959648,
0.0013637144584208727,
-0.049393605440855026,
-0.07117589563131332,
-0.016484379768371582,
-0.04362959414720535,
0.007890542969107628,
-0.... | 0.073077 |
{ "type": "ip\_range" } } } PUT range\_index/\_doc/2 { "ip\_whitelist" : "192.168.0.0/16" } -------------------------------------------------- // CONSOLE [[range-params]] ==== Parameters for range fields The following parameters are accepted by range types: [horizontal] <>:: Try to convert strings to numbers and trunca... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/range.asciidoc | 6.2 | elasticsearch-6-2 | [
0.014243356883525848,
0.13523255288600922,
-0.04630467668175697,
0.03876505792140961,
-0.01469145156443119,
0.036732692271471024,
0.030376719310879707,
0.0411883108317852,
-0.017493419349193573,
-0.04347513988614082,
-0.02851085178554058,
-0.02405226044356823,
0.014453650452196598,
-0.0253... | 0.056996 |
[[binary]] === Binary datatype The `binary` type accepts a binary value as a https://en.wikipedia.org/wiki/Base64[Base64] encoded string. The field is not stored by default and is not searchable: [source,js] -------------------------------------------------- PUT my\_index { "mappings": { "\_doc": { "properties": { "nam... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/binary.asciidoc | 6.2 | elasticsearch-6-2 | [
0.01268057618290186,
0.1253587007522583,
0.07712576538324356,
0.06496385484933853,
-0.011199118569493294,
-0.02014065720140934,
-0.0007732185767963529,
0.02322310209274292,
0.07427943497896194,
-0.012585348449647427,
-0.07862909883260727,
-0.006518098525702953,
0.030271610245108604,
0.0144... | 0.060718 |
[[nested]] === Nested datatype The `nested` type is a specialised version of the <> datatype that allows arrays of objects to be indexed and queried independently of each other. ==== How arrays of objects are flattened Arrays of inner <> do not work the way you may expect. Lucene has no concept of inner objects, so Ela... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/nested.asciidoc | 6.2 | elasticsearch-6-2 | [
0.016033943742513657,
0.0712440237402916,
0.10757599025964737,
0.08836742490530014,
0.007023660000413656,
-0.030249444767832756,
-0.04059542715549469,
0.0036042409483343363,
0.07186485081911087,
0.003966383170336485,
-0.1175316795706749,
-0.013832841999828815,
-0.02551315166056156,
0.01525... | 0.056769 |
be added to an existing nested object. [IMPORTANT] ============================================= Because nested documents are indexed as separate documents, they can only be accessed within the scope of the `nested` query, the `nested`/`reverse\_nested` aggregations, or <>. For instance, if a string field within a nest... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/nested.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.0018074365798383951,
0.05957886576652527,
0.07485806941986084,
0.080463707447052,
0.02518570050597191,
0.040335047990083694,
-0.047967273741960526,
-0.013444019481539726,
0.004202166572213173,
-0.02011927217245102,
-0.05307510122656822,
-0.028233470395207405,
0.04857151582837105,
-0.039... | -0.031854 |
[[date]] === Date datatype JSON doesn't have a date datatype, so dates in Elasticsearch can either be: \* strings containing formatted dates, e.g. `"2015-01-01"` or `"2015/01/01 12:10:30"`. \* a long number representing \_milliseconds-since-the-epoch\_. \* an integer representing \_seconds-since-the-epoch\_. Internally... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/date.asciidoc | 6.2 | elasticsearch-6-2 | [
0.012742405757308006,
0.08949363231658936,
0.06689373403787613,
0.030211713165044785,
-0.011687228456139565,
0.04194513335824013,
-0.09574304521083832,
0.02732066437602043,
0.05995146930217743,
-0.004210357088595629,
-0.059535905718803406,
-0.05617239698767662,
-0.05384650081396103,
0.0172... | 0.061141 |
[[object]] === Object datatype JSON documents are hierarchical in nature: the document may contain inner objects which, in turn, may contain inner objects themselves: [source,js] -------------------------------------------------- PUT my\_index/\_doc/1 { <1> "region": "US", "manager": { <2> "age": 30, "name": { <3> "fir... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/object.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.07574548572301865,
0.14145857095718384,
0.07276104390621185,
0.07518105208873749,
0.0023681004531681538,
-0.07038962095975876,
0.015364622697234154,
0.023520704358816147,
0.06523872911930084,
-0.028413766995072365,
-0.019143037497997284,
0.012248866260051727,
-0.03161977604031563,
0.007... | 0.158486 |
[[geo-shape]] === Geo-Shape datatype The `geo\_shape` datatype facilitates the indexing of and searching with arbitrary geo shapes such as rectangles and polygons. It should be used when either the data being indexed or the queries being executed contain shapes other than just points. You can query documents using this... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/geo-shape.asciidoc | 6.2 | elasticsearch-6-2 | [
0.022309327498078346,
0.05558006465435028,
0.08312449604272842,
0.05917055532336235,
-0.04417223110795021,
-0.062257979065179825,
0.002684377133846283,
0.012061506509780884,
-0.030640384182333946,
-0.04629221931099892,
-0.02090604417026043,
-0.04220553860068321,
0.026064202189445496,
0.026... | 0.033901 |
field type for point shapes only (NOTE: Multi-Points are not yet supported). This optimizes index and search performance for the `geohash` and `quadtree` when it is known that only points will be indexed. At present geo\_shape queries can not be executed on `geo\_point` field types. This option bridges the gap by impro... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/geo-shape.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.01449659839272499,
0.07062767446041107,
0.07281892746686935,
0.012385417707264423,
-0.0063316249288618565,
-0.08945763111114502,
-0.017295977100729942,
-0.011258349753916264,
0.015371086075901985,
-0.01502734050154686,
-0.012821988202631474,
0.029864659532904625,
-0.02014637365937233,
0... | 0.065146 |
a tree\_levels setting of 26. [float] ===== Performance considerations Elasticsearch uses the paths in the prefix tree as terms in the index and in queries. The higher the level is (and thus the precision), the more terms are generated. Of course, calculating the terms, keeping them in memory, and storing them on disk ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/geo-shape.asciidoc | 6.2 | elasticsearch-6-2 | [
0.04586084187030792,
0.02229177951812744,
0.022622909396886826,
0.0274142287671566,
0.011998292058706284,
-0.11603506654500961,
-0.1379750519990921,
0.05460766330361366,
0.061207931488752365,
0.04609358310699463,
-0.08464156836271286,
0.0004255157837178558,
-0.009115887805819511,
0.0264935... | 0.06497 |
an example of a LineString in WKT: [source,js] -------------------------------------------------- POST /example/doc { "location" : "LINESTRING (-77.03653 38.897676, -77.009051 38.889939)" } -------------------------------------------------- // CONSOLE The above `linestring` would draw a straight line starting at the Wh... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/geo-shape.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.12310406565666199,
0.10094299912452698,
-0.05025260150432587,
0.009178714826703072,
0.015348381362855434,
-0.04619447514414787,
0.07168274372816086,
0.04014723002910614,
0.039191000163555145,
-0.02311721257865429,
-0.09739381819963455,
-0.008721809834241867,
-0.015375486575067043,
0.002... | 0.123325 |
} -------------------------------------------------- // CONSOLE // TEST[skip:https://github.com/elastic/elasticsearch/issues/23836] [float] [[multipoint]] ===== http://www.geojson.org/geojson-spec.html#id5[MultiPoint] The following is an example of a list of geojson points: [source,js] ---------------------------------... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/geo-shape.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.03150403872132301,
0.06830751150846481,
-0.0013581144157797098,
-0.026064453646540642,
0.08693750947713852,
-0.0174811240285635,
-0.014366386458277702,
-0.008941764943301678,
0.07967480272054672,
-0.024013327434659004,
-0.0533188059926033,
-0.028741782531142235,
-0.015695998445153236,
0... | 0.055738 |
inner `radius` field is required. If not specified, then the units of the `radius` will default to `METERS`. \*NOTE:\* Neither GeoJSON or WKT support a point-radius circle type. [float] ==== Sorting and Retrieving index Shapes Due to the complex input structure and index representation of shapes, it is not currently po... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/geo-shape.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.01064065471291542,
0.07576046884059906,
-0.0372563898563385,
0.03705731779336929,
-0.03151315823197365,
-0.06012571230530739,
0.02506212517619133,
0.04875093698501587,
0.04189896583557129,
-0.057924479246139526,
0.030070748180150986,
-0.027007952332496643,
-0.03558287024497986,
0.069205... | 0.060577 |
[[boolean]] === Boolean datatype Boolean fields accept JSON `true` and `false` values, but can also accept strings which are interpreted as either true or false: [horizontal] False values:: `false`, `"false"` True values:: `true`, `"true"` For example: [source,js] -------------------------------------------------- PUT ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/boolean.asciidoc | 6.2 | elasticsearch-6-2 | [
0.011656578630208969,
0.08980122208595276,
0.05584955960512161,
0.05487392097711563,
-0.009384040720760822,
0.014209438115358353,
0.017419209703803062,
-0.059697650372982025,
0.033227358013391495,
-0.017456484958529472,
-0.014012281782925129,
-0.04402140900492668,
0.0060180919244885445,
0.... | 0.016404 |
[[keyword]] === Keyword datatype A field to index structured content such as email addresses, hostnames, status codes, zip codes or tags. They are typically used for filtering (\_Find me all blog posts where ++status++ is ++published++\_), for sorting, and for aggregations. Keyword fields are only searchable by their e... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/keyword.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.0072570061311125755,
0.06896154582500458,
0.05312919616699219,
0.07887103408575058,
0.04058816656470299,
0.0037263070698827505,
0.04573453217744827,
-0.0010510854190215468,
0.060292765498161316,
0.02038429118692875,
-0.023670101538300514,
0.02927386946976185,
0.03612613305449486,
0.0047... | 0.011356 |
[[text]] === Text datatype A field to index full-text values, such as the body of an email or the description of a product. These fields are `analyzed`, that is they are passed through an <> to convert the string into a list of individual terms before being indexed. The analysis process allows Elasticsearch to search f... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/text.asciidoc | 6.2 | elasticsearch-6-2 | [
0.023888565599918365,
0.11756139993667603,
0.0898154005408287,
0.05202280357480049,
0.022421985864639282,
0.0017015343764796853,
-0.008564791642129421,
0.017327504232525826,
0.11653363704681396,
0.025650987401604652,
-0.04210946336388588,
0.02728164754807949,
-0.014765246771275997,
0.03434... | 0.038573 |
[[array]] === Arrays In Elasticsearch, there is no dedicated `array` datatype. Any field can contain zero or more values by default, however, all values in the array must be of the same datatype. For instance: \* an array of strings: [ `"one"`, `"two"` ] \* an array of integers: [ `1`, `2` ] \* an array of arrays: [ `1... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/array.asciidoc | 6.2 | elasticsearch-6-2 | [
0.10438449680805206,
0.09441657364368439,
0.04770771041512489,
0.026634661480784416,
-0.03781109303236008,
-0.0295698381960392,
0.04219328984618187,
-0.07053067535161972,
0.031421296298503876,
-0.007607243023812771,
-0.09784889966249466,
-0.022837864235043526,
-0.006725741550326347,
0.0237... | 0.052773 |
[[number]] === Numeric datatypes The following numeric types are supported: [horizontal] `long`:: A signed 64-bit integer with a minimum value of +-2^63^+ and a maximum value of +2^63^-1+. `integer`:: A signed 32-bit integer with a minimum value of +-2^31^+ and a maximum value of +2^31^-1+. `short`:: A signed 16-bit in... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/numeric.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.013017119839787483,
0.06871702522039413,
-0.0639604777097702,
-0.06583593785762787,
-0.042281679809093475,
-0.09795300662517548,
0.017802249640226364,
0.06736312061548233,
-0.0412498414516449,
-0.04291771352291107,
-0.04005149379372597,
-0.06102904677391052,
0.03946148231625557,
-0.0056... | 0.110287 |
parameters are accepted by numeric types: [horizontal] <>:: Try to convert strings to numbers and truncate fractions for integers. Accepts `true` (default) and `false`. <>:: Mapping field-level query time boosting. Accepts a floating point number, defaults to `1.0`. <>:: Should the field be stored on disk in a column-s... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/types/numeric.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.06634142994880676,
0.0845068022608757,
-0.11249720305204391,
0.06268727779388428,
-0.06378374993801117,
-0.02051200531423092,
-0.005476340651512146,
0.0467069149017334,
-0.01712522841989994,
-0.00476789427921176,
0.010283452458679676,
0.01503911055624485,
0.04532673954963684,
-0.0463334... | 0.095126 |
[[dynamic-field-mapping]] === Dynamic field mapping By default, when a previously unseen field is found in a document, Elasticsearch will add the new field to the type mapping. This behaviour can be disabled, both at the document and at the <> level, by setting the <> parameter to `false` (to ignore new fields) or to `... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/dynamic/field-mapping.asciidoc | 6.2 | elasticsearch-6-2 | [
0.0328957699239254,
0.08535195142030716,
0.042120322585105896,
0.04285313934087753,
-0.008312533609569073,
0.014945809729397297,
-0.015837768092751503,
-0.03274904564023018,
0.04858342185616493,
-0.02341477759182453,
-0.04625554382801056,
-0.009511874988675117,
-0.02701939269900322,
0.0308... | 0.056444 |
[[dynamic-templates]] === Dynamic templates Dynamic templates allow you to define custom mappings that can be applied to dynamically added fields based on: \* the <> detected by Elasticsearch, with <>. \* the name of the field, with <> or <>. \* the full dotted path to the field, with <>. The original field name `{name... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/dynamic/templates.asciidoc | 6.2 | elasticsearch-6-2 | [
0.01522494200617075,
0.11335808783769608,
0.049100086092948914,
0.06701162457466125,
-0.022805918008089066,
0.025627467781305313,
-0.013326387852430344,
0.04428502917289734,
0.03899373859167099,
-0.03312646970152855,
-0.07780101895332336,
-0.025552479550242424,
-0.04528868570923805,
0.0147... | 0.053882 |
NOTCONSOLE [[path-match-unmatch]] ==== `path\_match` and `path\_unmatch` The `path\_match` and `path\_unmatch` parameters work in the same way as `match` and `unmatch`, but operate on the full dotted path to the field, not just the final name, e.g. `some\_object.\*.some\_field`. This example copies the values of any fi... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/dynamic/templates.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.053515274077653885,
0.09586388617753983,
0.09627845138311386,
0.06081460416316986,
-0.0015417279209941626,
-0.01115257665514946,
0.009239548817276955,
-0.015557036735117435,
0.003759489394724369,
-0.05877779424190521,
-0.0373150072991848,
-0.06555857509374619,
-0.053508076816797256,
0.0... | 0.059694 |
course if you do not need them because you don't need to perform exact search or aggregate on this field, you could remove it as described in the previous section. ===== Time-series When doing time series analysis with Elasticsearch, it is common to have many numeric fields that you will often aggregate on but never fi... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/dynamic/templates.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.01377881970256567,
0.09421312063932419,
0.08071975409984589,
0.0669301301240921,
0.04747651889920235,
0.03156678378582001,
-0.07159044593572617,
-0.015213984996080399,
0.12180287390947342,
0.0007922071381472051,
-0.06619429588317871,
-0.007810832466930151,
-0.05089618265628815,
-0.01493... | 0.03007 |
[[null-value]] === `null\_value` A `null` value cannot be indexed or searched. When a field is set to `null`, (or an empty array or an array of `null` values) it is treated as though that field has no values. The `null\_value` parameter allows you to replace explicit `null` values with the specified value so that it ca... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/null-value.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.007578808348625898,
0.10829798132181168,
0.06808577477931976,
0.05005892366170883,
-0.023541584610939026,
0.041098348796367645,
0.023779306560754776,
-0.008955106139183044,
0.04672040417790413,
-0.021708358079195023,
-0.0061013163067400455,
-0.04009024426341057,
0.00014644418843090534,
... | 0.05829 |
[[mapping-boost]] === `boost` Individual fields can be \_boosted\_ automatically -- count more towards the relevance score -- at query time, with the `boost` parameter as follows: [source,js] -------------------------------------------------- PUT my\_index { "mappings": { "\_doc": { "properties": { "title": { "type": "... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/boost.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.06493837386369705,
0.08839300274848938,
0.05530130863189697,
0.0900053009390831,
-0.0106166647747159,
0.06147489324212074,
0.036110132932662964,
0.0350956954061985,
0.049035076051950455,
-0.05943594500422478,
-0.07154490053653717,
-0.040166232734918594,
0.04124881699681282,
-0.011670252... | 0.021978 |
[[eager-global-ordinals]] === `eager\_global\_ordinals` Global ordinals is a data-structure on top of doc values, that maintains an incremental numbering for each unique term in a lexicographic order. Each term has a unique number and the number of term 'A' is lower than the number of term 'B'. Global ordinals are only... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/eager-global-ordinals.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.022379081696271896,
0.030924664810299873,
0.08488263934850693,
-0.04999897629022598,
-0.033022861927747726,
0.03061167150735855,
-0.04442541301250458,
-0.010576648637652397,
0.07596184313297272,
0.012140383943915367,
-0.012211592867970467,
0.03442629426717758,
0.06880319118499756,
-0.01... | 0.047425 |
[[index-options]] === `index\_options` The `index\_options` parameter controls what information is added to the inverted index, for search and highlighting purposes. It accepts the following settings: [horizontal] `docs`:: Only the doc number is indexed. Can answer the question \_Does this term exist in this field?\_ `... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/index-options.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.05452261120080948,
0.04403407499194145,
-0.008318944834172726,
0.08422575145959854,
-0.004018478095531464,
0.06163277104496956,
0.017377370968461037,
-0.0002633768308442086,
0.07573821395635605,
-0.008567746728658676,
-0.010962240397930145,
0.056443069130182266,
0.042748454958200455,
-0... | 0.118468 |
[[fielddata]] === `fielddata` Most fields are <> by default, which makes them searchable. Sorting, aggregations, and accessing field values in scripts, however, requires a different access pattern from search. Search needs to answer the question \_"Which documents contain this term?"\_, while sorting and aggregations n... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/fielddata.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.0013429675018414855,
0.11561618745326996,
0.010004519484937191,
0.06633693724870682,
-0.041445277631282806,
0.02153891883790493,
0.05199408531188965,
0.07789285480976105,
0.05224012956023216,
-0.036291368305683136,
-0.003200215520337224,
0.133164182305336,
0.026109695434570312,
-0.02702... | 0.043626 |
document frequency falls between a `min` and `max` value, which can be expressed an absolute number (when the number is bigger than 1.0) or as a percentage (eg `0.01` is `1%` and `1.0` is `100%`). Frequency is calculated \*per segment\*. Percentages are based on the number of docs which have a value for the field, as o... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/fielddata.asciidoc | 6.2 | elasticsearch-6-2 | [
0.0143884913995862,
0.1023026630282402,
0.027765322476625443,
0.06634470075368881,
0.010256528854370117,
-0.03273998200893402,
0.02947319485247135,
0.03720296919345856,
0.10341352224349976,
-0.0014227809151634574,
-0.04292280226945877,
-0.05568685010075569,
-0.021533727645874023,
0.0018232... | 0.019155 |
[[normalizer]] === `normalizer` The `normalizer` property of <> fields is similar to <> except that it guarantees that the analysis chain produces a single token. The `normalizer` is applied prior to indexing the keyword, as well as at search-time when the `keyword` field is searched via a query parser such as the <> q... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/normalizer.asciidoc | 6.2 | elasticsearch-6-2 | [
0.018692094832658768,
0.09027349948883057,
0.06844515353441238,
0.08617038279771805,
0.005461619235575199,
0.004233642481267452,
0.018761849030852318,
0.007566084619611502,
0.012438001111149788,
-0.02315579727292061,
-0.025139281526207924,
-0.01101483404636383,
0.02976801246404648,
-0.0031... | 0.089278 |
[[enabled]] === `enabled` Elasticsearch tries to index all of the fields you give it, but sometimes you want to just store the field without indexing it. For instance, imagine that you are using Elasticsearch as a web session store. You may want to index the session ID and last update time, but you don't need to query ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/enabled.asciidoc | 6.2 | elasticsearch-6-2 | [
0.01697375811636448,
0.1172792986035347,
0.0512600839138031,
0.07566642761230469,
0.00916407909244299,
0.008816364221274853,
-0.034122344106435776,
0.01048976555466652,
0.03078789822757244,
-0.007352333050221205,
-0.026224542409181595,
0.05671435222029686,
-0.029195569455623627,
0.00608359... | 0.07607 |
[[coerce]] === `coerce` Data is not always clean. Depending on how it is produced a number might be rendered in the JSON body as a true JSON number, e.g. `5`, but it might also be rendered as a string, e.g. `"5"`. Alternatively, a number that should be an integer might instead be rendered as a floating point, e.g. `5.0... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/coerce.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.041245490312576294,
0.10023600608110428,
0.06969824433326721,
0.03952375426888466,
-0.03273463621735573,
-0.05951841548085213,
0.0015176746528595686,
-0.008058068342506886,
0.03404943645000458,
-0.041741903871297836,
-0.05269775912165642,
-0.07201124727725983,
-0.027927247807383537,
0.0... | 0.025865 |
[[similarity]] === `similarity` Elasticsearch allows you to configure a scoring algorithm or \_similarity\_ per field. The `similarity` setting provides a simple way of choosing a similarity algorithm other than the default `BM25`, such as `TF/IDF`. Similarities are mostly useful for <> fields, but can also apply to ot... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/similarity.asciidoc | 6.2 | elasticsearch-6-2 | [
0.014724673703312874,
-0.011400560848414898,
-0.06367945671081543,
-0.03178095445036888,
0.01048081275075674,
0.0012206982355564833,
-0.016533037647604942,
-0.05268105864524841,
0.018417079001665115,
-0.03338271379470825,
-0.02651171199977398,
-0.022642971947789192,
0.07244743406772614,
0.... | 0.110452 |
[[ignore-malformed]] === `ignore\_malformed` Sometimes you don't have much control over the data that you receive. One user may send a `login` field that is a <>, and another sends a `login` field that is an email address. Trying to index the wrong datatype into a field throws an exception by default, and rejects the w... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/ignore-malformed.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.017072997987270355,
0.11445623636245728,
0.09606096148490906,
0.07977526634931564,
0.025630420073866844,
-0.0672900378704071,
0.040879834443330765,
-0.018508778885006905,
0.0724102109670639,
-0.028887975960969925,
-0.03292952850461006,
0.018545860424637794,
0.0439106710255146,
-0.026622... | 0.039075 |
[[multi-fields]] === `fields` It is often useful to index the same field in different ways for different purposes. This is the purpose of \_multi-fields\_. For instance, a `string` field could be mapped as a `text` field for full-text search, and as a `keyword` field for sorting or aggregations: [source,js] -----------... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/multi-fields.asciidoc | 6.2 | elasticsearch-6-2 | [
0.020208805799484253,
0.05434113368391991,
0.1268451064825058,
0.04326130822300911,
-0.02553454600274563,
0.014661600813269615,
0.003013886511325836,
0.006780778989195824,
0.07305678725242615,
-0.022963013499975204,
-0.027719248086214066,
0.007060436066240072,
-0.01291708368808031,
0.02220... | 0.025245 |
[[mapping-store]] === `store` By default, field values are <> to make them searchable, but they are not \_stored\_. This means that the field can be queried, but the original field value cannot be retrieved. Usually this doesn't matter. The field value is already part of the <>, which is stored by default. If you only ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/store.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.03348350152373314,
0.08450063318014145,
0.040694206953048706,
0.07099781185388565,
-0.005206103436648846,
0.040351949632167816,
-0.04257424548268318,
0.01840660721063614,
0.08635541051626205,
-0.0037312812637537718,
-0.008937625214457512,
0.055067311972379684,
-0.004530062433332205,
-0.... | 0.007437 |
[[properties]] === `properties` Type mappings, <> and <> contain sub-fields, called `properties`. These properties may be of any <>, including `object` and `nested`. Properties can be added: \* explicitly by defining them when <>. \* explicitly by defining them when adding or updating a mapping type with the <> API. \*... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/properties.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.01253576297312975,
0.08300747722387314,
0.089374840259552,
0.09562928229570389,
-0.0262458473443985,
-0.01079733856022358,
-0.03583553433418274,
0.020420338958501816,
0.04227635636925697,
0.013376628048717976,
-0.06997637450695038,
-0.02498587965965271,
-0.0039190202951431274,
0.0355063... | 0.031706 |
[[ignore-above]] === `ignore\_above` Strings longer than the `ignore\_above` setting will not be indexed or stored. [source,js] -------------------------------------------------- PUT my\_index { "mappings": { "\_doc": { "properties": { "message": { "type": "keyword", "ignore\_above": 20 <1> } } } } } PUT my\_index/\_do... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/ignore-above.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.04014293849468231,
0.0914766788482666,
0.1444576233625412,
0.06918256729841232,
0.009147752076387405,
-0.01979033276438713,
0.03315761312842369,
0.007422700524330139,
0.060876090079545975,
-0.02120443433523178,
-0.007737749721854925,
0.0276270043104887,
0.06293399631977081,
-0.058590658... | 0.044491 |
[[copy-to]] === `copy\_to` The `copy\_to` parameter allows you to create custom <> fields. In other words, the values of multiple fields can be copied into a group field, which can then be queried as a single field. For instance, the `first\_name` and `last\_name` fields can be copied to the `full\_name` field as follo... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/copy-to.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.02963193506002426,
0.04357964172959328,
0.09244637936353683,
0.08683846145868301,
0.001929920050315559,
-0.0049039809964597225,
0.040593504905700684,
0.018523110076785088,
0.013867681846022606,
-0.019855042919516563,
-0.016326583921909332,
-0.05307002738118172,
-0.008427037857472897,
-0... | 0.044071 |
[[dynamic]] === `dynamic` By default, fields can be added \_dynamically\_ to a document, or to <> within a document, just by indexing a document containing the new field. For instance: [source,js] -------------------------------------------------- PUT my\_index/\_doc/1 <1> { "username": "johnsmith", "name": { "first": ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/dynamic.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.0485081747174263,
0.0806889683008194,
0.13383503258228302,
0.07659601420164108,
-0.015285436995327473,
-0.02530253492295742,
-0.004397994372993708,
0.03194744512438774,
0.08662322163581848,
-0.021272538229823112,
-0.061551161110401154,
0.004205905832350254,
0.00923524796962738,
-0.01722... | 0.002393 |
[[position-increment-gap]] === `position\_increment\_gap` <> text fields take term <> into account, in order to be able to support <>. When indexing text fields with multiple values a "fake" gap is added between the values to prevent most phrase queries from matching across the values. The size of this gap is configure... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/position-increment-gap.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.06302768737077713,
0.10490269213914871,
0.05520649999380112,
0.00947577878832817,
0.02470315247774124,
0.08767730742692947,
0.013438250869512558,
-0.00201996136456728,
0.10543408244848251,
-0.029839562252163887,
-0.03019857592880726,
-0.04185132682323456,
0.009306690655648708,
-0.070834... | 0.057621 |
[[mapping-date-format]] === `format` In JSON documents, dates are represented as strings. Elasticsearch uses a set of preconfigured formats to recognize and parse these strings into a long value representing \_milliseconds-since-the-epoch\_ in UTC. Besides the <>, your own <> can be specified using the familiar `yyyy/M... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/format.asciidoc | 6.2 | elasticsearch-6-2 | [
0.05180415138602257,
0.08310315757989883,
0.08003402501344681,
0.03612985461950302,
-0.03826194256544113,
0.037154458463191986,
-0.11417236924171448,
0.0322376973927021,
0.0641397014260292,
0.02194777876138687,
-0.07878165692090988,
-0.025203878059983253,
-0.057621199637651443,
-0.00933300... | 0.030375 |
weekyear, and one digit day of week: `xxxx'W'wwe`. `basic\_week\_date\_time` or `strict\_basic\_week\_date\_time`:: A basic formatter that combines a basic weekyear date and time, separated by a 'T': `xxxx'W'wwe'T'HHmmss.SSSZ`. `basic\_week\_date\_time\_no\_millis` or `strict\_basic\_week\_date\_time\_no\_millis`:: A b... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/format.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.011295873671770096,
0.0749533399939537,
-0.023409971967339516,
-0.007677052635699511,
-0.04764261096715927,
0.006058247294276953,
-0.07751857489347458,
0.004790905397385359,
-0.11184778809547424,
-0.03364003449678421,
-0.00041610360494814813,
-0.06501105427742004,
0.025572240352630615,
... | 0.010145 |
full date as four digit weekyear, two digit week of weekyear, and one digit day of week: `xxxx-'W'ww-e`. `week\_date\_time` or `strict\_week\_date\_time`:: A formatter that combines a full weekyear date and time, separated by a 'T': `xxxx-'W'ww-e'T'HH:mm:ss.SSSZZ`. `week\_date\_time\_no\_millis` or `strict\_week\_date\... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/format.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.014281186275184155,
0.07875445485115051,
-0.028783781453967094,
0.005867382511496544,
-0.06161835417151451,
0.050508011132478714,
-0.08133266121149063,
0.019046725705266,
-0.12699730694293976,
-0.029761305078864098,
-0.019935155287384987,
-0.07633980363607407,
0.0496065653860569,
0.0059... | -0.030101 |
[[search-analyzer]] === `search\_analyzer` Usually, the same <> should be applied at index time and at search time, to ensure that the terms in the query are in the same format as the terms in the inverted index. Sometimes, though, it can make sense to use a different analyzer at search time, such as when using the <> ... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/search-analyzer.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.035444870591163635,
0.0724647268652916,
0.0233901459723711,
0.06909232586622238,
-0.01699632592499256,
0.00042166226194240153,
0.00824346300214529,
-0.015075494535267353,
0.04355630651116371,
-0.029612602666020393,
-0.0040795267559587955,
-0.03277415782213211,
-0.025608772411942482,
0.0... | 0.077784 |
[[term-vector]] === `term\_vector` Term vectors contain information about the terms produced by the <> process, including: \* a list of terms. \* the position (or order) of each term. \* the start and end character offsets mapping the term to its origin in the original string. These term vectors can be stored so that t... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/term-vector.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.04246595501899719,
0.004604810383170843,
-0.04702926054596901,
0.0113292895257473,
0.05431943014264107,
0.05981509014964104,
0.005221694242209196,
-0.03881336748600006,
0.08429215848445892,
-0.0017837588675320148,
0.029275162145495415,
0.07791843265295029,
0.011759377084672451,
-0.07353... | 0.090116 |
[[analyzer]] === `analyzer` The values of <> string fields are passed through an <> to convert the string into a stream of \_tokens\_ or \_terms\_. For instance, the string `"The quick Brown Foxes."` may, depending on which analyzer is used, be analyzed to the tokens: `quick`, `brown`, `fox`. These are the actual terms... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/analyzer.asciidoc | 6.2 | elasticsearch-6-2 | [
0.029886679723858833,
0.06708552688360214,
0.01132582500576973,
0.04793904721736908,
0.03130130097270012,
-0.02281532809138298,
0.01702190935611725,
-0.022364988923072815,
0.07508523762226105,
0.047767624258995056,
-0.044234078377485275,
-0.012062625028192997,
0.017495503649115562,
0.02701... | 0.104762 |
`my\_stop\_analyzer` analyzer which removes stop words <3> `analyzer` setting that points to the `my\_analyzer` analyzer which will be used at index time <4> `search\_analyzer` setting that points to the `my\_stop\_analyzer` and removes stop words for non-phrase queries <5> `search\_quote\_analyzer` setting that points... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/analyzer.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.08165369182825089,
0.06794381886720657,
0.00516847800463438,
0.07083351165056229,
0.03947882354259491,
0.04157225042581558,
0.07340283691883087,
-0.062174227088689804,
0.05638841912150383,
0.019182901829481125,
0.03998732194304466,
0.017476823180913925,
0.04062321409583092,
-0.058647934... | 0.12543 |
[[doc-values]] === `doc\_values` Most fields are <> by default, which makes them searchable. The inverted index allows queries to look up the search term in unique sorted list of terms, and from that immediately have access to the list of documents that contain the term. Sorting, aggregations, and access to field value... | https://github.com/elastic/elasticsearch/blob/6.2//docs/reference/mapping/params/doc-values.asciidoc | 6.2 | elasticsearch-6-2 | [
-0.05940098688006401,
0.07177132368087769,
0.0067201233468949795,
0.08486989885568619,
0.030619598925113678,
-0.012712589465081692,
-0.0005940300761722028,
0.05459748953580856,
0.1280180811882019,
0.041890013962984085,
-0.006622690707445145,
0.12345530092716217,
0.04061255604028702,
-0.080... | 0.063801 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.