Examples with ValueSource org.apache.lucene.queries.function.ValueSource used on opensource projects

Example 31 with ValueSource

use of org.apache.lucene.queries.function.ValueSource in project lucene-solr by apache.

the class TestIndexSearcher method getStringVal.

private String getStringVal(SolrQueryRequest sqr, String field, int doc) throws IOException {
    SchemaField sf = sqr.getSchema().getField(field);
    ValueSource vs = sf.getType().getValueSource(sf, null);
    Map context = ValueSource.newContext(sqr.getSearcher());
    vs.createWeight(context, sqr.getSearcher());
    IndexReaderContext topReaderContext = sqr.getSearcher().getTopReaderContext();
    List<LeafReaderContext> leaves = topReaderContext.leaves();
    int idx = ReaderUtil.subIndex(doc, leaves);
    LeafReaderContext leaf = leaves.get(idx);
    FunctionValues vals = vs.getValues(context, leaf);
    return vals.strVal(doc - leaf.docBase);
}

Example 32 with ValueSource

use of org.apache.lucene.queries.function.ValueSource in project lucene-solr by apache.

the class SerializedDVStrategy method makeQuery.

/**
   * Returns a Query that should be used in a random-access fashion.
   * Use in another manner will be SLOW.
   */
@Override
public Query makeQuery(SpatialArgs args) {
    ValueSource shapeValueSource = makeShapeValueSource();
    ShapePredicateValueSource predicateValueSource = new ShapePredicateValueSource(shapeValueSource, args.getOperation(), args.getShape());
    return new PredicateValueSourceQuery(predicateValueSource);
}

Example 33 with ValueSource

use of org.apache.lucene.queries.function.ValueSource in project lucene-solr by apache.

the class SolrReturnFields method add.

private void add(String fl, NamedList<String> rename, DocTransformers augmenters, SolrQueryRequest req) {
    if (fl == null) {
        return;
    }
    try {
        StrParser sp = new StrParser(fl);
        for (; ; ) {
            sp.opt(',');
            sp.eatws();
            if (sp.pos >= sp.end)
                break;
            int start = sp.pos;
            // short circuit test for a really simple field name
            String key = null;
            String field = getFieldName(sp);
            char ch = sp.ch();
            if (field != null) {
                if (sp.opt(':')) {
                    // this was a key, not a field name
                    key = field;
                    field = null;
                    sp.eatws();
                    start = sp.pos;
                } else {
                    if (Character.isWhitespace(ch) || ch == ',' || ch == 0) {
                        addField(field, key, augmenters, false);
                        continue;
                    }
                    // an invalid field name... reset the position pointer to retry
                    sp.pos = start;
                    field = null;
                }
            }
            if (key != null) {
                // we read "key : "
                field = sp.getId(null);
                ch = sp.ch();
                if (field != null && (Character.isWhitespace(ch) || ch == ',' || ch == 0)) {
                    rename.add(field, key);
                    addField(field, key, augmenters, false);
                    continue;
                }
                // an invalid field name... reset the position pointer to retry
                sp.pos = start;
                field = null;
            }
            if (field == null) {
                // We didn't find a simple name, so let's see if it's a globbed field name.
                // Globbing only works with field names of the recommended form (roughly like java identifiers)
                field = sp.getGlobbedId(null);
                ch = sp.ch();
                if (field != null && (Character.isWhitespace(ch) || ch == ',' || ch == 0)) {
                    // "*" looks and acts like a glob, but we give it special treatment
                    if ("*".equals(field)) {
                        _wantsAllFields = true;
                    } else {
                        globs.add(field);
                    }
                    continue;
                }
                // an invalid glob
                sp.pos = start;
            }
            String funcStr = sp.val.substring(start);
            if (funcStr.startsWith("[")) {
                ModifiableSolrParams augmenterParams = new ModifiableSolrParams();
                int end = QueryParsing.parseLocalParams(funcStr, 0, augmenterParams, req.getParams(), "[", ']');
                sp.pos += end;
                // [foo] is short for [type=foo] in localParams syntax
                String augmenterName = augmenterParams.get("type");
                augmenterParams.remove("type");
                String disp = key;
                if (disp == null) {
                    disp = '[' + augmenterName + ']';
                }
                TransformerFactory factory = req.getCore().getTransformerFactory(augmenterName);
                if (factory != null) {
                    DocTransformer t = factory.create(disp, augmenterParams, req);
                    if (t != null) {
                        if (!_wantsAllFields) {
                            String[] extra = t.getExtraRequestFields();
                            if (extra != null) {
                                for (String f : extra) {
                                    // also request this field from IndexSearcher
                                    fields.add(f);
                                }
                            }
                        }
                        augmenters.addTransformer(t);
                    }
                } else {
                //throw new SolrException(ErrorCode.BAD_REQUEST, "Unknown DocTransformer: "+augmenterName);
                }
                addField(field, disp, augmenters, true);
                continue;
            }
            // let's try it as a function instead
            QParser parser = QParser.getParser(funcStr, FunctionQParserPlugin.NAME, req);
            Query q = null;
            ValueSource vs = null;
            try {
                if (parser instanceof FunctionQParser) {
                    FunctionQParser fparser = (FunctionQParser) parser;
                    fparser.setParseMultipleSources(false);
                    fparser.setParseToEnd(false);
                    q = fparser.getQuery();
                    if (fparser.localParams != null) {
                        if (fparser.valFollowedParams) {
                            // need to find the end of the function query via the string parser
                            int leftOver = fparser.sp.end - fparser.sp.pos;
                            // reset our parser to the same amount of leftover
                            sp.pos = sp.end - leftOver;
                        } else {
                            // the value was via the "v" param in localParams, so we need to find
                            // the end of the local params themselves to pick up where we left off
                            sp.pos = start + fparser.localParamsEnd;
                        }
                    } else {
                        // need to find the end of the function query via the string parser
                        int leftOver = fparser.sp.end - fparser.sp.pos;
                        // reset our parser to the same amount of leftover
                        sp.pos = sp.end - leftOver;
                    }
                } else {
                    // A QParser that's not for function queries.
                    // It must have been specified via local params.
                    q = parser.getQuery();
                    assert parser.getLocalParams() != null;
                    sp.pos = start + parser.localParamsEnd;
                }
                funcStr = sp.val.substring(start, sp.pos);
                if (q instanceof FunctionQuery) {
                    vs = ((FunctionQuery) q).getValueSource();
                } else {
                    vs = new QueryValueSource(q, 0.0f);
                }
                if (key == null) {
                    SolrParams localParams = parser.getLocalParams();
                    if (localParams != null) {
                        key = localParams.get("key");
                    }
                }
                if (key == null) {
                    key = funcStr;
                }
                addField(funcStr, key, augmenters, true);
                augmenters.addTransformer(new ValueSourceAugmenter(key, parser, vs));
            } catch (SyntaxError e) {
                // try again, simple rules for a field name with no whitespace
                sp.pos = start;
                field = sp.getSimpleString();
                if (req.getSchema().getFieldOrNull(field) != null) {
                    // OK, it was an oddly named field
                    addField(field, key, augmenters, false);
                    if (key != null) {
                        rename.add(field, key);
                    }
                } else {
                    throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "Error parsing fieldname: " + e.getMessage(), e);
                }
            }
        // end try as function
        }
    // end for(;;)
    } catch (SyntaxError e) {
        throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "Error parsing fieldname", e);
    }
}

Example 34 with ValueSource

use of org.apache.lucene.queries.function.ValueSource in project lucene-solr by apache.

the class TestValueSource method parse.

@Override
public ValueSource parse(FunctionQParser fp) throws SyntaxError {
    String first = fp.parseArg();
    String second = fp.parseArg();
    if (first == null)
        first = "NOW";
    Date d1 = getDate(fp, first);
    ValueSource v1 = d1 == null ? getValueSource(fp, first) : null;
    Date d2 = getDate(fp, second);
    ValueSource v2 = d2 == null ? getValueSource(fp, second) : null;
    // d     constant
    // v     field
    // dd    constant
    // dv    subtract field from constant
    // vd    subtract constant from field
    // vv    subtract fields
    final long ms1 = (d1 == null) ? 0 : d1.getTime();
    final long ms2 = (d2 == null) ? 0 : d2.getTime();
    if (d1 != null && v2 == null) {
        return new LongConstValueSource(ms1 - ms2);
    }
    // "v" just the date field
    if (v1 != null && v2 == null && d2 == null) {
        return v1;
    }
    // "dv"
    if (d1 != null && v2 != null)
        return new DualFloatFunction(new LongConstValueSource(ms1), v2) {

            @Override
            protected String name() {
                return "ms";
            }

            @Override
            protected float func(int doc, FunctionValues aVals, FunctionValues bVals) throws IOException {
                return ms1 - bVals.longVal(doc);
            }
        };
    // "vd"
    if (v1 != null && d2 != null)
        return new DualFloatFunction(v1, new LongConstValueSource(ms2)) {

            @Override
            protected String name() {
                return "ms";
            }

            @Override
            protected float func(int doc, FunctionValues aVals, FunctionValues bVals) throws IOException {
                return aVals.longVal(doc) - ms2;
            }
        };
    // "vv"
    if (v1 != null && v2 != null)
        return new DualFloatFunction(v1, v2) {

            @Override
            protected String name() {
                return "ms";
            }

            @Override
            protected float func(int doc, FunctionValues aVals, FunctionValues bVals) throws IOException {
                return aVals.longVal(doc) - bVals.longVal(doc);
            }
        };
    // shouldn't happen
    return null;
}

Example 35 with ValueSource

use of org.apache.lucene.queries.function.ValueSource in project lucene-solr by apache.

the class MinMaxAgg method createSlotAcc.

@Override
public SlotAcc createSlotAcc(FacetContext fcontext, int numDocs, int numSlots) throws IOException {
    ValueSource vs = getArg();
    if (vs instanceof StrFieldSource) {
        String field = ((StrFieldSource) vs).getField();
        SchemaField sf = fcontext.qcontext.searcher().getSchema().getField(field);
        if (sf.multiValued() || sf.getType().multiValuedFieldCache()) {
            if (sf.hasDocValues()) {
            // dv
            } else {
            // uif
            }
        } else {
            return new SingleValuedOrdAcc(fcontext, sf, numSlots);
        }
    }
    // numeric functions
    return new ValSlotAcc(vs, fcontext, numSlots);
}