Java Code Examples for org.elasticsearch.index.mapper.core.DateFieldMapper#DateFieldType

private Query getRangeQuerySingle(String field, String part1, String part2, boolean startInclusive, boolean endInclusive) {
    currentFieldType = parseContext.fieldMapper(field);
    if (currentFieldType != null) {
        if (lowercaseExpandedTerms && !currentFieldType.isNumeric()) {
            part1 = part1 == null ? null : part1.toLowerCase(locale);
            part2 = part2 == null ? null : part2.toLowerCase(locale);
        }

        try {
            Query rangeQuery;
            if (currentFieldType instanceof DateFieldMapper.DateFieldType && settings.timeZone() != null) {
                DateFieldMapper.DateFieldType dateFieldType = (DateFieldMapper.DateFieldType) this.currentFieldType;
                rangeQuery = dateFieldType.rangeQuery(part1, part2, startInclusive, endInclusive, settings.timeZone(), null);
            } else {
                rangeQuery = currentFieldType.rangeQuery(part1, part2, startInclusive, endInclusive);
            }
            return rangeQuery;
        } catch (RuntimeException e) {
            if (settings.lenient()) {
                return null;
            }
            throw e;
        }
    }
    return newRangeQuery(field, part1, part2, startInclusive, endInclusive);
}
 

private AbstractDistanceScoreFunction parseVariable(String fieldName, XContentParser parser, QueryParseContext parseContext, MultiValueMode mode) throws IOException {

        // now, the field must exist, else we cannot read the value for
        // the doc later
        MappedFieldType fieldType = parseContext.fieldMapper(fieldName);
        if (fieldType == null) {
            throw new QueryParsingException(parseContext, "unknown field [{}]", fieldName);
        }

        // dates and time need special handling
        parser.nextToken();
        if (fieldType instanceof DateFieldMapper.DateFieldType) {
            return parseDateVariable(fieldName, parser, parseContext, (DateFieldMapper.DateFieldType) fieldType, mode);
        } else if (fieldType instanceof GeoPointFieldMapper.GeoPointFieldType) {
            return parseGeoVariable(fieldName, parser, parseContext, (GeoPointFieldMapper.GeoPointFieldType) fieldType, mode);
        } else if (fieldType instanceof NumberFieldMapper.NumberFieldType) {
            return parseNumberVariable(fieldName, parser, parseContext, (NumberFieldMapper.NumberFieldType) fieldType, mode);
        } else {
            throw new QueryParsingException(parseContext, "field [{}] is of type [{}], but only numeric types are supported.", fieldName, fieldType);
        }
    }
 

private static ValueFormat resolveFormat(@Nullable String format, @Nullable DateTimeZone timezone,  MappedFieldType fieldType) {
    if (fieldType instanceof  DateFieldMapper.DateFieldType) {
        return format != null ? ValueFormat.DateTime.format(format, timezone) : ValueFormat.DateTime.mapper((DateFieldMapper.DateFieldType) fieldType, timezone);
    }
    if (fieldType instanceof IpFieldMapper.IpFieldType) {
        return ValueFormat.IPv4;
    }
    if (fieldType instanceof BooleanFieldMapper.BooleanFieldType) {
        return ValueFormat.BOOLEAN;
    }
    if (fieldType instanceof NumberFieldMapper.NumberFieldType) {
        return format != null ? ValueFormat.Number.format(format) : ValueFormat.RAW;
    }
    return ValueFormat.RAW;
}
 

private AbstractDistanceScoreFunction parseDateVariable(String fieldName, XContentParser parser, QueryParseContext parseContext,
        DateFieldMapper.DateFieldType dateFieldType, MultiValueMode mode) throws IOException {
    XContentParser.Token token;
    String parameterName = null;
    String scaleString = null;
    String originString = null;
    String offsetString = "0d";
    double decay = 0.5;
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            parameterName = parser.currentName();
        } else if (parameterName.equals(DecayFunctionBuilder.SCALE)) {
            scaleString = parser.text();
        } else if (parameterName.equals(DecayFunctionBuilder.ORIGIN)) {
            originString = parser.text();
        } else if (parameterName.equals(DecayFunctionBuilder.DECAY)) {
            decay = parser.doubleValue();
        } else if (parameterName.equals(DecayFunctionBuilder.OFFSET)) {
            offsetString = parser.text();
        } else {
            throw new ElasticsearchParseException("parameter [{}] not supported!", parameterName);
        }
    }
    long origin = SearchContext.current().nowInMillis();
    if (originString != null) {
        origin = dateFieldType.parseToMilliseconds(originString, false, null, null);
    }

    if (scaleString == null) {
        throw new ElasticsearchParseException("[{}] must be set for date fields.", DecayFunctionBuilder.SCALE);
    }
    TimeValue val = TimeValue.parseTimeValue(scaleString, TimeValue.timeValueHours(24), getClass().getSimpleName() + ".scale");
    double scale = val.getMillis();
    val = TimeValue.parseTimeValue(offsetString, TimeValue.timeValueHours(24), getClass().getSimpleName() + ".offset");
    double offset = val.getMillis();
    IndexNumericFieldData numericFieldData = parseContext.getForField(dateFieldType);
    return new NumericFieldDataScoreFunction(origin, scale, decay, offset, getDecayFunction(), numericFieldData, mode);
}
 

public static DateTime mapper(DateFieldMapper.DateFieldType fieldType, DateTimeZone timezone) {
    return new DateTime(fieldType.dateTimeFormatter(), timezone);
}
 

public static DateMath mapper(DateFieldMapper.DateFieldType fieldType, @Nullable DateTimeZone timezone) {
    return new DateMath(new DateMathParser(fieldType.dateTimeFormatter()), timezone);
}
 

public static DateTime mapper(DateFieldMapper.DateFieldType fieldType, DateTimeZone timezone) {
    return new DateTime(fieldType.dateTimeFormatter().format(), ValueFormatter.DateTime.mapper(fieldType, timezone), ValueParser.DateMath.mapper(fieldType, timezone));
}
 

@Override
public DateFieldMapper.DateFieldType fieldType() {
    return (DateFieldMapper.DateFieldType)fieldType;
}