protected AbstractIndexOrdinalsFieldData( Index index, Settings indexSettings, Names fieldNames, FieldDataType fieldDataType, IndexFieldDataCache cache, CircuitBreakerService breakerService) { super(index, indexSettings, fieldNames, fieldDataType, cache); final Map<String, Settings> groups = fieldDataType.getSettings().getGroups("filter"); frequency = groups.get("frequency"); regex = groups.get("regex"); this.breakerService = breakerService; }
public <IFD extends IndexFieldData<?>> IFD getForField(FieldMapper<?> mapper) { final FieldMapper.Names fieldNames = mapper.names(); final FieldDataType type = mapper.fieldDataType(); final boolean docValues = mapper.hasDocValues(); IndexFieldData<?> fieldData = loadedFieldData.get(fieldNames.indexName()); if (fieldData == null) { synchronized (loadedFieldData) { fieldData = loadedFieldData.get(fieldNames.indexName()); if (fieldData == null) { IndexFieldData.Builder builder = null; String format = type.getFormat(indexSettings); if (format != null && FieldDataType.DOC_VALUES_FORMAT_VALUE.equals(format) && !docValues) { logger.warn( "field [" + fieldNames.fullName() + "] has no doc values, will use default field data format"); format = null; } if (format != null) { builder = buildersByTypeAndFormat.get(Tuple.tuple(type.getType(), format)); if (builder == null) { logger.warn( "failed to find format [" + format + "] for field [" + fieldNames.fullName() + "], will use default"); } } if (builder == null && docValues) { builder = docValuesBuildersByType.get(type.getType()); } if (builder == null) { builder = buildersByType.get(type.getType()); } if (builder == null) { throw new ElasticsearchIllegalArgumentException( "failed to find field data builder for field " + fieldNames.fullName() + ", and type " + type.getType()); } IndexFieldDataCache cache = fieldDataCaches.get(fieldNames.indexName()); if (cache == null) { // we default to node level cache, which in turn defaults to be unbounded // this means changing the node level settings is simple, just set the bounds there String cacheType = type.getSettings().get("cache", indexSettings.get("index.fielddata.cache", "node")); if ("resident".equals(cacheType)) { cache = new IndexFieldDataCache.Resident( indexService, fieldNames, type, indicesFieldDataCacheListener); } else if ("soft".equals(cacheType)) { cache = new IndexFieldDataCache.Soft( indexService, fieldNames, type, indicesFieldDataCacheListener); } else if ("node".equals(cacheType)) { cache = indicesFieldDataCache.buildIndexFieldDataCache( indexService, index, fieldNames, type); } else { throw new ElasticsearchIllegalArgumentException( "cache type not supported [" + cacheType + "] for field [" + fieldNames.fullName() + "]"); } fieldDataCaches.put(fieldNames.indexName(), cache); } GlobalOrdinalsBuilder globalOrdinalBuilder = new InternalGlobalOrdinalsBuilder(index(), indexSettings); fieldData = builder.build( index, indexSettings, mapper, cache, circuitBreakerService, indexService.mapperService(), globalOrdinalBuilder); loadedFieldData.put(fieldNames.indexName(), fieldData); } } } return (IFD) fieldData; }
@SuppressWarnings("unchecked") public <IFD extends IndexFieldData<?>> IFD getForField(MappedFieldType fieldType) { final Names fieldNames = fieldType.names(); final FieldDataType type = fieldType.fieldDataType(); if (type == null) { throw new IllegalArgumentException( "found no fielddata type for field [" + fieldNames.fullName() + "]"); } final boolean docValues = fieldType.hasDocValues(); IndexFieldData.Builder builder = null; String format = type.getFormat(indexSettings); if (format != null && FieldDataType.DOC_VALUES_FORMAT_VALUE.equals(format) && !docValues) { logger.warn( "field [" + fieldNames.fullName() + "] has no doc values, will use default field data format"); format = null; } if (format != null) { builder = buildersByTypeAndFormat.get(Tuple.tuple(type.getType(), format)); if (builder == null) { logger.warn( "failed to find format [" + format + "] for field [" + fieldNames.fullName() + "], will use default"); } } if (builder == null && docValues) { builder = docValuesBuildersByType.get(type.getType()); } if (builder == null) { builder = buildersByType.get(type.getType()); } if (builder == null) { throw new IllegalArgumentException( "failed to find field data builder for field " + fieldNames.fullName() + ", and type " + type.getType()); } IndexFieldDataCache cache; synchronized (this) { cache = fieldDataCaches.get(fieldNames.indexName()); if (cache == null) { // we default to node level cache, which in turn defaults to be unbounded // this means changing the node level settings is simple, just set the bounds there String cacheType = type.getSettings() .get("cache", indexSettings.get(FIELDDATA_CACHE_KEY, FIELDDATA_CACHE_VALUE_NODE)); if (FIELDDATA_CACHE_VALUE_NODE.equals(cacheType)) { cache = indicesFieldDataCache.buildIndexFieldDataCache(listener, index, fieldNames, type); } else if ("none".equals(cacheType)) { cache = new IndexFieldDataCache.None(); } else { throw new IllegalArgumentException( "cache type not supported [" + cacheType + "] for field [" + fieldNames.fullName() + "]"); } fieldDataCaches.put(fieldNames.indexName(), cache); } } return (IFD) builder.build(index, indexSettings, fieldType, cache, circuitBreakerService, mapperService); }
public <IFD extends IndexFieldData<?>> IFD getForField(FieldDataType type, String fieldName) { final FieldMapper<?> mapper; final BuilderContext context = new BuilderContext(indexService.settingsService().getSettings(), new ContentPath(1)); if (type.getType().equals("string")) { mapper = MapperBuilders.stringField(fieldName) .tokenized(false) .fieldDataSettings(type.getSettings()) .build(context); } else if (type.getType().equals("float")) { mapper = MapperBuilders.floatField(fieldName).fieldDataSettings(type.getSettings()).build(context); } else if (type.getType().equals("double")) { mapper = MapperBuilders.doubleField(fieldName) .fieldDataSettings(type.getSettings()) .build(context); } else if (type.getType().equals("long")) { mapper = MapperBuilders.longField(fieldName).fieldDataSettings(type.getSettings()).build(context); } else if (type.getType().equals("int")) { mapper = MapperBuilders.integerField(fieldName) .fieldDataSettings(type.getSettings()) .build(context); } else if (type.getType().equals("short")) { mapper = MapperBuilders.shortField(fieldName).fieldDataSettings(type.getSettings()).build(context); } else if (type.getType().equals("byte")) { mapper = MapperBuilders.byteField(fieldName).fieldDataSettings(type.getSettings()).build(context); } else if (type.getType().equals("geo_point")) { mapper = MapperBuilders.geoPointField(fieldName) .fieldDataSettings(type.getSettings()) .build(context); } else if (type.getType().equals("_parent")) { mapper = MapperBuilders.parent().type(fieldName).build(context); } else if (type.getType().equals("binary")) { mapper = MapperBuilders.binaryField(fieldName) .fieldDataSettings(type.getSettings()) .build(context); } else { throw new UnsupportedOperationException(type.getType()); } return ifdService.getForField(mapper); }
public static FieldData load(FieldDataType type, IndexReader reader, String fieldName) throws IOException { return type.load(reader, fieldName); }
/** * Should single value cross documents case be optimized to remove ords. Note, this optimization * might not be supported by all Field Data implementations, but the ones that do, should * consult this method to check if it should be done or not. */ public static boolean removeOrdsOnSingleValue(FieldDataType fieldDataType) { return !"always".equals(fieldDataType.getSettings().get("ordinals")); }