1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
/**
* Copyright 2010-2013 Ben Birch
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this software except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
(function( app ) {
/*
notes on elasticsearch terminology used in this project
indices[index] contains one or more
types[type] contains one or more
documents contain one or more
paths[path]
each path contains one element of data
each path maps to one field
eg PUT, "/twitter/tweet/1"
{
user: "mobz",
date: "2011-01-01",
message: "You know, for browsing elasticsearch",
name: {
first: "Ben",
last: "Birch"
}
}
creates
1 index: twitter
this is the collection of index data
1 type: tweet
this is the type of document (kind of like a table in sql)
1 document: /twitter/tweet/1
this is an actual document in the index ( kind of like a row in sql)
5 paths: [ ["user"], ["date"], ["message"], ["name","first"], ["name","last"] ]
since documents can be heirarchical this maps a path from a document root to a piece of data
5 fields: [ "user", "date", "message", "first", "last" ]
this is an indexed 'column' of data. fields are not heirarchical
the relationship between a path and a field is called a mapping. mappings also contain a wealth of information about how es indexes the field
notes
1) a path is stored as an array, the dpath is <index> . <type> . path.join("."),
which can be considered the canonical reference for a mapping
2) confusingly, es uses the term index for both the collection of indexed data, and the individually indexed fields
so the term index_name is the same as field_name in this sense.
*/
var data = app.ns("data");
var ux = app.ns("ux");
var coretype_map = {
"string" : "string",
"keyword" : "string",
"text" : "string",
"byte" : "number",
"short" : "number",
"long" : "number",
"integer" : "number",
"float" : "number",
"double" : "number",
"ip" : "number",
"date" : "date",
"boolean" : "boolean",
"binary" : "binary",
"multi_field" : "multi_field"
};
var default_property_map = {
"string" : { "store" : "no", "index" : "analysed" },
"number" : { "store" : "no", "precision_steps" : 4 },
"date" : { "store" : "no", "format" : "dateOptionalTime", "index": "yes", "precision_steps": 4 },
"boolean" : { "store" : "no", "index": "yes" },
"binary" : { },
"multi_field" : { }
};
// parses metatdata from a cluster, into a bunch of useful data structures
data.MetaData = ux.Observable.extend({
defaults: {
state: null // (required) response from a /_cluster/state request
},
init: function() {
this._super();
this.refresh(this.config.state);
},
getIndices: function(alias) {
return alias ? this.aliases[alias] : this.indicesList;
},
// returns an array of strings containing all types that are in all of the indices passed in, or all types
getTypes: function(indices) {
var indices = indices || [], types = [];
this.typesList.forEach(function(type) {
for(var i = 0; i < indices.length; i++) {
if(! this.indices[indices[i]].types.contains(type))
return;
}
types.push(type);
}, this);
return types;
},
refresh: function(state) {
// currently metadata expects all like named fields to have the same type, even when from different types and indices
var aliases = this.aliases = {};
var indices = this.indices = {};
var types = this.types = {};
var fields = this.fields = {};
var paths = this.paths = {};
function createField( mapping, index, type, path, name ) {
var dpath = [ index, type ].concat( path ).join( "." );
var field_name = mapping.index_name || path.join( "." );
var field = paths[ dpath ] = fields[ field_name ] || $.extend({
field_name : field_name,
core_type : coretype_map[ mapping.type ],
dpaths : []
}, default_property_map[ coretype_map[ mapping.type ] ], mapping );
if (field.type === "multi_field" && typeof field.fields !== "undefined") {
for (var subField in field.fields) {
field.fields[ subField ] = createField( field.fields[ subField ], index, type, path.concat( subField ), name + "." + subField );
}
}
if (fields.dpaths) {
field.dpaths.push(dpath);
}
return field;
}
function getFields(properties, type, index, listeners) {
(function procPath(prop, path) {
for (var n in prop) {
if ("properties" in prop[n]) {
procPath( prop[ n ].properties, path.concat( n ) );
} else {
var field = createField(prop[n], index, type, path.concat(n), n);
listeners.forEach( function( listener ) {
listener[ field.field_name ] = field;
} );
}
}
})(properties, []);
}
for (var index in state.metadata.indices) {
indices[index] = {
types : [], fields : {}, paths : {}, parents : {}
};
indices[index].aliases = state.metadata.indices[index].aliases;
indices[index].aliases.forEach(function(alias) {
(aliases[alias] || (aliases[alias] = [])).push(index);
});
var mapping = state.metadata.indices[index].mappings;
for (var type in mapping) {
indices[index].types.push(type);
if ( type in types) {
types[type].indices.push(index);
} else {
types[type] = {
indices : [index], fields : {}
};
}
getFields(mapping[type].properties, type, index, [fields, types[type].fields, indices[index].fields]);
if ( typeof mapping[type]._parent !== "undefined") {
indices[index].parents[type] = mapping[type]._parent.type;
}
}
}
this.aliasesList = Object.keys(aliases);
this.indicesList = Object.keys(indices);
this.typesList = Object.keys(types);
this.fieldsList = Object.keys(fields);
}
});
})( this.app );
|
