org.apache.lucene.search.Scorable Java Examples

public static final MatcherFactory<ScoringMatch> matchWithSimilarity(Similarity similarity) {
  return searcher -> {
    searcher.setSimilarity(similarity);
    return new CollectingMatcher<ScoringMatch>(searcher, ScoreMode.COMPLETE) {
      @Override
      protected ScoringMatch doMatch(String queryId, int doc, Scorable scorer) throws IOException {
        float score = scorer.score();
        if (score > 0)
          return new ScoringMatch(queryId, score);
        return null;
      }

      @Override
      public ScoringMatch resolve(ScoringMatch match1, ScoringMatch match2) {
        return new ScoringMatch(match1.getQueryId(), match1.getScore() + match2.getScore());
      }
    };
  };
}
 

@Override
public LeafCollector getLeafCollector(LeafReaderContext context) throws IOException {
  final FixedBitSet set = new FixedBitSet(context.reader().maxDoc());
  this.sets[context.ord] = set;
  return new LeafCollector() {
    
    @Override
    public void setScorer(Scorable scorer) throws IOException {}
    
    @Override
    public void collect(int docId) throws IOException{
      ++totalHits;
      set.set(docId);
    }
  };
}
 

@Override
public LeafCollector getLeafCollector(LeafReaderContext context) throws IOException {
  final int base = context.docBase;
  final NumericDocValues values = DocValues.getNumeric(context.reader(), "sort_i");
  return new LeafCollector() {
    
    @Override
    public void setScorer(Scorable scorer) throws IOException {}
    
    public void collect(int doc) throws IOException {
      long value;
      if (values.advanceExact(doc)) {
        value = values.longValue();
      } else {
        value = 0;
      }
      list.add(new ScoreDoc(doc+base, (float) value));
    }
  };
}
 

@Override
public LeafCollector getLeafCollector(LeafReaderContext context) {
  return new LeafCollector() {

    @Override
    public void setScorer(Scorable scorer) throws IOException {
      // we don't use scoring, so this is NO-OP
    }

    @Override
    public void collect(int doc) throws IOException {
      _docIds.add(doc);
    }
  };
}
 

@Override
public void collect(int docID) {
  for(Scorable s : allScorers) {
    if (docID != s.docID()) {
      throw new IllegalStateException("subScorer=" + s + " has docID=" + s.docID() + " != collected docID=" + docID);
    }
  }
}
 

@Override
public void setScorer(Scorable scorer) throws IOException {
  this.scorer = scorer;
  if (leafDelegate != null) {
    leafDelegate.setScorer(scorer);
  }
}
 

@Override
public void setScorer(Scorable s) throws IOException {
  // Gathers all scorers, including s and "under":
  allScorers = new ArrayList<>();
  allScorers.add(s);
  int upto = 0;
  while(upto < allScorers.size()) {
    s = allScorers.get(upto++);
    for (Scorable.ChildScorable sub : s.getChildren()) {
      allScorers.add(sub.child);
    }
  }
}
 

@Override
public void setScorer(Scorable scorer) throws IOException {
  groupSelector.setScorer(scorer);
  for (LeafFieldComparator comparator : leafComparators) {
    comparator.setScorer(scorer);
  }
}
 

@Override
public void setScorer(Scorable scorer) throws IOException {
  this.scorer = scorer;
  for (LeafFieldComparator comparator : leafComparators) {
    comparator.setScorer(scorer);
  }
}
 

@Override
public LeafCollector getLeafCollector(LeafReaderContext context) {
  return new LeafCollector() {

    @Override
    public void setScorer(Scorable scorer) throws IOException {
      // we don't use scoring, so this is NO-OP
    }

    @Override
    public void collect(int doc) throws IOException {
      _docIds.add(_docIdTranslator.getPinotDocId(doc));
    }
  };
}
 

ProfileScorer(ProfileWeight w, Scorer scorer, QueryProfileBreakdown profile) throws IOException {
    super(w);
    this.scorer = scorer;
    this.profileWeight = w;
    scoreTimer = profile.getTimer(QueryTimingType.SCORE);
    nextDocTimer = profile.getTimer(QueryTimingType.NEXT_DOC);
    advanceTimer = profile.getTimer(QueryTimingType.ADVANCE);
    matchTimer = profile.getTimer(QueryTimingType.MATCH);
    shallowAdvanceTimer = profile.getTimer(QueryTimingType.SHALLOW_ADVANCE);
    computeMaxScoreTimer = profile.getTimer(QueryTimingType.COMPUTE_MAX_SCORE);
    ProfileScorer profileScorer = null;
    if (w.getQuery() instanceof ConstantScoreQuery && scorer instanceof ProfileScorer) {
        //Case when we have a totalHits query and it is not cached
        profileScorer = (ProfileScorer) scorer;
    } else if (w.getQuery() instanceof ConstantScoreQuery && scorer.getChildren().size() == 1) {
        //Case when we have a top N query. If the scorer has no children, it is because it is cached
        //and in that case we do not do any special treatment
        Scorable childScorer = scorer.getChildren().iterator().next().child;
        if (childScorer instanceof ProfileScorer) {
            profileScorer = (ProfileScorer) childScorer;
        }
    }
    if (profileScorer != null) {
        isConstantScoreQuery = true;
        profile.setTimer(QueryTimingType.NEXT_DOC, profileScorer.nextDocTimer);
        profile.setTimer(QueryTimingType.ADVANCE, profileScorer.advanceTimer);
        profile.setTimer(QueryTimingType.MATCH, profileScorer.matchTimer);
    } else {
        isConstantScoreQuery = false;
    }
}
 

@Override
public void setScorer(Scorable scorer) throws IOException {
    if (!(scorer instanceof ScoreCachingWrappingScorer)) {
        scorer = new ScoreCachingWrappingScorer(scorer);
    }
    this.scorer = scorer;
    leafCollector.setScorer(scorer);
}
 

protected SortingGroupHead(Sort sort, T groupValue, int doc, LeafReaderContext context, Scorable scorer) throws IOException {
  super(groupValue, doc, context.docBase);
  final SortField[] sortFields = sort.getSort();
  comparators = new FieldComparator[sortFields.length];
  leafComparators = new LeafFieldComparator[sortFields.length];
  for (int i = 0; i < sortFields.length; i++) {
    comparators[i] = sortFields[i].getComparator(1, i);
    leafComparators[i] = comparators[i].getLeafComparator(context);
    leafComparators[i].setScorer(scorer);
    leafComparators[i].copy(0, doc);
    leafComparators[i].setBottom(0);
  }
}
 

@Override
public void setScorer(Scorable scorer) throws IOException {
  this.scorer = scorer;
  for (GroupHead<T> head : heads.values()) {
    head.setScorer(scorer);
  }
}
 

@Override
public void setScorer(Scorable scorer) {
  this.scorer = scorer;
}
 

@Override
public void setScorer(Scorable scorer) {
    this.scorer = scorer;
}
 

public void setScorer(final Scorable scorer) {
    inner.setScorer(scorer);
}
 

@Override
public void setScorer(Scorable scorer) {
}
 

@Override
public void setScorer(Scorable scorer) throws IOException {
    raiseIfKilled.run();
    delegate.setScorer(scorer);
}
 

@Override
public void setScorer(Scorable scorer) {
}
 

@Override
public void setScorer(Scorable scorer) {
}
 

public void setScorer(Scorable scorer) throws IOException{
  leafCollector.setScorer(scorer);
}
 

@Override
public void setScorer(Scorable s) throws IOException {
  super.setScorer(s);
  this.compareState.setScorer(s);
}
 

public void setScorer(Scorable scorer) throws IOException {
  this.scorer = scorer;
}
 

@Override
public void setScorer(Scorable scorer) throws IOException {
  this.collapseStrategy.setScorer(scorer);
}
 

public void setScorer(Scorable scorer) throws IOException {
  this.collapseStrategy.setScorer(scorer);
}
 

@Override
public void setScorer(Scorable scorer) {}
 

@Override
public void setScorer(Scorable scorer) {}
 

@Override
public void setScorer(Scorable scorer) throws IOException {
  this.scorer = scorer;
}
 

@Override
protected QueryMatch doMatch(String queryId, int doc, Scorable scorer) {
  return new QueryMatch(queryId);
}