Java 类org.apache.lucene.search.similarities.ClassicSimilarity 实例源码

@Override
public Query rewrite(IndexReader reader) throws IOException {
    Query rewritten = super.rewrite(reader);
    if (rewritten != this) {
        return rewritten;
    }
    XMoreLikeThis mlt = new XMoreLikeThis(reader, similarity == null ? new ClassicSimilarity() : similarity);

    mlt.setFieldNames(moreLikeFields);
    mlt.setAnalyzer(analyzer);
    mlt.setMinTermFreq(minTermFrequency);
    mlt.setMinDocFreq(minDocFreq);
    mlt.setMaxDocFreq(maxDocFreq);
    mlt.setMaxQueryTerms(maxQueryTerms);
    mlt.setMinWordLen(minWordLen);
    mlt.setMaxWordLen(maxWordLen);
    mlt.setStopWords(stopWords);
    mlt.setBoost(boostTerms);
    mlt.setBoostFactor(boostTermsFactor);

    if (this.unlikeText != null || this.unlikeFields != null) {
        handleUnlike(mlt, this.unlikeText, this.unlikeFields);
    }

    return createQuery(mlt);
}

public TermVectorsFilter(Fields termVectorsByField, Fields topLevelFields, Set<String> selectedFields, @Nullable AggregatedDfs dfs) {
    this.fields = termVectorsByField;
    this.topLevelFields = topLevelFields;
    this.selectedFields = selectedFields;

    this.dfs = dfs;
    this.scoreTerms = new HashMap<>();
    this.similarity = new ClassicSimilarity();
}

@Before
public void setupIndex() throws IOException {
    dirUnderTest = newDirectory();
    List<Similarity> sims = Arrays.asList(
            new ClassicSimilarity(),
            new SweetSpotSimilarity(), // extends Classic
            new BM25Similarity(),
            new LMDirichletSimilarity(),
            new BooleanSimilarity(),
            new LMJelinekMercerSimilarity(0.2F),
            new AxiomaticF3LOG(0.5F, 10),
            new DFISimilarity(new IndependenceChiSquared()),
            new DFRSimilarity(new BasicModelBE(), new AfterEffectB(), new NormalizationH1()),
            new IBSimilarity(new DistributionLL(), new LambdaDF(), new NormalizationH3())
        );
    similarity = sims.get(random().nextInt(sims.size()));

    indexWriterUnderTest = new RandomIndexWriter(random(), dirUnderTest, newIndexWriterConfig().setSimilarity(similarity));
    for (int i = 0; i < docs.length; i++) {
        Document doc = new Document();
        doc.add(newStringField("id", "" + i, Field.Store.YES));
        doc.add(newField("field", docs[i], Store.YES));
        indexWriterUnderTest.addDocument(doc);
    }
    indexWriterUnderTest.commit();
    indexWriterUnderTest.forceMerge(1);
    indexWriterUnderTest.flush();


    indexReaderUnderTest = indexWriterUnderTest.getReader();
    searcherUnderTest = newSearcher(indexReaderUnderTest);
    searcherUnderTest.setSimilarity(similarity);
}

public static IndexSearcher newSearcher(IndexReader r, boolean wrapWithAssertions) {
    Random random = new Random();

    int threads = 0;
    final ThreadPoolExecutor ex;
    if (random.nextBoolean()) {
        ex = null;
    } else {
        threads = randomIntBetween(random, 1, 8);
        ex = new ThreadPoolExecutor(threads, threads, 0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(),
                new NamedThreadFactory("LuceneTestCase"));
    }
    if (ex != null) {
        r.addReaderClosedListener(new IndexReader.ReaderClosedListener() {
            @Override
            public void onClose(IndexReader reader) {
                shutdownExecutorService(ex);
            }
        });
    }
    IndexSearcher ret;
    if (wrapWithAssertions) {
        ret = random.nextBoolean()
                ? new AssertingIndexSearcher(random, r, ex)
                : new AssertingIndexSearcher(random, r.getContext(), ex);
    } else {
        ret = random.nextBoolean()
                ? new IndexSearcher(r, ex)
                : new IndexSearcher(r.getContext(), ex);
    }
    ret.setSimilarity(new ClassicSimilarity());
    return ret;

}

public DocFreq(IndexReader indexReader, String field) {
    this.indexReader = indexReader;
    this.field = field;
    this.docFreqMap = new HashMap<>();
    this.similarity = new ClassicSimilarity();
    this.numDocs = indexReader.numDocs();
}

private PerFieldSimilarityWrapper getSimilarity(final QueryWithFilters queryWithFilters) {
    return new PerFieldSimilarityWrapper() {
        @Override
        public Similarity get(String name) {

            AnalyzerSettings analyzerSettings = indexConfig.getAnalyzerSettingsForIndexField(name);
            AnalyzerSettings.Similarity similarity = AnalyzerSettings.Similarity.BM25;
            if (analyzerSettings != null) {
                similarity = analyzerSettings.getSimilarity();
            }

            AnalyzerSettings.Similarity fieldSimilarityOverride = queryWithFilters.getFieldSimilarityOverride(name);
            if (fieldSimilarityOverride != null) {
                similarity = fieldSimilarityOverride;
            }

            if (AnalyzerSettings.Similarity.TFIDF.equals(similarity)) {
                return new ClassicSimilarity();
            }
            else if (AnalyzerSettings.Similarity.BM25.equals(similarity)) {
                return new BM25Similarity();
            }
            else if (AnalyzerSettings.Similarity.CONSTANT.equals(similarity)) {
                return new ConstantSimilarity();
            }
            else if (AnalyzerSettings.Similarity.TF.equals(similarity)) {
                return new TFSimilarity();
            }
            else {
                throw new RuntimeException("Unknown similarity type <" + similarity + ">");
            }
        }
    };
}

/**
 * {@inheritDoc}
 */
@Override
public ClassicSimilarity get() {
    return similarity;
}

/**
 * Constructor requiring an IndexReader.
 */
public XMoreLikeThis(IndexReader ir) {
    this(ir, new ClassicSimilarity());
}

public IndexSearcher setSimilarity(IndexSearcher searcher) {
    Similarity similarity = random().nextBoolean() ? new BM25Similarity() : new ClassicSimilarity();
    searcher.setSimilarity(similarity);
    return searcher;
}

public void testOverrideDefaultSimilarity() {
    Settings settings = Settings.builder().put("index.similarity.default.type", "classic").build();
    IndexSettings indexSettings = IndexSettingsModule.newIndexSettings("test", settings);
    SimilarityService service = new SimilarityService(indexSettings, Collections.emptyMap());
    assertTrue(service.getDefaultSimilarity() instanceof ClassicSimilarity);
}

public void testResolveDefaultSimilarities() {
    SimilarityService similarityService = createIndex("foo").similarityService();
    assertThat(similarityService.getSimilarity("classic").get(), instanceOf(ClassicSimilarity.class));
    assertThat(similarityService.getSimilarity("BM25").get(), instanceOf(BM25Similarity.class));
    assertThat(similarityService.getSimilarity("default"), equalTo(null));
}

/**
 * Constructor requiring an IndexReader.
 */
public RelevancyFeedback(IndexReader ir) {
    this(ir, new ClassicSimilarity());
}

/**
 * Constructor requiring an IndexReader.
 */
public MoreLikeThis(IndexReader ir) {
    this(ir, new ClassicSimilarity());
}