/** * Add a field to the document. * * @return true if the field was successfully added */ public static boolean addField(Document doc, String field, Object fieldValue) { Class<?> clazz = fieldValue.getClass(); if (clazz == String.class) { doc.add(new TextField(field, (String) fieldValue, Store.NO)); } else if (clazz == Long.class) { doc.add(new LongPoint(field, (Long) fieldValue)); } else if (clazz == Integer.class) { doc.add(new IntPoint(field, (Integer) fieldValue)); } else if (clazz == Float.class) { doc.add(new FloatPoint(field, (Float) fieldValue)); } else if (clazz == Double.class) { doc.add(new DoublePoint(field, (Double) fieldValue)); } else { return false; } return true; }
/** * Create a query for matching an exact long value. * <p> * This is for simple one-dimension points, for multidimensional points use * {@link #newRangeQuery(String, long[], long[])} instead. * * @param field field name. must not be {@code null}. * @param value exact value * @throws IllegalArgumentException if {@code field} is null. * @return a query matching documents with this exact value */ public static Query newExactQuery(String field, long value) { return newRangeQuery(field, value, value); }
/** * Create a query matching any of the specified 1D values. This is the points equivalent of {@code TermsQuery}. * * @param field field name. must not be {@code null}. * @param values all values to match */ public static Query newSetQuery(String field, Collection<Long> values) { Long[] boxed = values.toArray(new Long[0]); long[] unboxed = new long[boxed.length]; for (int i = 0; i < boxed.length; i++) { unboxed[i] = boxed[i]; } return newSetQuery(field, unboxed); } }
@Override protected String toString(int dimension, byte[] value) { return Long.toString(decodeDimension(value, 0)); } };
@Override public Query toTermQuery(final String name, final String text) throws ParseException { return LongPoint.newExactQuery(name, toDate(text)); }
@Override protected String toString(byte[] value) { assert value.length == Long.BYTES; return Long.toString(decodeDimension(value, 0)); } };
@Override public Query toTermQuery(final String name, final String text) { return LongPoint.newExactQuery(name, toLong(text)); }
doc.add(new LongPoint(EXPIRATION_TIME_FIELD_NAME, expires));
/** * Create a range query for long values. * <p> * This is for simple one-dimension ranges, for multidimensional ranges use * {@link #newRangeQuery(String, long[], long[])} instead. * <p> * You can have half-open ranges (which are in fact </≤ or >/≥ queries) * by setting {@code lowerValue = Long.MIN_VALUE} or {@code upperValue = Long.MAX_VALUE}. * <p> * Ranges are inclusive. For exclusive ranges, pass {@code Math.addExact(lowerValue, 1)} * or {@code Math.addExact(upperValue, -1)}. * * @param field field name. must not be {@code null}. * @param lowerValue lower portion of the range (inclusive). * @param upperValue upper portion of the range (inclusive). * @throws IllegalArgumentException if {@code field} is null. * @return a query matching documents within this range. */ public static Query newRangeQuery(String field, long lowerValue, long upperValue) { return newRangeQuery(field, new long[] { lowerValue }, new long[] { upperValue }); }
@Override public String toString() { StringBuilder result = new StringBuilder(); result.append(getClass().getSimpleName()); result.append(" <"); result.append(name); result.append(':'); BytesRef bytes = (BytesRef) fieldsData; for (int dim = 0; dim < type.pointDataDimensionCount(); dim++) { if (dim > 0) { result.append(','); } result.append(decodeDimension(bytes.bytes, bytes.offset + dim * Long.BYTES)); } result.append('>'); return result.toString(); }
@Override public Query termsQuery(List<?> values, @Nullable QueryShardContext context) { long[] v = new long[values.size()]; for (int i = 0; i < values.size(); ++i) { v[i] = parse(values.get(i)); } return LongPoint.newSetQuery(name(), v); }
@Override public Query termQuery(String field, Object value) { if (hasDecimalPart(value)) { return Queries.newMatchNoDocsQuery("Value [" + value + "] has a decimal part"); } long v = parse(value, true); return LongPoint.newExactQuery(field, v); }
@Override public List<Field> createFields(String name, Number value, boolean indexed, boolean docValued, boolean stored) { List<Field> fields = new ArrayList<>(); if (indexed) { fields.add(new LongPoint(name, value.longValue())); } if (docValued) { fields.add(new SortedNumericDocValuesField(name, value.longValue())); } if (stored) { fields.add(new StoredField(name, value.longValue())); } return fields; } };
Query filter = LongPoint.newRangeQuery(EXPIRATION_TIME_FIELD_NAME, U.currentTimeMillis(), Long.MAX_VALUE);
@Override public Number numericValue() { if (type.pointDataDimensionCount() != 1) { throw new IllegalStateException("this field (name=" + name + ") uses " + type.pointDataDimensionCount() + " dimensions; cannot convert to a single numeric value"); } BytesRef bytes = (BytesRef) fieldsData; assert bytes.length == Long.BYTES; return decodeDimension(bytes.bytes, bytes.offset); }
@Override public Query termsQuery(String field, List<Object> values) { long[] v = new long[values.size()]; int upTo = 0; for (int i = 0; i < values.size(); i++) { Object value = values.get(i); if (!hasDecimalPart(value)) { v[upTo++] = parse(value, true); } } if (upTo == 0) { return Queries.newMatchNoDocsQuery("All values have a decimal part"); } if (upTo != v.length) { v = Arrays.copyOf(v, upTo); } return LongPoint.newSetQuery(field, v); }
@Override public Query termQuery(Object value, @Nullable QueryShardContext context) { long v = parse(value); return LongPoint.newExactQuery(name(), v); }
@Override public void addFields(final String name, final Object value, final ViewSettings settings, final Document to) throws ParseException { to.add(boost(new LongPoint(name, toDate(value)), settings)); to.add(new NumericDocValuesField(name, toDate(value))); }
/** * Returns a soft-deletes retention query that will be used in {@link org.apache.lucene.index.SoftDeletesRetentionMergePolicy} * Documents including tombstones are soft-deleted and matched this query will be retained and won't cleaned up by merges. */ Query getRetentionQuery() { return LongPoint.newRangeQuery(SeqNoFieldMapper.NAME, getMinRetainedSeqNo(), Long.MAX_VALUE); } }
@Override public Number parsePoint(byte[] value) { return LongPoint.decodeDimension(value, 0); }