+ * If the segment has no {@link DocValues}, the default + * {@link org.apache.lucene.index.DocValues.Source} of type + * {@link org.apache.lucene.index.DocValues.Type#BYTES_VAR_SORTED} will be used. + * + * @lucene.experimental + */ +public class StrDocValuesFieldSource extends DocValuesFieldSource { + + /** + * @param fieldName the name of the {@link DocValues} field + * @param direct whether or not to use a direct {@link org.apache.lucene.index.DocValues.Source} + */ + public StrDocValuesFieldSource(String fieldName, boolean direct) { + super(fieldName, direct); + } + + @Override + public FunctionValues getValues(@SuppressWarnings("rawtypes") Map context, AtomicReaderContext readerContext) throws IOException { + final DocValues.Source source = getSource(readerContext.reader(), DocValues.Type.BYTES_VAR_SORTED); + final Bits liveDocs = readerContext.reader().getLiveDocs(); + switch (source.getType()) { + case BYTES_FIXED_DEREF: + case BYTES_FIXED_STRAIGHT: + case BYTES_VAR_DEREF: + case BYTES_VAR_STRAIGHT: + return new StrDocValues(this) { + + @Override + public boolean exists(int doc) { + return liveDocs == null || liveDocs.get(doc); + } + + @Override + public boolean bytesVal(int doc, BytesRef target) { + source.getBytes(doc, target); + return true; + } + + @Override + public String strVal(int doc) { + BytesRef utf8Bytes = new BytesRef(); + source.getBytes(doc, utf8Bytes); + return utf8Bytes.utf8ToString(); + } + + }; + case BYTES_FIXED_SORTED: + case BYTES_VAR_SORTED: + final DocValues.SortedSource sortedSource = source.asSortedSource(); + return new IntDocValues(this) { + + @Override + public int intVal(int doc) { + return ordVal(doc); + } + + @Override + public int ordVal(int doc) { + return sortedSource.ord(doc); + } + + @Override + public boolean exists(int doc) { + return liveDocs == null || liveDocs.get(doc); + } + + @Override + public boolean bytesVal(int doc, BytesRef target) { + source.getBytes(doc, target); + return true; + } + + @Override + public String strVal(int doc) { + BytesRef utf8Bytes = new BytesRef(); + source.getBytes(doc, utf8Bytes); + return utf8Bytes.utf8ToString(); + } + + @Override + public Object objectVal(int doc) { + return strVal(doc); + } + + }; + default: + throw new IllegalStateException(getClass().getSimpleName() + " only works with binary types, not " + source.getType()); + } + } + +} Index: lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/NumericDocValuesFieldSource.java =================================================================== --- lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/NumericDocValuesFieldSource.java (révision 0) +++ lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/NumericDocValuesFieldSource.java (copie de travail) @@ -0,0 +1,239 @@ +package org.apache.lucene.queries.function.valuesource; + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import java.io.IOException; +import java.util.Map; + +import org.apache.lucene.index.AtomicReaderContext; +import org.apache.lucene.index.DocValues; +import org.apache.lucene.queries.function.FunctionValues; +import org.apache.lucene.queries.function.ValueSource; +import org.apache.lucene.queries.function.docvalues.DoubleDocValues; +import org.apache.lucene.queries.function.docvalues.FloatDocValues; +import org.apache.lucene.queries.function.docvalues.IntDocValues; +import org.apache.lucene.queries.function.docvalues.LongDocValues; +import org.apache.lucene.util.Bits; + +/** + * A {@link ValueSource} for numeric {@link DocValues} types:
+ * If the segment has no {@link DocValues}, the default + * {@link org.apache.lucene.index.DocValues.Source} of type + * {@link org.apache.lucene.index.DocValues.Type#FLOAT_64} will be used. + * + * @lucene.experimental + */ +public final class NumericDocValuesFieldSource extends DocValuesFieldSource { + + /** + * @param fieldName the name of the {@link DocValues} field + * @param direct whether or not to use a direct {@link org.apache.lucene.index.DocValues.Source} + */ + public NumericDocValuesFieldSource(String fieldName, boolean direct) { + super(fieldName, direct); + } + + @Override + public FunctionValues getValues(@SuppressWarnings("rawtypes") Map context, AtomicReaderContext readerContext) throws IOException { + final DocValues.Source source = getSource(readerContext.reader(), DocValues.Type.FLOAT_64); + final Bits liveDocs = readerContext.reader().getLiveDocs(); + switch (source.getType()) { + case FIXED_INTS_8: + case FIXED_INTS_16: + case FIXED_INTS_32: + case FIXED_INTS_64: + case VAR_INTS: + if (source.hasArray()) { + final Object valuesArr = source.getArray(); + if (valuesArr instanceof long[]) { + final long[] values = (long[]) source.getArray(); + return new LongDocValues(this) { + + @Override + public boolean exists(int doc) { + return liveDocs == null || liveDocs.get(doc); + } + + @Override + public long longVal(int doc) { + return values[doc]; + } + + }; + } else if (valuesArr instanceof int[]) { + final int[] values = (int[]) source.getArray(); + return new IntDocValues(this) { + + @Override + public boolean exists(int doc) { + return liveDocs == null || liveDocs.get(doc); + } + + @Override + public int intVal(int doc) { + return values[doc]; + } + + }; + } else if (valuesArr instanceof short[]) { + final short[] values = (short[]) source.getArray(); + return new IntDocValues(this) { + + @Override + public boolean exists(int doc) { + return liveDocs == null || liveDocs.get(doc); + } + + @Override + public int intVal(int doc) { + return values[doc]; + } + + @Override + public Object objectVal(int doc) { + return shortVal(doc); + } + + }; + } else if (valuesArr instanceof byte[]) { + final byte[] values = (byte[]) source.getArray(); + return new IntDocValues(this) { + + @Override + public boolean exists(int doc) { + return liveDocs == null || liveDocs.get(doc); + } + + @Override + public int intVal(int doc) { + return values[doc]; + } + + @Override + public Object objectVal(int doc) { + return byteVal(doc); + } + + }; + } + } + return new LongDocValues(this) { + + @Override + public boolean exists(int doc) { + return liveDocs == null || liveDocs.get(doc); + } + + @Override + public long longVal(int doc) { + return source.getInt(doc); + } + + @Override + public Object objectVal(int doc) { + switch (source.getType()) { + case FIXED_INTS_8: + return byteVal(doc); + case FIXED_INTS_16: + return shortVal(doc); + case FIXED_INTS_32: + return intVal(doc); + case FIXED_INTS_64: + case VAR_INTS: + return longVal(doc); + default: + throw new AssertionError(); + } + } + + }; + case FLOAT_32: + case FLOAT_64: + if (source.hasArray()) { + final Object valuesArr = source.getArray(); + if (valuesArr instanceof float[]) { + final float[] values = (float[]) valuesArr; + return new FloatDocValues(this) { + + @Override + public boolean exists(int doc) { + return liveDocs == null || liveDocs.get(doc); + } + + @Override + public float floatVal(int doc) { + return values[doc]; + } + + }; + } else if (valuesArr instanceof double[]) { + final double[] values = (double[]) valuesArr; + return new DoubleDocValues(this) { + + @Override + public boolean exists(int doc) { + return liveDocs == null || liveDocs.get(doc); + } + + @Override + public double doubleVal(int doc) { + return values[doc]; + } + + }; + } + } + return new DoubleDocValues(this) { + + @Override + public boolean exists(int doc) { + return liveDocs == null || liveDocs.get(doc); + } + + @Override + public double doubleVal(int doc) { + return source.getFloat(doc); + } + + @Override + public Object objectVal(int doc) { + switch (source.getType()) { + case FLOAT_32: + return floatVal(doc); + case FLOAT_64: + return doubleVal(doc); + default: + throw new AssertionError(); + } + } + + }; + default: + throw new IllegalStateException(getClass().getSimpleName() + " only works with numeric types, not " + source.getType()); + } + } + +} Index: lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/DateDocValuesFieldSource.java =================================================================== --- lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/DateDocValuesFieldSource.java (révision 0) +++ lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/DateDocValuesFieldSource.java (copie de travail) @@ -0,0 +1,103 @@ +package org.apache.lucene.queries.function.valuesource; + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import java.io.IOException; +import java.util.Date; +import java.util.Map; + +import org.apache.lucene.index.AtomicReaderContext; +import org.apache.lucene.index.DocValues; +import org.apache.lucene.queries.function.FunctionValues; +import org.apache.lucene.queries.function.ValueSource; +import org.apache.lucene.queries.function.docvalues.LongDocValues; +import org.apache.lucene.util.Bits; + +/** + * A {@link ValueSource} for {@link DocValues} dates, backed by + * {@link org.apache.lucene.index.DocValues.Type#FIXED_INTS_64} + * or {@link org.apache.lucene.index.DocValues.Type#VAR_INTS}. + *
+ * If the segment has no {@link DocValues}, the default + * {@link org.apache.lucene.index.DocValues.Source} of type + * {@link org.apache.lucene.index.DocValues.Type#FIXED_INTS_64} will be used. + * + * @lucene.experimental + */ +public final class DateDocValuesFieldSource extends DocValuesFieldSource { + + /** + * @param fieldName the name of the {@link DocValues} field + * @param direct whether or not to use a direct {@link org.apache.lucene.index.DocValues.Source} + */ + public DateDocValuesFieldSource(String fieldName, boolean direct) { + super(fieldName, direct); + } + + @Override + public FunctionValues getValues(@SuppressWarnings("rawtypes") Map context, AtomicReaderContext readerContext) throws IOException { + final DocValues.Source source = getSource(readerContext.reader(), DocValues.Type.FIXED_INTS_64); + final Bits liveDocs = readerContext.reader().getLiveDocs(); + switch (source.getType()) { + case FIXED_INTS_64: + case VAR_INTS: + if (source.hasArray() && source.getArray() instanceof long[]) { + final long[] values = (long[]) source.getArray(); + return new LongDocValues(this) { + + @Override + public boolean exists(int doc) { + return liveDocs == null || liveDocs.get(doc); + } + + @Override + public long longVal(int doc) { + return values[doc]; + } + + @Override + public Object objectVal(int doc) { + return new Date(longVal(doc)); + } + + }; + } + return new LongDocValues(this) { + + @Override + public boolean exists(int doc) { + return liveDocs == null || liveDocs.get(doc); + } + + @Override + public long longVal(int doc) { + return source.getInt(doc); + } + + @Override + public Object objectVal(int doc) { + return new Date(longVal(doc)); + } + + }; + default: + throw new IllegalStateException(getClass().getSimpleName() + " only works with 64-bits integer types, not " + source.getType()); + } + } + +} Index: lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/DocValuesFieldSource.java =================================================================== --- lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/DocValuesFieldSource.java (révision 0) +++ lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/DocValuesFieldSource.java (copie de travail) @@ -0,0 +1,89 @@ +package org.apache.lucene.queries.function.valuesource; + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import java.io.IOException; + +import org.apache.lucene.index.AtomicReader; +import org.apache.lucene.index.DocValues; +import org.apache.lucene.queries.function.ValueSource; + +/** + * A {@link ValueSource} that is based a a field's {@link DocValues}. + */ +abstract class DocValuesFieldSource extends ValueSource { + + protected final String fieldName; + protected final boolean direct; + + protected DocValuesFieldSource(String fieldName, boolean direct) { + this.fieldName = fieldName; + this.direct = direct; + } + + protected final DocValues.Source getSource(AtomicReader reader, DocValues.Type defaultType) throws IOException { + final DocValues vals = reader.docValues(fieldName); + if (vals == null) { + switch (defaultType) { + case BYTES_FIXED_SORTED: + case BYTES_VAR_SORTED: + return DocValues.getDefaultSortedSource(defaultType, reader.maxDoc()); + default: + return DocValues.getDefaultSource(defaultType); + } + } + return direct ? vals.getDirectSource() : vals.getSource(); + } + + /** + * @return whether or not a direct + * {@link org.apache.lucene.index.DocValues.Source} is used. + */ + public boolean isDirect() { + return direct; + } + + /** + * @return the field name + */ + public String getFieldName() { + return fieldName; + } + + @Override + public boolean equals(Object o) { + if (o == null || !getClass().isInstance(o)) { + return false; + } + final DocValuesFieldSource other = (DocValuesFieldSource) o; + return fieldName.equals(other.fieldName) && direct == other.direct; + } + + @Override + public int hashCode() { + int h = getClass().hashCode(); + h = 31 * h + fieldName.hashCode(); + h = 31 * h + (direct ? 1 : 0); + return h; + } + + @Override + public String description() { + return fieldName; + } +}