Example #1
0
  @Override
  public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
    if (indexCreatedBefore2x == false) {
      return builder;
    }
    boolean includeDefaults = params.paramAsBoolean("include_defaults", false);

    // if all are defaults, no sense to write it at all
    if (!includeDefaults
        && fieldType().stored() == Defaults.FIELD_TYPE.stored()
        && fieldType().indexOptions() == Defaults.FIELD_TYPE.indexOptions()
        && path == Defaults.PATH
        && hasCustomFieldDataSettings() == false) {
      return builder;
    }
    builder.startObject(CONTENT_TYPE);
    if (includeDefaults || fieldType().stored() != Defaults.FIELD_TYPE.stored()) {
      builder.field("store", fieldType().stored());
    }
    if (includeDefaults || fieldType().indexOptions() != Defaults.FIELD_TYPE.indexOptions()) {
      builder.field(
          "index",
          indexTokenizeOptionToString(
              fieldType().indexOptions() != IndexOptions.NONE, fieldType().tokenized()));
    }
    if (includeDefaults || path != Defaults.PATH) {
      builder.field("path", path);
    }

    if (includeDefaults || hasCustomFieldDataSettings()) {
      builder.field("fielddata", (Map) fieldType().fieldDataType().getSettings().getAsMap());
    }
    builder.endObject();
    return builder;
  }
  @Override
  public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
    boolean includeDefaults = params.paramAsBoolean("include_defaults", false);

    // if all are defaults, no sense to write it at all
    boolean indexed = fieldType.indexOptions() != IndexOptions.NONE;
    boolean indexedDefault = Defaults.FIELD_TYPE.indexOptions() != IndexOptions.NONE;
    if (!includeDefaults
        && indexed == indexedDefault
        && fieldType.stored() == Defaults.FIELD_TYPE.stored()
        && required == Defaults.REQUIRED
        && path == Defaults.PATH) {
      return builder;
    }
    builder.startObject(CONTENT_TYPE);
    if (indexCreatedBefore2x && (includeDefaults || indexed != indexedDefault)) {
      builder.field("index", indexTokenizeOptionToString(indexed, fieldType.tokenized()));
    }
    if (indexCreatedBefore2x
        && (includeDefaults || fieldType.stored() != Defaults.FIELD_TYPE.stored())) {
      builder.field("store", fieldType.stored());
    }
    if (includeDefaults || required != Defaults.REQUIRED) {
      builder.field("required", required);
    }
    if (indexCreatedBefore2x && (includeDefaults || path != Defaults.PATH)) {
      builder.field("path", path);
    }
    builder.endObject();
    return builder;
  }
 private ParentFieldMapper(Settings indexSettings, MappedFieldType existing, String parentType) {
   this(
       existing == null ? Defaults.FIELD_TYPE.clone() : existing.clone(),
       joinFieldTypeForParentType(parentType, indexSettings),
       null,
       null,
       indexSettings);
 }
Example #4
0
 private static MappedFieldType idFieldType(Settings indexSettings, MappedFieldType existing) {
   if (existing != null) {
     return existing.clone();
   }
   MappedFieldType fieldType = Defaults.FIELD_TYPE.clone();
   boolean pre2x = Version.indexCreated(indexSettings).before(Version.V_2_0_0_beta1);
   if (pre2x && indexSettings.getAsBoolean("index.mapping._id.indexed", true) == false) {
     fieldType.setTokenized(false);
   }
   return fieldType;
 }
 private static MappedFieldType defaultFieldType(Settings indexSettings) {
   MappedFieldType defaultFieldType = Defaults.FIELD_TYPE.clone();
   Version indexCreated = Version.indexCreated(indexSettings);
   if (indexCreated.before(Version.V_2_1_0)) {
     // enables fielddata loading, doc values was disabled on _type between 2.0 and 2.1.
     ((TypeFieldType) defaultFieldType).setFielddata(true);
   } else {
     defaultFieldType.setHasDocValues(true);
   }
   return defaultFieldType;
 }
  @Override
  public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
    boolean includeDefaults = params.paramAsBoolean("include_defaults", false);

    // if all are defaults, no sense to write it at all
    if (!includeDefaults
        && fieldType.stored() == Defaults.FIELD_TYPE.stored()
        && fieldType.indexed() == Defaults.FIELD_TYPE.indexed()) {
      return builder;
    }
    builder.startObject(CONTENT_TYPE);
    if (includeDefaults || fieldType.stored() != Defaults.FIELD_TYPE.stored()) {
      builder.field("store", fieldType.stored());
    }
    if (includeDefaults || fieldType.indexed() != Defaults.FIELD_TYPE.indexed()) {
      builder.field(
          "index", indexTokenizeOptionToString(fieldType.indexed(), fieldType.tokenized()));
    }
    builder.endObject();
    return builder;
  }
 private FieldNamesFieldMapper(Settings indexSettings, MappedFieldType existing) {
   this(existing == null ? Defaults.FIELD_TYPE.clone() : existing.clone(), indexSettings);
 }
 public FieldNamesFieldMapper(Settings indexSettings) {
   this(Defaults.FIELD_TYPE.clone(), null, indexSettings);
 }
  private void innerToXContent(XContentBuilder builder, boolean includeDefaults)
      throws IOException {
    if (includeDefaults || enabled != Defaults.ENABLED) {
      builder.field("enabled", enabled);
    }
    if (includeDefaults || autoBoost != false) {
      builder.field("auto_boost", autoBoost);
    }
    if (includeDefaults || fieldType.stored() != Defaults.FIELD_TYPE.stored()) {
      builder.field("store", fieldType.stored());
    }
    if (includeDefaults || fieldType.storeTermVectors() != Defaults.FIELD_TYPE.storeTermVectors()) {
      builder.field("store_term_vectors", fieldType.storeTermVectors());
    }
    if (includeDefaults
        || fieldType.storeTermVectorOffsets() != Defaults.FIELD_TYPE.storeTermVectorOffsets()) {
      builder.field("store_term_vector_offsets", fieldType.storeTermVectorOffsets());
    }
    if (includeDefaults
        || fieldType.storeTermVectorPositions() != Defaults.FIELD_TYPE.storeTermVectorPositions()) {
      builder.field("store_term_vector_positions", fieldType.storeTermVectorPositions());
    }
    if (includeDefaults
        || fieldType.storeTermVectorPayloads() != Defaults.FIELD_TYPE.storeTermVectorPayloads()) {
      builder.field("store_term_vector_payloads", fieldType.storeTermVectorPayloads());
    }
    if (includeDefaults || fieldType.omitNorms() != Defaults.FIELD_TYPE.omitNorms()) {
      builder.field("omit_norms", fieldType.omitNorms());
    }

    if (indexAnalyzer == null && searchAnalyzer == null) {
      if (includeDefaults) {
        builder.field("analyzer", "default");
      }
    } else if (indexAnalyzer == null) {
      // searchAnalyzer != null
      if (includeDefaults || !searchAnalyzer.name().startsWith("_")) {
        builder.field("search_analyzer", searchAnalyzer.name());
      }
    } else if (searchAnalyzer == null) {
      // indexAnalyzer != null
      if (includeDefaults || !indexAnalyzer.name().startsWith("_")) {
        builder.field("index_analyzer", indexAnalyzer.name());
      }
    } else if (indexAnalyzer.name().equals(searchAnalyzer.name())) {
      // indexAnalyzer == searchAnalyzer
      if (includeDefaults || !indexAnalyzer.name().startsWith("_")) {
        builder.field("analyzer", indexAnalyzer.name());
      }
    } else {
      // both are there but different
      if (includeDefaults || !indexAnalyzer.name().startsWith("_")) {
        builder.field("index_analyzer", indexAnalyzer.name());
      }
      if (includeDefaults || !searchAnalyzer.name().startsWith("_")) {
        builder.field("search_analyzer", searchAnalyzer.name());
      }
    }

    if (similarity() != null) {
      builder.field("similarity", similarity().name());
    } else if (includeDefaults) {
      builder.field("similarity", SimilarityLookupService.DEFAULT_SIMILARITY);
    }

    if (customFieldDataSettings != null) {
      builder.field("fielddata", (Map) customFieldDataSettings.getAsMap());
    } else if (includeDefaults) {
      builder.field("fielddata", (Map) fieldDataType.getSettings().getAsMap());
    }
  }
Example #10
0
    @Override
    public AttachmentMapper build(BuilderContext context) {
      ContentPath.Type origPathType = context.path().pathType();
      context.path().pathType(pathType);

      FieldMapper contentMapper;
      if (context.indexCreatedVersion().before(Version.V_2_0_0_beta1)) {
        // old behavior, we need the content to be indexed under the attachment field name
        if (contentBuilder instanceof FieldMapper.Builder == false) {
          throw new IllegalStateException("content field for attachment must be a field mapper");
        }
        ((FieldMapper.Builder) contentBuilder).indexName(name);
        contentBuilder.name = name + "." + FieldNames.CONTENT;
        contentMapper = (FieldMapper) contentBuilder.build(context);
        context.path().add(name);
      } else {
        context.path().add(name);
        contentMapper = (FieldMapper) contentBuilder.build(context);
      }

      FieldMapper dateMapper = (FieldMapper) dateBuilder.build(context);
      FieldMapper authorMapper = (FieldMapper) authorBuilder.build(context);
      FieldMapper titleMapper = (FieldMapper) titleBuilder.build(context);
      FieldMapper nameMapper = (FieldMapper) nameBuilder.build(context);
      FieldMapper keywordsMapper = (FieldMapper) keywordsBuilder.build(context);
      FieldMapper contentTypeMapper = (FieldMapper) contentTypeBuilder.build(context);
      FieldMapper contentLength = (FieldMapper) contentLengthBuilder.build(context);
      FieldMapper language = (FieldMapper) languageBuilder.build(context);
      context.path().remove();

      context.path().pathType(origPathType);

      if (defaultIndexedChars == null && context.indexSettings() != null) {
        defaultIndexedChars =
            context.indexSettings().getAsInt("index.mapping.attachment.indexed_chars", 100000);
      }
      if (defaultIndexedChars == null) {
        defaultIndexedChars = 100000;
      }

      if (ignoreErrors == null && context.indexSettings() != null) {
        ignoreErrors =
            context
                .indexSettings()
                .getAsBoolean("index.mapping.attachment.ignore_errors", Boolean.TRUE);
      }
      if (ignoreErrors == null) {
        ignoreErrors = Boolean.TRUE;
      }

      if (langDetect == null && context.indexSettings() != null) {
        langDetect =
            context
                .indexSettings()
                .getAsBoolean("index.mapping.attachment.detect_language", Boolean.FALSE);
      }
      if (langDetect == null) {
        langDetect = Boolean.FALSE;
      }
      MappedFieldType defaultFieldType = Defaults.FIELD_TYPE.clone();
      if (this.fieldType.indexOptions() != IndexOptions.NONE && !this.fieldType.tokenized()) {
        defaultFieldType.setOmitNorms(true);
        defaultFieldType.setIndexOptions(IndexOptions.DOCS);
        if (!this.omitNormsSet && this.fieldType.boost() == 1.0F) {
          this.fieldType.setOmitNorms(true);
        }

        if (!this.indexOptionsSet) {
          this.fieldType.setIndexOptions(IndexOptions.DOCS);
        }
      }

      defaultFieldType.freeze();
      this.setupFieldType(context);
      return new AttachmentMapper(
          name,
          fieldType,
          defaultFieldType,
          pathType,
          defaultIndexedChars,
          ignoreErrors,
          langDetect,
          contentMapper,
          dateMapper,
          titleMapper,
          nameMapper,
          authorMapper,
          keywordsMapper,
          contentTypeMapper,
          contentLength,
          language,
          context.indexSettings(),
          multiFieldsBuilder.build(this, context),
          copyTo);
    }