Remove support for stored fields.

Author: jtibshirani

docs/reference/mapping/types/embedded-json.asciidoc

@@ -113,25 +113,8 @@ keyword-style aggregations such as `terms`. As with queries, there is no
 special support for numerics -- all values in the JSON object are treated as
 keywords. When sorting, this implies that values are compared lexicographically.
 
-[[stored-fields]]
-==== Stored fields
-
-If the <<mapping-store,`store`>> option is enabled, the entire JSON object will
-be stored in pretty-printed format. It can be retrieved through the top-level
-`embedded_json` field:
-
-[source,js]
---------------------------------
-POST bug_reports/_search
-{
-  "query": { "match": { "title": "results not sorted" }},
-  "stored_fields": ["labels"]
-}
---------------------------------
-// CONSOLE
-
-Field keys cannot be used to load stored content. For example, specifying
-`"stored_fields": ["labels.timestamp"]` will return an empty list.
+Embedded JSON fields currently cannot be stored. It is not possible to specify
+the <<mapping-store, `store`>> parameter in the mapping.
 
 [[json-params]]
 ==== Parameters for JSON fields

server/src/main/java/org/elasticsearch/index/mapper/JsonFieldMapper.java

@@ -20,7 +20,6 @@
 package org.elasticsearch.index.mapper;
 
 import org.apache.lucene.analysis.core.WhitespaceAnalyzer;
-import org.apache.lucene.document.StoredField;
 import org.apache.lucene.index.DirectoryReader;
 import org.apache.lucene.index.IndexOptions;
 import org.apache.lucene.index.IndexableField;
@@ -34,14 +33,11 @@
 import org.apache.lucene.search.SortField;
 import org.apache.lucene.search.TermQuery;
 import org.apache.lucene.util.BytesRef;
-import org.elasticsearch.common.bytes.BytesReference;
 import org.elasticsearch.common.lucene.Lucene;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.unit.Fuzziness;
 import org.elasticsearch.common.xcontent.XContentBuilder;
-import org.elasticsearch.common.xcontent.XContentFactory;
 import org.elasticsearch.common.xcontent.XContentParser;
-import org.elasticsearch.common.xcontent.json.JsonXContent;
 import org.elasticsearch.common.xcontent.support.XContentMapValues;
 import org.elasticsearch.index.Index;
 import org.elasticsearch.index.IndexSettings;
@@ -90,9 +86,6 @@
  * the mapper will produce untokenized string fields called "json_field" with values "some value" and "true",
  * as well as string fields called "json_field._keyed" with values "key\0some value" and "key2.key3\0true".
  * Note that \0 is used as a reserved separator character (see {@link JsonFieldParser#SEPARATOR}).
- *
- * When 'store' is enabled, a single stored field is added containing the entire JSON object in
- * pretty-printed format.
  */
 public final class JsonFieldMapper extends FieldMapper {
 
@@ -175,6 +168,11 @@ public Builder copyTo(CopyTo copyTo) {
             throw new UnsupportedOperationException("[copy_to] is not supported for [" + CONTENT_TYPE + "] fields.");
         }
 
+        @Override
+        public Builder store(boolean store) {
+            throw new UnsupportedOperationException("[store] is not supported for [" + CONTENT_TYPE + "] fields.");
+        }
+
         @Override
         public JsonFieldMapper build(BuilderContext context) {
             setupFieldType(context);
@@ -579,34 +577,13 @@ protected void parseCreateField(ParseContext context, List<IndexableField> field
             return;
         }
 
-        if (fieldType.indexOptions() == IndexOptions.NONE
-                && !fieldType.hasDocValues()
-                && !fieldType.stored()) {
+        if (fieldType.indexOptions() == IndexOptions.NONE && !fieldType.hasDocValues()) {
             context.parser().skipChildren();
             return;
         }
 
-        BytesRef storedValue = null;
-        if (fieldType.stored()) {
-            XContentBuilder builder = XContentFactory.jsonBuilder()
-                .prettyPrint()
-                .copyCurrentStructure(context.parser());
-            storedValue = BytesReference.bytes(builder).toBytesRef();
-            fields.add(new StoredField(fieldType.name(), storedValue));
-        }
-
-        XContentParser indexedFieldsParser = context.parser();
-
-        // If store is enabled, we've already consumed the content to produce the stored field. Here we
-        // 'reset' the parser, so that we can traverse the content again.
-        if (storedValue != null) {
-            indexedFieldsParser = JsonXContent.jsonXContent.createParser(context.parser().getXContentRegistry(),
-                context.parser().getDeprecationHandler(),
-                storedValue.bytes);
-            indexedFieldsParser.nextToken();
-        }
-
-        fields.addAll(fieldParser.parse(indexedFieldsParser));
+        XContentParser xContentParser = context.parser();
+        fields.addAll(fieldParser.parse(xContentParser));
 
         if (!fieldType.hasDocValues()) {
             createFieldNamesField(context, fields);

server/src/test/java/org/elasticsearch/index/mapper/JsonFieldMapperTests.java

@@ -186,54 +186,16 @@ public void testEnableStore() throws Exception {
         String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
             .startObject("type")
                 .startObject("properties")
-                    .startObject("store")
-                        .field("type", "embedded_json")
-                        .field("store", true)
-                    .endObject()
-                    .startObject("store_only")
+                    .startObject("field")
                         .field("type", "embedded_json")
-                        .field("index", false)
                         .field("store", true)
-                        .field("doc_values", false)
                     .endObject()
                 .endObject()
             .endObject()
         .endObject());
 
-        DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
-        assertEquals(mapping, mapper.mappingSource().toString());
-
-        BytesReference doc = BytesReference.bytes(XContentFactory.jsonBuilder().startObject()
-                .startObject("store")
-                    .field("key", "value")
-                .endObject()
-                .startObject("store_only")
-                    .field("key", "value")
-                .endObject()
-            .endObject());
-        ParsedDocument parsedDoc = mapper.parse(new SourceToParse("test", "type", "1", doc, XContentType.JSON));
-
-        // We make sure to pretty-print here, since the field is always stored in pretty-printed format.
-        BytesReference storedValue = BytesReference.bytes(JsonXContent.contentBuilder()
-            .prettyPrint()
-            .startObject()
-                .field("key", "value")
-            .endObject());
-
-        IndexableField[] store = parsedDoc.rootDoc().getFields("store");
-        assertEquals(3, store.length);
-
-        assertTrue(store[0].fieldType().stored());
-        assertEquals(storedValue.toBytesRef(), store[0].binaryValue());
-        assertFalse(store[1].fieldType().stored());
-        assertFalse(store[2].fieldType().stored());
-        assertEquals(DocValuesType.SORTED_SET, store[2].fieldType().docValuesType());
-
-        IndexableField[] storeOnly = parsedDoc.rootDoc().getFields("store_only");
-        assertEquals(1, storeOnly.length);
-
-        assertTrue(storeOnly[0].fieldType().stored());
-        assertEquals(storedValue.toBytesRef(), storeOnly[0].binaryValue());
+        expectThrows(UnsupportedOperationException.class, () ->
+            parser.parse("type", new CompressedXContent(mapping)));
     }
 
     public void testIndexOptions() throws IOException {

server/src/test/java/org/elasticsearch/search/fields/SearchFieldsIT.java

@@ -1227,51 +1227,6 @@ public void testLoadMetadata() throws Exception {
         assertThat(fields.get("_routing").getValue().toString(), equalTo("1"));
     }
 
-    public void testJsonStoredFields() throws Exception {
-        XContentBuilder mapping = XContentFactory.jsonBuilder()
-            .startObject()
-                .startObject("_doc")
-                    .startObject("properties")
-                        .startObject("json_field")
-                            .field("type", "embedded_json")
-                            .field("store", true)
-                        .endObject()
-                    .endObject()
-                .endObject()
-            .endObject();
-        assertAcked(prepareCreate("test").addMapping("_doc", mapping));
-        ensureGreen("test");
-
-        XContentBuilder source = XContentFactory.jsonBuilder()
-            .startObject()
-                .startObject("json_field")
-                    .field("key", "value")
-                .endObject()
-            .endObject();
-        index("test", "_doc", "1", source);
-        refresh("test");
-
-        SearchResponse response = client().prepareSearch("test")
-            .addStoredField("json_field")
-            .addStoredField("json_field.key")
-            .get();
-        assertSearchResponse(response);
-        assertHitCount(response, 1);
-
-        Map<String, DocumentField> fields = response.getHits().getAt(0).getFields();
-        DocumentField field = fields.get("json_field");
-        assertEquals("json_field", field.getName());
-        assertFalse(fields.containsKey("json_field.key"));
-
-        // We make sure to pretty-print here, since the field is always stored in pretty-printed format.
-        BytesReference storedValue = BytesReference.bytes(XContentFactory.jsonBuilder()
-            .prettyPrint()
-            .startObject()
-                .field("key", "value")
-            .endObject());
-        assertEquals(storedValue.utf8ToString(), field.getValue());
-    }
-
      public void testJsonDocValuesFields() throws Exception {
         XContentBuilder mapping = XContentFactory.jsonBuilder()
             .startObject()