/** * 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 integer value. * <p> * This is for simple one-dimension points, for multidimensional points use * {@link #newRangeQuery(String, int[], int[])} 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, int value) { return newRangeQuery(field, value, value); }
@Override protected String toString(byte[] value) { assert value.length == Integer.BYTES; return Integer.toString(decodeDimension(value, 0)); } };
@Override public Query toTermQuery(final String name, final String text) { return IntPoint.newExactQuery(name, toInt(text)); }
/** * 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<Integer> values) { Integer[] boxed = values.toArray(new Integer[0]); int[] unboxed = new int[boxed.length]; for (int i = 0; i < boxed.length; i++) { unboxed[i] = boxed[i]; } return newSetQuery(field, unboxed); } }
@Override public Query termQuery(String field, Object value) { if (hasDecimalPart(value)) { return Queries.newMatchNoDocsQuery("Value [" + value + "] has a decimal part"); } int v = parse(value, true); return IntPoint.newExactQuery(field, v); }
@Override public Query termsQuery(String field, List<Object> values) { int[] v = new int[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 IntPoint.newSetQuery(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 IntPoint(name, value.intValue())); } if (docValued) { fields.add(new SortedNumericDocValuesField(name, value.intValue())); } if (stored) { fields.add(new StoredField(name, value.intValue())); } return fields; } },
/** * Create a range query for integer values. * <p> * This is for simple one-dimension ranges, for multidimensional ranges use * {@link #newRangeQuery(String, int[], int[])} instead. * <p> * You can have half-open ranges (which are in fact </≤ or >/≥ queries) * by setting {@code lowerValue = Integer.MIN_VALUE} or {@code upperValue = Integer.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, int lowerValue, int upperValue) { return newRangeQuery(field, new int[] { lowerValue }, new int[] { upperValue }); }
@Override public Query createExactQuery(String absoluteFieldPath, Integer value) { return IntPoint.newExactQuery( absoluteFieldPath, value ); }
@Override protected String toString(int dimension, byte[] value) { return Integer.toString(decodeDimension(value, 0)); } };
/** * 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<Integer> values) { Integer[] boxed = values.toArray(new Integer[0]); int[] unboxed = new int[boxed.length]; for (int i = 0; i < boxed.length; i++) { unboxed[i] = boxed[i]; } return newSetQuery(field, unboxed); } }
@Override public void addFields(final String name, final Object value, final ViewSettings settings, final Document to) { to.add(boost(new IntPoint(name, toInt(value)), settings)); to.add(new NumericDocValuesField(name, toInt(value))); }
@Override public Query getQuery(LuceneIndex index) throws LuceneQueryException { if (luceneQuery == null) { luceneQuery = IntPoint.newRangeQuery(fieldName, lowerValue, upperValue); } System.out.println("IntRangeQueryProvider, using java serializable"); return luceneQuery; } }
@Override public Query termQuery(String field, Object value) { if (hasDecimalPart(value)) { return Queries.newMatchNoDocsQuery("Value [" + value + "] has a decimal part"); } int v = parse(value, true); return IntPoint.newExactQuery(field, v); }
@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 * Integer.BYTES)); } result.append('>'); return result.toString(); }
@Override public Query termsQuery(String field, List<Object> values) { int[] v = new int[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 IntPoint.newSetQuery(field, v); }
@Override protected Field createField(Number o, String indexedFieldName) { return new IntPoint(indexedFieldName, o.intValue()); }
@Override public Query toRangeQuery(final String name, final String lower, final String upper, final boolean lowerInclusive, final boolean upperInclusive) { return IntPoint.newRangeQuery(name, lowerInclusive ? toInt(lower) : Math.addExact(toInt(lower), 1), upperInclusive ? toInt(upper) : Math.addExact(toInt(upper), -1)); }
@Override public Query getQuery(final QueryContext queryContext) throws IOException { return IntPoint.newExactQuery(resolveField(queryContext.getFieldMap()), value); } }