Example usage for org.apache.lucene.index IndexableFieldType indexOptions

List of usage examples for org.apache.lucene.index IndexableFieldType indexOptions

  1. HOME
  2. Java
  3. org.apache.lucene
  4. org.apache.lucene.index.*
  5. IndexableFieldType
  6. indexOptions

Introduction

In this page you can find the example usage for org.apache.lucene.index IndexableFieldType indexOptions.

Prototype

public IndexOptions indexOptions();

Source Link

Document

IndexOptions , describing what should be recorded into the inverted index

Usage

From source file:org.elasticsearch.index.mapper.core.KeywordFieldMapperTests.java

License:Apache License

public void testDefaults() throws Exception {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type").startObject("properties")
            .startObject("field").field("type", "keyword").endObject().endObject().endObject().endObject()
            .string();/*from   w w w.j  a  v  a 2 s.  c o  m*/

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper.mappingSource().toString());

    ParsedDocument doc = mapper.parse("test", "type", "1",
            XContentFactory.jsonBuilder().startObject().field("field", "1234").endObject().bytes());

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(2, fields.length);

    assertEquals("1234", fields[0].stringValue());
    IndexableFieldType fieldType = fields[0].fieldType();
    assertThat(fieldType.omitNorms(), equalTo(true));
    assertFalse(fieldType.tokenized());
    assertFalse(fieldType.stored());
    assertThat(fieldType.indexOptions(), equalTo(IndexOptions.DOCS));
    assertThat(fieldType.storeTermVectors(), equalTo(false));
    assertThat(fieldType.storeTermVectorOffsets(), equalTo(false));
    assertThat(fieldType.storeTermVectorPositions(), equalTo(false));
    assertThat(fieldType.storeTermVectorPayloads(), equalTo(false));
    assertEquals(DocValuesType.NONE, fieldType.docValuesType());

    assertEquals(new BytesRef("1234"), fields[1].binaryValue());
    fieldType = fields[1].fieldType();
    assertThat(fieldType.indexOptions(), equalTo(IndexOptions.NONE));
    assertEquals(DocValuesType.SORTED_SET, fieldType.docValuesType());
}

From source file:org.elasticsearch.index.mapper.core.TextFieldMapperTests.java

License:Apache License

public void testDefaults() throws Exception {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type").startObject("properties")
            .startObject("field").field("type", "text").endObject().endObject().endObject().endObject()
            .string();/*from   w w  w.  j a  va 2  s  . c  o  m*/

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper.mappingSource().toString());

    ParsedDocument doc = mapper.parse("test", "type", "1",
            XContentFactory.jsonBuilder().startObject().field("field", "1234").endObject().bytes());

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(1, fields.length);

    assertEquals("1234", fields[0].stringValue());
    IndexableFieldType fieldType = fields[0].fieldType();
    assertThat(fieldType.omitNorms(), equalTo(false));
    assertTrue(fieldType.tokenized());
    assertFalse(fieldType.stored());
    assertThat(fieldType.indexOptions(), equalTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS));
    assertThat(fieldType.storeTermVectors(), equalTo(false));
    assertThat(fieldType.storeTermVectorOffsets(), equalTo(false));
    assertThat(fieldType.storeTermVectorPositions(), equalTo(false));
    assertThat(fieldType.storeTermVectorPayloads(), equalTo(false));
    assertEquals(DocValuesType.NONE, fieldType.docValuesType());
}

From source file:org.elasticsearch.index.mapper.ICUCollationKeywordFieldMapperTests.java

License:Apache License

public void testDefaults() throws Exception {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type").startObject("properties")
            .startObject("field").field("type", FIELD_TYPE).endObject().endObject().endObject().endObject()
            .string();/*w  ww .ja va  2  s  . co  m*/

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper.mappingSource().toString());

    ParsedDocument doc = mapper.parse(SourceToParse.source("test", "type", "1",
            XContentFactory.jsonBuilder().startObject().field("field", "1234").endObject().bytes(),
            XContentType.JSON));

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(2, fields.length);

    Collator collator = Collator.getInstance(ULocale.ROOT);
    RawCollationKey key = collator.getRawCollationKey("1234", null);
    BytesRef expected = new BytesRef(key.bytes, 0, key.size);

    assertEquals(expected, fields[0].binaryValue());
    IndexableFieldType fieldType = fields[0].fieldType();
    assertThat(fieldType.omitNorms(), equalTo(true));
    assertFalse(fieldType.tokenized());
    assertFalse(fieldType.stored());
    assertThat(fieldType.indexOptions(), equalTo(IndexOptions.DOCS));
    assertThat(fieldType.storeTermVectors(), equalTo(false));
    assertThat(fieldType.storeTermVectorOffsets(), equalTo(false));
    assertThat(fieldType.storeTermVectorPositions(), equalTo(false));
    assertThat(fieldType.storeTermVectorPayloads(), equalTo(false));
    assertEquals(DocValuesType.NONE, fieldType.docValuesType());

    assertEquals(expected, fields[1].binaryValue());
    fieldType = fields[1].fieldType();
    assertThat(fieldType.indexOptions(), equalTo(IndexOptions.NONE));
    assertEquals(DocValuesType.SORTED_SET, fieldType.docValuesType());
}

From source file:org.elasticsearch.index.mapper.ICUCollationKeywordFieldMapperTests.java

License:Apache License

public void testBackCompat() throws Exception {
    indexService = createIndex("oldindex",
            Settings.builder().put("index.version.created", Version.V_5_5_0).build());
    parser = indexService.mapperService().documentMapperParser();

    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type").startObject("properties")
            .startObject("field").field("type", FIELD_TYPE).endObject().endObject().endObject().endObject()
            .string();/*from  w  w  w .  j  av  a 2  s.  c  o  m*/

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper.mappingSource().toString());

    ParsedDocument doc = mapper.parse(SourceToParse.source("oldindex", "type", "1",
            XContentFactory.jsonBuilder().startObject().field("field", "1234").endObject().bytes(),
            XContentType.JSON));

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(2, fields.length);

    Collator collator = Collator.getInstance(ULocale.ROOT);
    RawCollationKey key = collator.getRawCollationKey("1234", null);
    BytesRef expected = new BytesRef(key.bytes, 0, key.size);

    assertEquals(expected, fields[0].binaryValue());
    IndexableFieldType fieldType = fields[0].fieldType();
    assertThat(fieldType.omitNorms(), equalTo(true));
    assertFalse(fieldType.tokenized());
    assertFalse(fieldType.stored());
    assertThat(fieldType.indexOptions(), equalTo(IndexOptions.DOCS));
    assertThat(fieldType.storeTermVectors(), equalTo(false));
    assertThat(fieldType.storeTermVectorOffsets(), equalTo(false));
    assertThat(fieldType.storeTermVectorPositions(), equalTo(false));
    assertThat(fieldType.storeTermVectorPayloads(), equalTo(false));
    assertEquals(DocValuesType.NONE, fieldType.docValuesType());

    assertEquals(expected, fields[1].binaryValue());
    fieldType = fields[1].fieldType();
    assertThat(fieldType.indexOptions(), equalTo(IndexOptions.NONE));
    assertEquals(DocValuesType.SORTED, fieldType.docValuesType());
}

From source file:org.elasticsearch.index.mapper.ICUCollationKeywordFieldMapperTests.java

License:Apache License

public void testMultipleValues() throws IOException {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type").startObject("properties")
            .startObject("field").field("type", FIELD_TYPE).endObject().endObject().endObject().endObject()
            .string();//from   ww w .  j  a v  a  2 s .  c o m

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper.mappingSource().toString());

    ParsedDocument doc = mapper
            .parse(SourceToParse.source(
                    "test", "type", "1", XContentFactory.jsonBuilder().startObject()
                            .field("field", Arrays.asList("1234", "5678")).endObject().bytes(),
                    XContentType.JSON));

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(4, fields.length);

    Collator collator = Collator.getInstance(ULocale.ROOT);
    RawCollationKey key = collator.getRawCollationKey("1234", null);
    BytesRef expected = new BytesRef(key.bytes, 0, key.size);

    assertEquals(expected, fields[0].binaryValue());
    IndexableFieldType fieldType = fields[0].fieldType();
    assertThat(fieldType.omitNorms(), equalTo(true));
    assertFalse(fieldType.tokenized());
    assertFalse(fieldType.stored());
    assertThat(fieldType.indexOptions(), equalTo(IndexOptions.DOCS));
    assertThat(fieldType.storeTermVectors(), equalTo(false));
    assertThat(fieldType.storeTermVectorOffsets(), equalTo(false));
    assertThat(fieldType.storeTermVectorPositions(), equalTo(false));
    assertThat(fieldType.storeTermVectorPayloads(), equalTo(false));
    assertEquals(DocValuesType.NONE, fieldType.docValuesType());

    assertEquals(expected, fields[1].binaryValue());
    fieldType = fields[1].fieldType();
    assertThat(fieldType.indexOptions(), equalTo(IndexOptions.NONE));
    assertEquals(DocValuesType.SORTED_SET, fieldType.docValuesType());

    collator = Collator.getInstance(ULocale.ROOT);
    key = collator.getRawCollationKey("5678", null);
    expected = new BytesRef(key.bytes, 0, key.size);

    assertEquals(expected, fields[2].binaryValue());
    fieldType = fields[2].fieldType();
    assertThat(fieldType.omitNorms(), equalTo(true));
    assertFalse(fieldType.tokenized());
    assertFalse(fieldType.stored());
    assertThat(fieldType.indexOptions(), equalTo(IndexOptions.DOCS));
    assertThat(fieldType.storeTermVectors(), equalTo(false));
    assertThat(fieldType.storeTermVectorOffsets(), equalTo(false));
    assertThat(fieldType.storeTermVectorPositions(), equalTo(false));
    assertThat(fieldType.storeTermVectorPayloads(), equalTo(false));
    assertEquals(DocValuesType.NONE, fieldType.docValuesType());

    assertEquals(expected, fields[3].binaryValue());
    fieldType = fields[3].fieldType();
    assertThat(fieldType.indexOptions(), equalTo(IndexOptions.NONE));
    assertEquals(DocValuesType.SORTED_SET, fieldType.docValuesType());
}

From source file:org.elasticsearch.index.mapper.ICUCollationKeywordFieldMapperTests.java

License:Apache License

public void testCollator() throws IOException {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type").startObject("properties")
            .startObject("field").field("type", FIELD_TYPE).field("language", "tr").field("strength", "primary")
            .endObject().endObject().endObject().endObject().string();

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper.mappingSource().toString());

    ParsedDocument doc = mapper//from w w  w .j  a v a 2s . c o m
            .parse(SourceToParse.source(
                    "test", "type", "1", XContentFactory.jsonBuilder().startObject()
                            .field("field", "I WLL USE TURKSH CASING").endObject().bytes(),
                    XContentType.JSON));

    Collator collator = Collator.getInstance(new ULocale("tr"));
    collator.setStrength(Collator.PRIMARY);
    RawCollationKey key = collator.getRawCollationKey(" will use turkish casng", null); // should collate to same value
    BytesRef expected = new BytesRef(key.bytes, 0, key.size);

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(2, fields.length);

    assertEquals(expected, fields[0].binaryValue());
    IndexableFieldType fieldType = fields[0].fieldType();
    assertThat(fieldType.omitNorms(), equalTo(true));
    assertFalse(fieldType.tokenized());
    assertFalse(fieldType.stored());
    assertThat(fieldType.indexOptions(), equalTo(IndexOptions.DOCS));
    assertThat(fieldType.storeTermVectors(), equalTo(false));
    assertThat(fieldType.storeTermVectorOffsets(), equalTo(false));
    assertThat(fieldType.storeTermVectorPositions(), equalTo(false));
    assertThat(fieldType.storeTermVectorPayloads(), equalTo(false));
    assertEquals(DocValuesType.NONE, fieldType.docValuesType());

    assertEquals(expected, fields[1].binaryValue());
    fieldType = fields[1].fieldType();
    assertThat(fieldType.indexOptions(), equalTo(IndexOptions.NONE));
    assertEquals(DocValuesType.SORTED_SET, fieldType.docValuesType());
}

From source file:org.elasticsearch.index.mapper.KeywordFieldMapperTests.java

License:Apache License

public void testDefaults() throws Exception {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type").startObject("properties")
            .startObject("field").field("type", "keyword").endObject().endObject().endObject().endObject()
            .string();// w  ww  . j  a v  a2 s  .  co  m

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper.mappingSource().toString());

    ParsedDocument doc = mapper.parse("test", "type", "1",
            XContentFactory.jsonBuilder().startObject().field("field", "1234").endObject().bytes());

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(2, fields.length);

    assertEquals(new BytesRef("1234"), fields[0].binaryValue());
    IndexableFieldType fieldType = fields[0].fieldType();
    assertThat(fieldType.omitNorms(), equalTo(true));
    assertFalse(fieldType.tokenized());
    assertFalse(fieldType.stored());
    assertThat(fieldType.indexOptions(), equalTo(IndexOptions.DOCS));
    assertThat(fieldType.storeTermVectors(), equalTo(false));
    assertThat(fieldType.storeTermVectorOffsets(), equalTo(false));
    assertThat(fieldType.storeTermVectorPositions(), equalTo(false));
    assertThat(fieldType.storeTermVectorPayloads(), equalTo(false));
    assertEquals(DocValuesType.NONE, fieldType.docValuesType());

    assertEquals(new BytesRef("1234"), fields[1].binaryValue());
    fieldType = fields[1].fieldType();
    assertThat(fieldType.indexOptions(), equalTo(IndexOptions.NONE));
    assertEquals(DocValuesType.SORTED_SET, fieldType.docValuesType());
}

From source file:org.elasticsearch.index.mapper.LegacyStringMappingTests.java

License:Apache License

private void assertDefaultAnalyzedFieldType(IndexableFieldType fieldType) {
    assertThat(fieldType.omitNorms(), equalTo(false));
    assertThat(fieldType.indexOptions(), equalTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS));
    assertThat(fieldType.storeTermVectors(), equalTo(false));
    assertThat(fieldType.storeTermVectorOffsets(), equalTo(false));
    assertThat(fieldType.storeTermVectorPositions(), equalTo(false));
    assertThat(fieldType.storeTermVectorPayloads(), equalTo(false));
}

From source file:org.elasticsearch.index.mapper.LegacyStringMappingTests.java

License:Apache License

private void assertEquals(IndexableFieldType ft1, IndexableFieldType ft2) {
    assertEquals(ft1.tokenized(), ft2.tokenized());
    assertEquals(ft1.omitNorms(), ft2.omitNorms());
    assertEquals(ft1.indexOptions(), ft2.indexOptions());
    assertEquals(ft1.storeTermVectors(), ft2.storeTermVectors());
    assertEquals(ft1.docValuesType(), ft2.docValuesType());
}

From source file:org.elasticsearch.index.mapper.LegacyStringMappingTests.java

License:Apache License

public void testDefaultsForNotAnalyzed() throws Exception {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type").startObject("properties")
            .startObject("field").field("type", "string").field("index", "not_analyzed").endObject().endObject()
            .endObject().endObject().string();

    DocumentMapper defaultMapper = parser.parse("type", new CompressedXContent(mapping));

    ParsedDocument doc = defaultMapper.parse("test", "type", "1",
            XContentFactory.jsonBuilder().startObject().field("field", "1234").endObject().bytes());

    IndexableFieldType fieldType = doc.rootDoc().getField("field").fieldType();
    assertThat(fieldType.omitNorms(), equalTo(true));
    assertThat(fieldType.indexOptions(), equalTo(IndexOptions.DOCS));
    assertThat(fieldType.storeTermVectors(), equalTo(false));
    assertThat(fieldType.storeTermVectorOffsets(), equalTo(false));
    assertThat(fieldType.storeTermVectorPositions(), equalTo(false));
    assertThat(fieldType.storeTermVectorPayloads(), equalTo(false));
    assertParseIdemPotent(fieldType, defaultMapper);

    // now test it explicitly set

    mapping = XContentFactory.jsonBuilder().startObject().startObject("type").startObject("properties")
            .startObject("field").field("type", "string").field("index", "not_analyzed").startObject("norms")
            .field("enabled", true).endObject().field("index_options", "freqs").endObject().endObject()
            .endObject().endObject().string();

    defaultMapper = parser.parse("type", new CompressedXContent(mapping));

    doc = defaultMapper.parse("test", "type", "1",
            XContentFactory.jsonBuilder().startObject().field("field", "1234").endObject().bytes());

    fieldType = doc.rootDoc().getField("field").fieldType();
    assertThat(fieldType.omitNorms(), equalTo(false));
    assertThat(fieldType.indexOptions(), equalTo(IndexOptions.DOCS_AND_FREQS));
    assertThat(fieldType.storeTermVectors(), equalTo(false));
    assertThat(fieldType.storeTermVectorOffsets(), equalTo(false));
    assertThat(fieldType.storeTermVectorPositions(), equalTo(false));
    assertThat(fieldType.storeTermVectorPayloads(), equalTo(false));
    assertParseIdemPotent(fieldType, defaultMapper);

    // also test the deprecated omit_norms

    mapping = XContentFactory.jsonBuilder().startObject().startObject("type").startObject("properties")
            .startObject("field").field("type", "string").field("index", "not_analyzed")
            .field("omit_norms", false).endObject().endObject().endObject().endObject().string();

    defaultMapper = parser.parse("type", new CompressedXContent(mapping));

    doc = defaultMapper.parse("test", "type", "1",
            XContentFactory.jsonBuilder().startObject().field("field", "1234").endObject().bytes());

    fieldType = doc.rootDoc().getField("field").fieldType();
    assertThat(fieldType.omitNorms(), equalTo(false));
    assertParseIdemPotent(fieldType, defaultMapper);
}