Apache Solr open-source search software
SOLR-15538 Update Lucene Preview Release dependency.
Mark Robert Miller797bb38c50fe
diff --git a/gradle/globals.gradle b/gradle/globals.gradleindex 816d77b317d..bf84fcaae6e 100644--- a/gradle/globals.gradle+++ b/gradle/globals.gradle@@ -20,7 +20,7 @@ allprojects {group "org.apache"- def lucenePrereleaseBuild = '5'+ def lucenePrereleaseBuild = '9'// Repositories to fetch dependencies from.repositories {diff --git a/solr/contrib/analysis-extras/src/test/org/apache/solr/schema/TestICUCollationField.java b/solr/contrib/analysis-extras/src/test/org/apache/solr/schema/TestICUCollationField.javaindex 844abade9f7..6c4ecb5074b 100644--- a/solr/contrib/analysis-extras/src/test/org/apache/solr/schema/TestICUCollationField.java+++ b/solr/contrib/analysis-extras/src/test/org/apache/solr/schema/TestICUCollationField.java@@ -98,7 +98,7 @@ public class TestICUCollationField extends SolrTestCaseJ4 {Mockito.when(loader.openResource(Mockito.anyString())).thenReturn(new ByteArrayInputStream(tailoredRules.getBytes(StandardCharsets.UTF_8)));} else {- loader = new FilesystemResourceLoader(confDir.toPath());+ loader = new FilesystemResourceLoader(confDir.toPath(), TestICUCollationField.class.getClassLoader());}final Collator readCollator = ICUCollationField.createFromRules(osFileName, loader);assertEquals(tailoredCollator, readCollator);diff --git a/solr/core/src/java/org/apache/solr/analysis/TokenizerChain.java b/solr/core/src/java/org/apache/solr/analysis/TokenizerChain.javaindex 9533f3dc394..611e3cf16a2 100644--- a/solr/core/src/java/org/apache/solr/analysis/TokenizerChain.java+++ b/solr/core/src/java/org/apache/solr/analysis/TokenizerChain.java@@ -49,7 +49,6 @@ public final class TokenizerChain extends SolrAnalyzer {customAnalyzer.getTokenizerFactory(),customAnalyzer.getTokenFilterFactories().toArray(new TokenFilterFactory[0]));setPositionIncrementGap(customAnalyzer.getPositionIncrementGap(null));- setVersion(customAnalyzer.getVersion());assert customAnalyzer.getOffsetGap(null) == 1; // note: we don't support setting the offset gap}diff --git a/solr/core/src/java/org/apache/solr/highlight/DefaultSolrHighlighter.java b/solr/core/src/java/org/apache/solr/highlight/DefaultSolrHighlighter.javaindex dba39e6bb0d..a92005fe602 100644--- a/solr/core/src/java/org/apache/solr/highlight/DefaultSolrHighlighter.java+++ b/solr/core/src/java/org/apache/solr/highlight/DefaultSolrHighlighter.java@@ -972,12 +972,14 @@ public class DefaultSolrHighlighter extends SolrHighlighter implements PluginInf}}+/*** Wraps a DirectoryReader that caches the {@link LeafReader#getTermVectors(int)} so that* if the next call has the same ID, then it is reused.*/static class TermVectorReusingLeafReader extends FilterLeafReader {+private int lastDocId = -1;private Fields tvFields;@@ -994,6 +996,7 @@ public class DefaultSolrHighlighter extends SolrHighlighter implements PluginInfreturn tvFields;}+@Overridepublic CacheHelper getCoreCacheHelper() {return null;diff --git a/solr/core/src/java/org/apache/solr/index/SlowCompositeReaderWrapper.java b/solr/core/src/java/org/apache/solr/index/SlowCompositeReaderWrapper.javaindex 14b4c0ff976..981f5a9d264 100644--- a/solr/core/src/java/org/apache/solr/index/SlowCompositeReaderWrapper.java+++ b/solr/core/src/java/org/apache/solr/index/SlowCompositeReaderWrapper.java@@ -241,10 +241,9 @@ public final class SlowCompositeReaderWrapper extends LeafReader {ensureOpen();return MultiDocValues.getNormValues(in, field); // TODO cache?}-+@Overridepublic Fields getTermVectors(int docID) throws IOException {- ensureOpen();return in.getTermVectors(docID);}@@ -281,13 +280,12 @@ public final class SlowCompositeReaderWrapper extends LeafReader {@Overridepublic VectorValues getVectorValues(String field) {ensureOpen();- return null; // because not supported. Throw UOE?+ return VectorValues.EMPTY;}@Override- public TopDocs searchNearestVectors(String field, float[] target, int k, int fanout)+ public TopDocs searchNearestVectors(String field, float[] target, int k, Bits acceptDocs)throws IOException {- ensureOpen();return null; // because not supported. Throw UOE?}diff --git a/solr/core/src/java/org/apache/solr/parser/SolrQueryParserBase.java b/solr/core/src/java/org/apache/solr/parser/SolrQueryParserBase.javaindex fc12c6b1b44..54b05749012 100644--- a/solr/core/src/java/org/apache/solr/parser/SolrQueryParserBase.java+++ b/solr/core/src/java/org/apache/solr/parser/SolrQueryParserBase.java@@ -1254,7 +1254,7 @@ public abstract class SolrQueryParserBase extends QueryBuilder {Automata.makeChar(factory.getMarkerChar()),Automata.makeAnyString());// subtract these away- automaton = Operations.minus(automaton, falsePositives, Operations.DEFAULT_MAX_DETERMINIZED_STATES);+ automaton = Operations.minus(automaton, falsePositives, Operations.DEFAULT_DETERMINIZE_WORK_LIMIT);}return new AutomatonQuery(term, automaton) {// override toString so it's completely transparentdiff --git a/solr/core/src/java/org/apache/solr/schema/FieldType.java b/solr/core/src/java/org/apache/solr/schema/FieldType.javaindex f3e995c3966..0a7a47a5b39 100644--- a/solr/core/src/java/org/apache/solr/schema/FieldType.java+++ b/solr/core/src/java/org/apache/solr/schema/FieldType.java@@ -64,7 +64,6 @@ import org.apache.lucene.util.BytesRef;import org.apache.lucene.util.BytesRefBuilder;import org.apache.lucene.util.CharsRef;import org.apache.lucene.util.CharsRefBuilder;-import org.apache.lucene.util.Version;import org.apache.solr.analysis.SolrAnalyzer;import org.apache.solr.analysis.TokenizerChain;import org.apache.solr.common.IteratorWriter;@@ -1264,9 +1263,6 @@ public abstract class FieldType extends FieldProperties {}} else { // analyzer is not instanceof TokenizerChainanalyzerProps.add(CLASS_NAME, analyzer.getClass().getName());- if (analyzer.getVersion() != Version.LATEST) {- analyzerProps.add(LUCENE_MATCH_VERSION_PARAM, analyzer.getVersion().toString());- }}return analyzerProps;}diff --git a/solr/core/src/java/org/apache/solr/schema/FieldTypePluginLoader.java b/solr/core/src/java/org/apache/solr/schema/FieldTypePluginLoader.javaindex 2e35dc5690e..8693e7646ed 100644--- a/solr/core/src/java/org/apache/solr/schema/FieldTypePluginLoader.java+++ b/solr/core/src/java/org/apache/solr/schema/FieldTypePluginLoader.java@@ -221,7 +221,6 @@ public final class FieldTypePluginLoader"Configuration Error: Analyzer '" + clazz.getName() +"' needs a '" + IndexSchema.LUCENE_MATCH_VERSION_PARAM + "' parameter");}- analyzer.setVersion(luceneMatchVersion);return analyzer;} catch (Exception e) {log.error("Cannot load analyzer: {}", analyzerName, e);diff --git a/solr/core/src/java/org/apache/solr/schema/SchemaField.java b/solr/core/src/java/org/apache/solr/schema/SchemaField.javaindex 3d7740ecf4b..ebb3c0cfc7a 100644--- a/solr/core/src/java/org/apache/solr/schema/SchemaField.java+++ b/solr/core/src/java/org/apache/solr/schema/SchemaField.java@@ -26,7 +26,7 @@ import org.apache.lucene.index.DocValuesType;import org.apache.lucene.index.IndexOptions;import org.apache.lucene.index.IndexableField;import org.apache.lucene.index.IndexableFieldType;-import org.apache.lucene.index.VectorValues;+import org.apache.lucene.index.VectorSimilarityFunction;import org.apache.lucene.search.SortField;import org.apache.solr.common.SolrException;import org.apache.solr.common.util.SimpleOrderedMap;@@ -454,8 +454,8 @@ public final class SchemaField extends FieldProperties implements IndexableField}@Override- public VectorValues.SimilarityFunction vectorSimilarityFunction() {- return VectorValues.SimilarityFunction.NONE;+ public VectorSimilarityFunction vectorSimilarityFunction() {+ return VectorSimilarityFunction.EUCLIDEAN;}@Overridediff --git a/solr/core/src/java/org/apache/solr/search/ExtendedDismaxQParser.java b/solr/core/src/java/org/apache/solr/search/ExtendedDismaxQParser.javaindex 42fa5043a79..1663c939861 100644--- a/solr/core/src/java/org/apache/solr/search/ExtendedDismaxQParser.java+++ b/solr/core/src/java/org/apache/solr/search/ExtendedDismaxQParser.java@@ -40,6 +40,7 @@ import org.apache.lucene.queries.function.FunctionScoreQuery;import org.apache.lucene.queries.function.ValueSource;import org.apache.lucene.queries.function.valuesource.ProductFloatFunction;import org.apache.lucene.queries.function.valuesource.QueryValueSource;+import org.apache.lucene.queries.spans.SpanQuery;import org.apache.lucene.search.BooleanClause;import org.apache.lucene.search.BooleanQuery;import org.apache.lucene.search.BoostQuery;@@ -48,7 +49,6 @@ import org.apache.lucene.search.MatchAllDocsQuery;import org.apache.lucene.search.MultiPhraseQuery;import org.apache.lucene.search.PhraseQuery;import org.apache.lucene.search.Query;-import org.apache.lucene.search.spans.SpanQuery;import org.apache.solr.analysis.TokenizerChain;import org.apache.solr.common.SolrException;import org.apache.solr.common.SolrException.ErrorCode;diff --git a/solr/core/src/java/org/apache/solr/search/PayloadCheckQParserPlugin.java b/solr/core/src/java/org/apache/solr/search/PayloadCheckQParserPlugin.javaindex a4a3db518fa..811fe6b6030 100644--- a/solr/core/src/java/org/apache/solr/search/PayloadCheckQParserPlugin.java+++ b/solr/core/src/java/org/apache/solr/search/PayloadCheckQParserPlugin.java@@ -31,8 +31,8 @@ import org.apache.lucene.analysis.payloads.PayloadEncoder;import org.apache.lucene.queries.payloads.SpanPayloadCheckQuery;import org.apache.lucene.queries.payloads.SpanPayloadCheckQuery.MatchOperation;import org.apache.lucene.queries.payloads.SpanPayloadCheckQuery.PayloadType;+import org.apache.lucene.queries.spans.SpanQuery;import org.apache.lucene.search.Query;-import org.apache.lucene.search.spans.SpanQuery;import org.apache.lucene.util.BytesRef;import org.apache.solr.common.SolrException;import org.apache.solr.common.params.SolrParams;diff --git a/solr/core/src/java/org/apache/solr/search/PayloadScoreQParserPlugin.java b/solr/core/src/java/org/apache/solr/search/PayloadScoreQParserPlugin.javaindex 45f39c72c49..a2797a2be61 100644--- a/solr/core/src/java/org/apache/solr/search/PayloadScoreQParserPlugin.java+++ b/solr/core/src/java/org/apache/solr/search/PayloadScoreQParserPlugin.java@@ -23,8 +23,8 @@ import org.apache.lucene.analysis.Analyzer;import org.apache.lucene.queries.payloads.PayloadDecoder;import org.apache.lucene.queries.payloads.PayloadFunction;import org.apache.lucene.queries.payloads.PayloadScoreQuery;+import org.apache.lucene.queries.spans.SpanQuery;import org.apache.lucene.search.Query;-import org.apache.lucene.search.spans.SpanQuery;import org.apache.solr.common.SolrException;import org.apache.solr.common.params.SolrParams;import org.apache.solr.request.SolrQueryRequest;diff --git a/solr/core/src/java/org/apache/solr/search/similarities/BM25SimilarityFactory.java b/solr/core/src/java/org/apache/solr/search/similarities/BM25SimilarityFactory.javaindex 2a01d280450..8c1661ee317 100644--- a/solr/core/src/java/org/apache/solr/search/similarities/BM25SimilarityFactory.java+++ b/solr/core/src/java/org/apache/solr/search/similarities/BM25SimilarityFactory.java@@ -23,6 +23,7 @@ import org.apache.solr.schema.SimilarityFactory;/*** Factory for BM25Similarity. This is the default similarity since 8.x.+ ** <p>* Parameters:* <ul>diff --git a/solr/core/src/java/org/apache/solr/search/similarities/SchemaSimilarityFactory.java b/solr/core/src/java/org/apache/solr/search/similarities/SchemaSimilarityFactory.javaindex d08e918ed35..9609e0f991f 100644--- a/solr/core/src/java/org/apache/solr/search/similarities/SchemaSimilarityFactory.java+++ b/solr/core/src/java/org/apache/solr/search/similarities/SchemaSimilarityFactory.java@@ -31,11 +31,15 @@ import org.apache.solr.util.plugin.SolrCoreAware;* <p>* <code>SimilarityFactory</code> that returns a global {@link PerFieldSimilarityWrapper}* that delegates to the field type, if it's configured. For field types that- * do not have a <code>Similarity</code> explicitly configured, the global <code>Similarity</code>- * will use per fieldtype defaults -- either based on an explicitly configured- * <code>defaultSimFromFieldType</code> or {@link BM25Similarity} as a sensible default.+ * do not have a <code>Similarity</code> explicitly configured, the global <code>Similarity</code>+ * will use per fieldtype defaults -- either based on an explicitly configured+ * <code>defaultSimFromFieldType</code> a sensible default:+ * </p>+ * <ul>+ * <li><code>luceneMatchVersion >= 8.0</code> = {@link BM25Similarity}</li>+ * </ul>* <p>- * The <code>defaultSimFromFieldType</code> option accepts the name of any fieldtype, and uses+ * The <code>defaultSimFromFieldType</code> option accepts the name of any fieldtype, and uses* whatever <code>Similarity</code> is explicitly configured for that fieldType as the default for* all other field types. For example:* </p>@@ -55,15 +59,15 @@ import org.apache.solr.util.plugin.SolrCoreAware;* </fieldType>* </pre>* <p>- * In the example above, any fieldtypes that do not define their own <code></similarity/></code>+ * In the example above, any fieldtypes that do not define their own <code></similarity/></code>* will use the <code>Similarity</code> configured for the <code>type-using-custom-dfr</code>.* </p>- *+ ** <p>- * <b>NOTE:</b> Users should be aware that even when this factory uses a single default- * <code>Similarity</code> for some or all fields in a Query, the behavior can be inconsistent- * with the behavior of explicitly configuring that same <code>Similarity</code> globally, because- * of differences in how some multi-field / multi-clause behavior is defined in+ * <b>NOTE:</b> Users should be aware that even when this factory uses a single default+ * <code>Similarity</code> for some or all fields in a Query, the behavior can be inconsistent+ * with the behavior of explicitly configuring that same <code>Similarity</code> globally, because+ * of differences in how some multi-field / multi-clause behavior is defined in* <code>PerFieldSimilarityWrapper</code>.* </p>*@@ -72,9 +76,9 @@ import org.apache.solr.util.plugin.SolrCoreAware;public class SchemaSimilarityFactory extends SimilarityFactory implements SolrCoreAware {private static final String INIT_OPT = "defaultSimFromFieldType";-+private String defaultSimFromFieldType; // set by init, if null use sensible implicit default-+private volatile SolrCore core; // set by inform(SolrCore)private volatile Similarity similarity; // lazy instantiated@@ -82,7 +86,7 @@ public class SchemaSimilarityFactory extends SimilarityFactory implements SolrCopublic void inform(SolrCore core) {this.core = core;}-+@Overridepublic void init(SolrParams args) {defaultSimFromFieldType = args.get(INIT_OPT, null);@@ -97,7 +101,7 @@ public class SchemaSimilarityFactory extends SimilarityFactory implements SolrCoif (null == similarity) {// Need to instantiate lazily, can't do this in inform(SolrCore) because of chicken/egg// circular initialization hell with core.getLatestSchema() to lookup defaultSimFromFieldType-+Similarity defaultSim = null;if (null == defaultSimFromFieldType) {// nothing configured, choose a sensible implicit default...@@ -106,23 +110,23 @@ public class SchemaSimilarityFactory extends SimilarityFactory implements SolrCoFieldType defSimFT = core.getLatestSchema().getFieldTypeByName(defaultSimFromFieldType);if (null == defSimFT) {throw new SolrException(ErrorCode.SERVER_ERROR,- "SchemaSimilarityFactory configured with " + INIT_OPT + "='" +- defaultSimFromFieldType + "' but that <fieldType> does not exist");-+ "SchemaSimilarityFactory configured with " + INIT_OPT + "='" ++ defaultSimFromFieldType + "' but that <fieldType> does not exist");+}defaultSim = defSimFT.getSimilarity();if (null == defaultSim) {throw new SolrException(ErrorCode.SERVER_ERROR,- "SchemaSimilarityFactory configured with " + INIT_OPT + "='" +- defaultSimFromFieldType +- "' but that <fieldType> does not define a <similarity>");+ "SchemaSimilarityFactory configured with " + INIT_OPT + "='" ++ defaultSimFromFieldType ++ "' but that <fieldType> does not define a <similarity>");}}similarity = new SchemaSimilarity(defaultSim);}return similarity;}-+private class SchemaSimilarity extends PerFieldSimilarityWrapper {private Similarity defaultSimilarity;diff --git a/solr/core/src/java/org/apache/solr/spelling/suggest/jaspell/JaspellLookup.java b/solr/core/src/java/org/apache/solr/spelling/suggest/jaspell/JaspellLookup.javanew file mode 100644index 00000000000..ecbb7f6eacf--- /dev/null+++ b/solr/core/src/java/org/apache/solr/spelling/suggest/jaspell/JaspellLookup.java@@ -0,0 +1,208 @@+/*+ * 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.+ */+package org.apache.solr.spelling.suggest.jaspell;++import java.io.IOException;+import java.util.ArrayList;+import java.util.List;+import java.util.Set;+import org.apache.lucene.search.suggest.InputIterator;+import org.apache.lucene.search.suggest.Lookup;+import org.apache.lucene.store.DataInput;+import org.apache.lucene.store.DataOutput;+import org.apache.lucene.util.BytesRef;+import org.apache.lucene.util.CharsRef;+import org.apache.lucene.util.CharsRefBuilder;+import org.apache.solr.spelling.suggest.jaspell.JaspellTernarySearchTrie.TSTNode;++/**+ * Suggest implementation based on <a href="http://jaspell.sourceforge.net/">JaSpell</a>.+ *+ * @see JaspellTernarySearchTrie+ * @deprecated Migrate to one of the newer suggesters which are much more RAM efficient.+ */+@Deprecated+public class JaspellLookup extends Lookup {+ JaspellTernarySearchTrie trie = new JaspellTernarySearchTrie();+ private boolean usePrefix = true;+ private int editDistance = 2;++ /** Number of entries the lookup was built with */+ private long count = 0;++ /**+ * Creates a new empty trie+ *+ * @see #build(InputIterator)+ */+ public JaspellLookup() {}++ @Override+ public void build(InputIterator iterator) throws IOException {+ if (iterator.hasPayloads()) {+ throw new IllegalArgumentException("this suggester doesn't support payloads");+ }+ if (iterator.hasContexts()) {+ throw new IllegalArgumentException("this suggester doesn't support contexts");+ }+ count = 0;+ trie = new JaspellTernarySearchTrie();+ trie.setMatchAlmostDiff(editDistance);+ BytesRef spare;+ final CharsRefBuilder charsSpare = new CharsRefBuilder();++ while ((spare = iterator.next()) != null) {+ final long weight = iterator.weight();+ if (spare.length == 0) {+ continue;+ }+ charsSpare.copyUTF8Bytes(spare);+ trie.put(charsSpare.toString(), weight);+ count++;+ }+ }++ /**+ * Adds a new node if <code>key</code> already exists, otherwise replaces its value.+ *+ * <p>This method always returns false.+ */+ public boolean add(CharSequence key, Object value) {+ trie.put(key, value);+ // XXX+ return false;+ }++ /** Returns the value for the specified key, or null if the key does not exist. */+ public Object get(CharSequence key) {+ return trie.get(key);+ }++ @Override+ public List<LookupResult> lookup(+ CharSequence key, Set<BytesRef> contexts, boolean onlyMorePopular, int num) {+ if (contexts != null) {+ throw new IllegalArgumentException("this suggester doesn't support contexts");+ }+ List<LookupResult> res = new ArrayList<>();+ List<String> list;+ int count = onlyMorePopular ? num * 2 : num;+ if (usePrefix) {+ list = trie.matchPrefix(key, count);+ } else {+ list = trie.matchAlmost(key, count);+ }+ if (list == null || list.size() == 0) {+ return res;+ }+ int maxCnt = Math.min(num, list.size());+ if (onlyMorePopular) {+ LookupPriorityQueue queue = new LookupPriorityQueue(num);+ for (String s : list) {+ long freq = ((Number) trie.get(s)).longValue();+ queue.insertWithOverflow(new LookupResult(new CharsRef(s), freq));+ }+ for (LookupResult lr : queue.getResults()) {+ res.add(lr);+ }+ } else {+ for (int i = 0; i < maxCnt; i++) {+ String s = list.get(i);+ long freq = ((Number) trie.get(s)).longValue();+ res.add(new LookupResult(new CharsRef(s), freq));+ }+ }+ return res;+ }++ private static final byte LO_KID = 0x01;+ private static final byte EQ_KID = 0x02;+ private static final byte HI_KID = 0x04;+ private static final byte HAS_VALUE = 0x08;++ private void readRecursively(DataInput in, TSTNode node) throws IOException {+ node.splitchar = in.readString().charAt(0);+ byte mask = in.readByte();+ if ((mask & HAS_VALUE) != 0) {+ node.data = in.readLong();+ }+ if ((mask & LO_KID) != 0) {+ TSTNode kid = new TSTNode('\0', node);+ node.relatives[TSTNode.LOKID] = kid;+ readRecursively(in, kid);+ }+ if ((mask & EQ_KID) != 0) {+ TSTNode kid = new TSTNode('\0', node);+ node.relatives[TSTNode.EQKID] = kid;+ readRecursively(in, kid);+ }+ if ((mask & HI_KID) != 0) {+ TSTNode kid = new TSTNode('\0', node);+ node.relatives[TSTNode.HIKID] = kid;+ readRecursively(in, kid);+ }+ }++ private void writeRecursively(DataOutput out, TSTNode node) throws IOException {+ if (node == null) {+ return;+ }+ out.writeString(new String(new char[] {node.splitchar}, 0, 1));+ byte mask = 0;+ if (node.relatives[TSTNode.LOKID] != null) mask |= LO_KID;+ if (node.relatives[TSTNode.EQKID] != null) mask |= EQ_KID;+ if (node.relatives[TSTNode.HIKID] != null) mask |= HI_KID;+ if (node.data != null) mask |= HAS_VALUE;+ out.writeByte(mask);+ if (node.data != null) {+ out.writeLong(((Number) node.data).longValue());+ }+ writeRecursively(out, node.relatives[TSTNode.LOKID]);+ writeRecursively(out, node.relatives[TSTNode.EQKID]);+ writeRecursively(out, node.relatives[TSTNode.HIKID]);+ }++ @Override+ public boolean store(DataOutput output) throws IOException {+ output.writeVLong(count);+ TSTNode root = trie.getRoot();+ if (root == null) { // empty tree+ return false;+ }+ writeRecursively(output, root);+ return true;+ }++ @Override+ public boolean load(DataInput input) throws IOException {+ count = input.readVLong();+ TSTNode root = new TSTNode('\0', null);+ readRecursively(input, root);+ trie.setRoot(root);+ return true;+ }++ @Override+ public long ramBytesUsed() {+ return trie.ramBytesUsed();+ }++ @Override+ public long getCount() {+ return count;+ }+}diff --git a/solr/core/src/java/org/apache/solr/spelling/suggest/jaspell/JaspellLookupFactory.java b/solr/core/src/java/org/apache/solr/spelling/suggest/jaspell/JaspellLookupFactory.javaindex f64bc986210..07c99781168 100644--- a/solr/core/src/java/org/apache/solr/spelling/suggest/jaspell/JaspellLookupFactory.java+++ b/solr/core/src/java/org/apache/solr/spelling/suggest/jaspell/JaspellLookupFactory.java@@ -19,7 +19,6 @@ package org.apache.solr.spelling.suggest.jaspell;import java.lang.invoke.MethodHandles;import org.apache.lucene.search.suggest.Lookup;-import org.apache.lucene.search.suggest.jaspell.JaspellLookup;import org.apache.solr.common.util.NamedList;import org.apache.solr.core.SolrCore;import org.apache.solr.spelling.suggest.LookupFactory;diff --git a/solr/core/src/java/org/apache/solr/spelling/suggest/jaspell/JaspellTernarySearchTrie.java b/solr/core/src/java/org/apache/solr/spelling/suggest/jaspell/JaspellTernarySearchTrie.javanew file mode 100644index 00000000000..4aad9c33877--- /dev/null+++ b/solr/core/src/java/org/apache/solr/spelling/suggest/jaspell/JaspellTernarySearchTrie.java@@ -0,0 +1,831 @@+/*+ * Copyright (c) 2005 Bruno Martins+ * All rights reserved.+ *+ * Redistribution and use in source and binary forms, with or without+ * modification, are permitted provided that the following conditions+ * are met:+ * 1. Redistributions of source code must retain the above copyright+ * notice, this list of conditions and the following disclaimer.+ * 2. Redistributions in binary form must reproduce the above copyright+ * notice, this list of conditions and the following disclaimer in the+ * documentation and/or other materials provided with the distribution.+ * 3. Neither the name of the organization nor the names of its contributors+ * may be used to endorse or promote products derived from this software+ * without specific prior written permission.+ *+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF+ * THE POSSIBILITY OF SUCH DAMAGE.+ */+package org.apache.solr.spelling.suggest.jaspell;++import java.io.BufferedReader;+import java.io.IOException;+import java.nio.charset.StandardCharsets;+import java.nio.file.Files;+import java.nio.file.Path;+import java.util.List;+import java.util.Locale;+import java.util.Vector;+import java.util.zip.GZIPInputStream;+import org.apache.lucene.util.Accountable;+import org.apache.lucene.util.IOUtils;+import org.apache.lucene.util.RamUsageEstimator;++/**+ * Implementation of a Ternary Search Trie, a data structure for storing <code>String</code> objects+ * that combines the compact size of a binary search tree with the speed of a digital search trie,+ * and is therefore ideal for practical use in sorting and searching data.+ *+ * <p>This data structure is faster than hashing for many typical search problems, and supports a+ * broader range of useful problems and operations. Ternary searches are faster than hashing and+ * more powerful, too.+ *+ * <p>The theory of ternary search trees was described at a symposium in 1997 (see "Fast Algorithms+ * for Sorting and Searching Strings," by J.L. Bentley and R. Sedgewick, Proceedings of the 8th+ * Annual ACM-SIAM Symposium on Discrete Algorithms, January 1997). Algorithms in C, Third Edition,+ * by Robert Sedgewick (Addison-Wesley, 1998) provides yet another view of ternary search trees.+ *+ * @deprecated Migrate to one of the newer suggesters which are much more RAM efficient.+ */+@Deprecated+public class JaspellTernarySearchTrie implements Accountable {++ /** An inner class of Ternary Search Trie that represents a node in the trie. */+ protected static final class TSTNode implements Accountable {++ /** Index values for accessing relatives array. */+ protected static final int PARENT = 0, LOKID = 1, EQKID = 2, HIKID = 3;++ /** The key to the node. */+ protected Object data;++ /** The relative nodes. */+ protected final TSTNode[] relatives = new TSTNode[4];++ /** The char used in the split. */+ protected char splitchar;++ /**+ * Constructor method.+ *+ * @param splitchar The char used in the split.+ * @param parent The parent node.+ */+ protected TSTNode(char splitchar, TSTNode parent) {+ this.splitchar = splitchar;+ relatives[PARENT] = parent;+ }++ @Override+ public long ramBytesUsed() {+ long mem = RamUsageEstimator.shallowSizeOf(this) + RamUsageEstimator.shallowSizeOf(relatives);+ // We don't need to add parent since our parent added itself:+ for (int i = 1; i < 4; i++) {+ TSTNode node = relatives[i];+ if (node != null) {+ mem += node.ramBytesUsed();+ }+ }+ return mem;+ }+ }++ /**+ * Compares characters by alphabetical order.+ *+ * @param cCompare2 The first char in the comparison.+ * @param cRef The second char in the comparison.+ * @return A negative number, 0 or a positive number if the second char is less, equal or greater.+ */+ private static int compareCharsAlphabetically(char cCompare2, char cRef) {+ return Character.toLowerCase(cCompare2) - Character.toLowerCase(cRef);+ }++ /* what follows is the original Jaspell code.+ private static int compareCharsAlphabetically(int cCompare2, int cRef) {+ int cCompare = 0;+ if (cCompare2 >= 65) {+ if (cCompare2 < 89) {+ cCompare = (2 * cCompare2) - 65;+ } else if (cCompare2 < 97) {+ cCompare = cCompare2 + 24;+ } else if (cCompare2 < 121) {+ cCompare = (2 * cCompare2) - 128;+ } else cCompare = cCompare2;+ } else cCompare = cCompare2;+ if (cRef < 65) {+ return cCompare - cRef;+ }+ if (cRef < 89) {+ return cCompare - ((2 * cRef) - 65);+ }+ if (cRef < 97) {+ return cCompare - (cRef + 24);+ }+ if (cRef < 121) {+ return cCompare - ((2 * cRef) - 128);+ }+ return cCompare - cRef;+ }+ */++ /** The default number of values returned by the <code>matchAlmost</code> method. */+ private int defaultNumReturnValues = -1;++ /** the number of differences allowed in a call to the <code>matchAlmostKey</code> method. */+ private int matchAlmostDiff;++ /** The base node in the trie. */+ private TSTNode rootNode;++ private final Locale locale;++ /** Constructs an empty Ternary Search Trie. */+ public JaspellTernarySearchTrie() {+ this(Locale.ROOT);+ }++ /** Constructs an empty Ternary Search Trie, specifying the Locale used for lowercasing. */+ public JaspellTernarySearchTrie(Locale locale) {+ this.locale = locale;+ }++ // for loading+ void setRoot(TSTNode newRoot) {+ rootNode = newRoot;+ }++ // for saving+ TSTNode getRoot() {+ return rootNode;+ }++ /**+ * Constructs a Ternary Search Trie and loads data from a <code>Path</code> into the Trie. The+ * file is a normal text document, where each line is of the form word TAB float.+ *+ * @param file The <code>Path</code> with the data to load into the Trie.+ * @exception IOException A problem occurred while reading the data.+ */+ public JaspellTernarySearchTrie(Path file) throws IOException {+ this(file, false);+ }++ /**+ * Constructs a Ternary Search Trie and loads data from a <code>File</code> into the Trie. The+ * file is a normal text document, where each line is of the form "word TAB float".+ *+ * @param file The <code>File</code> with the data to load into the Trie.+ * @param compression If true, the file is compressed with the GZIP algorithm, and if false, the+ * file is a normal text document.+ * @exception IOException A problem occurred while reading the data.+ */+ public JaspellTernarySearchTrie(Path file, boolean compression) throws IOException {+ this();+ BufferedReader in;+ if (compression)+ in =+ new BufferedReader(+ IOUtils.getDecodingReader(+ new GZIPInputStream(Files.newInputStream(file)), StandardCharsets.UTF_8));+ else in = Files.newBufferedReader(file, StandardCharsets.UTF_8);+ try {+ String word;+ int pos;+ Float occur, one = 1f;+ while ((word = in.readLine()) != null) {+ pos = word.indexOf("\t");+ occur = one;+ if (pos != -1) {+ occur = Float.parseFloat(word.substring(pos + 1).trim());+ word = word.substring(0, pos);+ }+ String key = word.toLowerCase(locale);+ if (rootNode == null) {+ rootNode = new TSTNode(key.charAt(0), null);+ }+ TSTNode node = null;+ if (key.length() > 0 && rootNode != null) {+ TSTNode currentNode = rootNode;+ int charIndex = 0;+ while (true) {+ if (currentNode == null) break;+ int charComp = compareCharsAlphabetically(key.charAt(charIndex), currentNode.splitchar);+ if (charComp == 0) {+ charIndex++;+ if (charIndex == key.length()) {+ node = currentNode;+ break;+ }+ currentNode = currentNode.relatives[TSTNode.EQKID];+ } else if (charComp < 0) {+ currentNode = currentNode.relatives[TSTNode.LOKID];+ } else {+ currentNode = currentNode.relatives[TSTNode.HIKID];+ }+ }+ Float occur2 = null;+ if (node != null) occur2 = ((Float) (node.data));+ if (occur2 != null) {+ occur += occur2.floatValue();+ }+ currentNode = getOrCreateNode(word.trim().toLowerCase(locale));+ currentNode.data = occur;+ }+ }+ } finally {+ IOUtils.close(in);+ }+ }++ /**+ * Deletes the node passed in as an argument. If this node has non-null data, then both the node+ * and the data will be deleted. It also deletes any other nodes in the trie that are no longer+ * needed after the deletion of the node.+ *+ * @param nodeToDelete The node to delete.+ */+ private void deleteNode(TSTNode nodeToDelete) {+ if (nodeToDelete == null) {+ return;+ }+ nodeToDelete.data = null;+ while (nodeToDelete != null) {+ nodeToDelete = deleteNodeRecursion(nodeToDelete);+ // deleteNodeRecursion(nodeToDelete);+ }+ }++ /**+ * Recursively visits each node to be deleted.+ *+ * <p>To delete a node, first set its data to null, then pass it into this method, then pass the+ * node returned by this method into this method (make sure you don't delete the data of any of+ * the nodes returned from this method!) and continue in this fashion until the node returned by+ * this method is <code>null</code>.+ *+ * <p>The TSTNode instance returned by this method will be next node to be operated on by <code>+ * deleteNodeRecursion</code> (This emulates recursive method call while avoiding the JVM overhead+ * normally associated with a recursive method.)+ *+ * @param currentNode The node to delete.+ * @return The next node to be called in deleteNodeRecursion.+ */+ private TSTNode deleteNodeRecursion(TSTNode currentNode) {+ if (currentNode == null) {+ return null;+ }+ if (currentNode.relatives[TSTNode.EQKID] != null || currentNode.data != null) {+ return null;+ }+ // can't delete this node if it has a non-null eq kid or data+ TSTNode currentParent = currentNode.relatives[TSTNode.PARENT];+ boolean lokidNull = currentNode.relatives[TSTNode.LOKID] == null;+ boolean hikidNull = currentNode.relatives[TSTNode.HIKID] == null;+ int childType;+ if (currentParent.relatives[TSTNode.LOKID] == currentNode) {+ childType = TSTNode.LOKID;+ } else if (currentParent.relatives[TSTNode.EQKID] == currentNode) {+ childType = TSTNode.EQKID;+ } else if (currentParent.relatives[TSTNode.HIKID] == currentNode) {+ childType = TSTNode.HIKID;+ } else {+ rootNode = null;+ return null;+ }+ if (lokidNull && hikidNull) {+ currentParent.relatives[childType] = null;+ return currentParent;+ }+ if (lokidNull) {+ currentParent.relatives[childType] = currentNode.relatives[TSTNode.HIKID];+ currentNode.relatives[TSTNode.HIKID].relatives[TSTNode.PARENT] = currentParent;+ return currentParent;+ }+ if (hikidNull) {+ currentParent.relatives[childType] = currentNode.relatives[TSTNode.LOKID];+ currentNode.relatives[TSTNode.LOKID].relatives[TSTNode.PARENT] = currentParent;+ return currentParent;+ }+ int deltaHi = currentNode.relatives[TSTNode.HIKID].splitchar - currentNode.splitchar;+ int deltaLo = currentNode.splitchar - currentNode.relatives[TSTNode.LOKID].splitchar;+ int movingKid;+ TSTNode targetNode;+ if (deltaHi == deltaLo) {+ if (Math.random() < 0.5) {+ deltaHi++;+ } else {+ deltaLo++;+ }+ }+ if (deltaHi > deltaLo) {+ movingKid = TSTNode.HIKID;+ targetNode = currentNode.relatives[TSTNode.LOKID];+ } else {+ movingKid = TSTNode.LOKID;+ targetNode = currentNode.relatives[TSTNode.HIKID];+ }+ while (targetNode.relatives[movingKid] != null) {+ targetNode = targetNode.relatives[movingKid];+ }+ targetNode.relatives[movingKid] = currentNode.relatives[movingKid];+ currentParent.relatives[childType] = targetNode;+ targetNode.relatives[TSTNode.PARENT] = currentParent;+ if (!lokidNull) {+ currentNode.relatives[TSTNode.LOKID] = null;+ }+ if (!hikidNull) {+ currentNode.relatives[TSTNode.HIKID] = null;+ }+ return currentParent;+ }++ /**+ * Retrieve the object indexed by a key.+ *+ * @param key A <code>String</code> index.+ * @return The object retrieved from the Ternary Search Trie.+ */+ public Object get(CharSequence key) {+ TSTNode node = getNode(key);+ if (node == null) {+ return null;+ }+ return node.data;+ }++ /**+ * Retrieve the <code>Float</code> indexed by key, increment it by one unit and store the new+ * <code>Float</code>.+ *+ * @param key A <code>String</code> index.+ * @return The <code>Float</code> retrieved from the Ternary Search Trie.+ */+ public Float getAndIncrement(String key) {+ String key2 = key.trim().toLowerCase(locale);+ TSTNode node = getNode(key2);+ if (node == null) {+ return null;+ }+ Float aux = (Float) (node.data);+ if (aux == null) {+ aux = 1f;+ } else {+ aux = (float) (aux.intValue() + 1);+ }+ put(key2, aux);+ return aux;+ }++ /**+ * Returns the key that indexes the node argument.+ *+ * @param node The node whose index is to be calculated.+ * @return The <code>String</code> that indexes the node argument.+ */+ protected String getKey(TSTNode node) {+ StringBuilder getKeyBuffer = new StringBuilder();+ getKeyBuffer.setLength(0);+ getKeyBuffer.append("").append(node.splitchar);+ TSTNode currentNode;+ TSTNode lastNode;+ currentNode = node.relatives[TSTNode.PARENT];+ lastNode = node;+ while (currentNode != null) {+ if (currentNode.relatives[TSTNode.EQKID] == lastNode) {+ getKeyBuffer.append("").append(currentNode.splitchar);+ }+ lastNode = currentNode;+ currentNode = currentNode.relatives[TSTNode.PARENT];+ }+ getKeyBuffer.reverse();+ return getKeyBuffer.toString();+ }++ /**+ * Returns the node indexed by key, or <code>null</code> if that node doesn't exist. Search begins+ * at root node.+ *+ * @param key A <code>String</code> that indexes the node that is returned.+ * @return The node object indexed by key. This object is an instance of an inner class named+ * <code>TernarySearchTrie.TSTNode</code>.+ */+ public TSTNode getNode(CharSequence key) {+ return getNode(key, rootNode);+ }++ /**+ * Returns the node indexed by key, or <code>null</code> if that node doesn't exist. The search+ * begins at root node.+ *+ * @param key A <code>String</code> that indexes the node that is returned.+ * @param startNode The top node defining the subtrie to be searched.+ * @return The node object indexed by key. This object is an instance of an inner class named+ * <code>TernarySearchTrie.TSTNode</code>.+ */+ protected TSTNode getNode(CharSequence key, TSTNode startNode) {+ if (key == null || startNode == null || key.length() == 0) {+ return null;+ }+ TSTNode currentNode = startNode;+ int charIndex = 0;+ while (true) {+ if (currentNode == null) {+ return null;+ }+ int charComp = compareCharsAlphabetically(key.charAt(charIndex), currentNode.splitchar);+ if (charComp == 0) {+ charIndex++;+ if (charIndex == key.length()) {+ return currentNode;+ }+ currentNode = currentNode.relatives[TSTNode.EQKID];+ } else if (charComp < 0) {+ currentNode = currentNode.relatives[TSTNode.LOKID];+ } else {+ currentNode = currentNode.relatives[TSTNode.HIKID];+ }+ }+ }++ /**+ * Returns the node indexed by key, creating that node if it doesn't exist, and creating any+ * required intermediate nodes if they don't exist.+ *+ * @param key A <code>String</code> that indexes the node that is returned.+ * @return The node object indexed by key. This object is an instance of an inner class named+ * <code>TernarySearchTrie.TSTNode</code>.+ * @exception NullPointerException If the key is <code>null</code>.+ * @exception IllegalArgumentException If the key is an empty <code>String</code>.+ */+ protected TSTNode getOrCreateNode(CharSequence key)+ throws NullPointerException, IllegalArgumentException {+ if (key == null) {+ throw new NullPointerException("attempt to get or create node with null key");+ }+ if (key.length() == 0) {+ throw new IllegalArgumentException("attempt to get or create node with key of zero length");+ }+ if (rootNode == null) {+ rootNode = new TSTNode(key.charAt(0), null);+ }+ TSTNode currentNode = rootNode;+ int charIndex = 0;+ while (true) {+ int charComp = compareCharsAlphabetically(key.charAt(charIndex), currentNode.splitchar);+ if (charComp == 0) {+ charIndex++;+ if (charIndex == key.length()) {+ return currentNode;+ }+ if (currentNode.relatives[TSTNode.EQKID] == null) {+ currentNode.relatives[TSTNode.EQKID] = new TSTNode(key.charAt(charIndex), currentNode);+ }+ currentNode = currentNode.relatives[TSTNode.EQKID];+ } else if (charComp < 0) {+ if (currentNode.relatives[TSTNode.LOKID] == null) {+ currentNode.relatives[TSTNode.LOKID] = new TSTNode(key.charAt(charIndex), currentNode);+ }+ currentNode = currentNode.relatives[TSTNode.LOKID];+ } else {+ if (currentNode.relatives[TSTNode.HIKID] == null) {+ currentNode.relatives[TSTNode.HIKID] = new TSTNode(key.charAt(charIndex), currentNode);+ }+ currentNode = currentNode.relatives[TSTNode.HIKID];+ }+ }+ }++ /**+ * Returns a <code>List</code> of keys that almost match the argument key. Keys returned will have+ * exactly diff characters that do not match the target key, where diff is equal to the last value+ * passed in as an argument to the <code>setMatchAlmostDiff</code> method.+ *+ * <p>If the <code>matchAlmost</code> method is called before the <code>setMatchAlmostDiff</code>+ * method has been called for the first time, then diff = 0.+ *+ * @param key The target key.+ * @return A <code>List</code> with the results.+ */+ public List<String> matchAlmost(String key) {+ return matchAlmost(key, defaultNumReturnValues);+ }++ /**+ * Returns a <code>List</code> of keys that almost match the argument key. Keys returned will have+ * exactly diff characters that do not match the target key, where diff is equal to the last value+ * passed in as an argument to the <code>setMatchAlmostDiff</code> method.+ *+ * <p>If the <code>matchAlmost</code> method is called before the <code>setMatchAlmostDiff</code>+ * method has been called for the first time, then diff = 0.+ *+ * @param key The target key.+ * @param numReturnValues The maximum number of values returned by this method.+ * @return A <code>List</code> with the results+ */+ public List<String> matchAlmost(CharSequence key, int numReturnValues) {+ return matchAlmostRecursion(+ rootNode,+ 0,+ matchAlmostDiff,+ key,+ ((numReturnValues < 0) ? -1 : numReturnValues),+ new Vector<String>(),+ false);+ }++ /**+ * Recursivelly vists the nodes in order to find the ones that almost match a given key.+ *+ * @param currentNode The current node.+ * @param charIndex The current char.+ * @param d The number of differences so far.+ * @param matchAlmostNumReturnValues The maximum number of values in the result <code>List</code>.+ * @param matchAlmostResult2 The results so far.+ * @param upTo If true all keys having up to and including matchAlmostDiff mismatched letters will+ * be included in the result (including a key that is exactly the same as the target string)+ * otherwise keys will be included in the result only if they have exactly matchAlmostDiff+ * number of mismatched letters.+ * @param matchAlmostKey The key being searched.+ * @return A <code>List</code> with the results.+ */+ private List<String> matchAlmostRecursion(+ TSTNode currentNode,+ int charIndex,+ int d,+ CharSequence matchAlmostKey,+ int matchAlmostNumReturnValues,+ List<String> matchAlmostResult2,+ boolean upTo) {+ if ((currentNode == null)+ || (matchAlmostNumReturnValues != -1+ && matchAlmostResult2.size() >= matchAlmostNumReturnValues)+ || (d < 0)+ || (charIndex >= matchAlmostKey.length())) {+ return matchAlmostResult2;+ }+ int charComp =+ compareCharsAlphabetically(matchAlmostKey.charAt(charIndex), currentNode.splitchar);+ List<String> matchAlmostResult = matchAlmostResult2;+ if ((d > 0) || (charComp < 0)) {+ matchAlmostResult =+ matchAlmostRecursion(+ currentNode.relatives[TSTNode.LOKID],+ charIndex,+ d,+ matchAlmostKey,+ matchAlmostNumReturnValues,+ matchAlmostResult,+ upTo);+ }+ int nextD = (charComp == 0) ? d : d - 1;+ boolean cond = (upTo) ? (nextD >= 0) : (nextD == 0);+ if ((matchAlmostKey.length() == charIndex + 1) && cond && (currentNode.data != null)) {+ matchAlmostResult.add(getKey(currentNode));+ }+ matchAlmostResult =+ matchAlmostRecursion(+ currentNode.relatives[TSTNode.EQKID],+ charIndex + 1,+ nextD,+ matchAlmostKey,+ matchAlmostNumReturnValues,+ matchAlmostResult,+ upTo);+ if ((d > 0) || (charComp > 0)) {+ matchAlmostResult =+ matchAlmostRecursion(+ currentNode.relatives[TSTNode.HIKID],+ charIndex,+ d,+ matchAlmostKey,+ matchAlmostNumReturnValues,+ matchAlmostResult,+ upTo);+ }+ return matchAlmostResult;+ }++ /**+ * Returns an alphabetical <code>List</code> of all keys in the trie that begin with a given+ * prefix. Only keys for nodes having non-null data are included in the <code>List</code>.+ *+ * @param prefix Each key returned from this method will begin with the characters in prefix.+ * @return A <code>List</code> with the results.+ */+ public List<String> matchPrefix(String prefix) {+ return matchPrefix(prefix, defaultNumReturnValues);+ }++ /**+ * Returns an alphabetical <code>List</code> of all keys in the trie that begin with a given+ * prefix. Only keys for nodes having non-null data are included in the <code>List</code>.+ *+ * @param prefix Each key returned from this method will begin with the characters in prefix.+ * @param numReturnValues The maximum number of values returned from this method.+ * @return A <code>List</code> with the results+ */+ public List<String> matchPrefix(CharSequence prefix, int numReturnValues) {+ Vector<String> sortKeysResult = new Vector<>();+ TSTNode startNode = getNode(prefix);+ if (startNode == null) {+ return sortKeysResult;+ }+ if (startNode.data != null) {+ sortKeysResult.addElement(getKey(startNode));+ }+ return sortKeysRecursion(+ startNode.relatives[TSTNode.EQKID],+ ((numReturnValues < 0) ? -1 : numReturnValues),+ sortKeysResult);+ }++ /**+ * Returns the number of nodes in the trie that have non-null data.+ *+ * @return The number of nodes in the trie that have non-null data.+ */+ public int numDataNodes() {+ return numDataNodes(rootNode);+ }++ /**+ * Returns the number of nodes in the subtrie below and including the starting node. The method+ * counts only nodes that have non-null data.+ *+ * @param startingNode The top node of the subtrie. the node that defines the subtrie.+ * @return The total number of nodes in the subtrie.+ */+ protected int numDataNodes(TSTNode startingNode) {+ return recursiveNodeCalculator(startingNode, true, 0);+ }++ /**+ * Returns the total number of nodes in the trie. The method counts nodes whether or not they have+ * data.+ *+ * @return The total number of nodes in the trie.+ */+ public int numNodes() {+ return numNodes(rootNode);+ }++ /**+ * Returns the total number of nodes in the subtrie below and including the starting Node. The+ * method counts nodes whether or not they have data.+ *+ * @param startingNode The top node of the subtrie. The node that defines the subtrie.+ * @return The total number of nodes in the subtrie.+ */+ protected int numNodes(TSTNode startingNode) {+ return recursiveNodeCalculator(startingNode, false, 0);+ }++ /**+ * Stores a value in the trie. The value may be retrieved using the key.+ *+ * @param key A <code>String</code> that indexes the object to be stored.+ * @param value The object to be stored in the Trie.+ */+ public void put(CharSequence key, Object value) {+ getOrCreateNode(key).data = value;+ }++ /**+ * Recursivelly visists each node to calculate the number of nodes.+ *+ * @param currentNode The current node.+ * @param checkData If true we check the data to be different of <code>null</code>.+ * @param numNodes2 The number of nodes so far.+ * @return The number of nodes accounted.+ */+ private int recursiveNodeCalculator(TSTNode currentNode, boolean checkData, int numNodes2) {+ if (currentNode == null) {+ return numNodes2;+ }+ int numNodes =+ recursiveNodeCalculator(currentNode.relatives[TSTNode.LOKID], checkData, numNodes2);+ numNodes = recursiveNodeCalculator(currentNode.relatives[TSTNode.EQKID], checkData, numNodes);+ numNodes = recursiveNodeCalculator(currentNode.relatives[TSTNode.HIKID], checkData, numNodes);+ if (checkData) {+ if (currentNode.data != null) {+ numNodes++;+ }+ } else {+ numNodes++;+ }+ return numNodes;+ }++ /**+ * Removes the value indexed by key. Also removes all nodes that are rendered unnecessary by the+ * removal of this data.+ *+ * @param key A <code>string</code> that indexes the object to be removed from the Trie.+ */+ public void remove(String key) {+ deleteNode(getNode(key.trim().toLowerCase(locale)));+ }++ /**+ * Sets the number of characters by which words can differ from target word when calling the+ * <code>matchAlmost</code> method.+ *+ * <p>Arguments less than 0 will set the char difference to 0, and arguments greater than 3 will+ * set the char difference to 3.+ *+ * @param diff The number of characters by which words can differ from target word.+ */+ public void setMatchAlmostDiff(int diff) {+ if (diff < 0) {+ matchAlmostDiff = 0;+ } else if (diff > 3) {+ matchAlmostDiff = 3;+ } else {+ matchAlmostDiff = diff;+ }+ }++ /**+ * Sets the default maximum number of values returned from the <code>matchPrefix</code> and <code>+ * matchAlmost</code> methods.+ *+ * <p>The value should be set this to -1 to get an unlimited number of return values. note that+ * the methods mentioned above provide overloaded versions that allow you to specify the maximum+ * number of return values, in which case this value is temporarily overridden.+ *+ * <p>*@param num The number of values that will be returned when calling the methods above.+ */+ public void setNumReturnValues(int num) {+ defaultNumReturnValues = (num < 0) ? -1 : num;+ }++ /**+ * Returns keys sorted in alphabetical order. This includes the start Node and all nodes connected+ * to the start Node.+ *+ * <p>The number of keys returned is limited to numReturnValues. To get a list that isn't limited+ * in size, set numReturnValues to -1.+ *+ * @param startNode The top node defining the subtrie to be searched.+ * @param numReturnValues The maximum number of values returned from this method.+ * @return A <code>List</code> with the results.+ */+ protected List<String> sortKeys(TSTNode startNode, int numReturnValues) {+ return sortKeysRecursion(+ startNode, ((numReturnValues < 0) ? -1 : numReturnValues), new Vector<String>());+ }++ /**+ * Returns keys sorted in alphabetical order. This includes the current Node and all nodes+ * connected to the current Node.+ *+ * <p>Sorted keys will be appended to the end of the resulting <code>List</code>. The result may+ * be empty when this method is invoked, but may not be <code>null</code>.+ *+ * @param currentNode The current node.+ * @param sortKeysNumReturnValues The maximum number of values in the result.+ * @param sortKeysResult2 The results so far.+ * @return A <code>List</code> with the results.+ */+ private List<String> sortKeysRecursion(+ TSTNode currentNode, int sortKeysNumReturnValues, List<String> sortKeysResult2) {+ if (currentNode == null) {+ return sortKeysResult2;+ }+ List<String> sortKeysResult =+ sortKeysRecursion(+ currentNode.relatives[TSTNode.LOKID], sortKeysNumReturnValues, sortKeysResult2);+ if (sortKeysNumReturnValues != -1 && sortKeysResult.size() >= sortKeysNumReturnValues) {+ return sortKeysResult;+ }+ if (currentNode.data != null) {+ sortKeysResult.add(getKey(currentNode));+ }+ sortKeysResult =+ sortKeysRecursion(+ currentNode.relatives[TSTNode.EQKID], sortKeysNumReturnValues, sortKeysResult);+ return sortKeysRecursion(+ currentNode.relatives[TSTNode.HIKID], sortKeysNumReturnValues, sortKeysResult);+ }++ @Override+ public long ramBytesUsed() {+ long mem = RamUsageEstimator.shallowSizeOf(this);+ final TSTNode root = getRoot();+ if (root != null) {+ mem += root.ramBytesUsed();+ }+ return mem;+ }+}diff --git a/solr/core/src/java/org/apache/solr/spelling/suggest/jaspell/package-info.java b/solr/core/src/java/org/apache/solr/spelling/suggest/jaspell/package-info.javaindex 569fe8e5fc0..f8d3b77d0b7 100644--- a/solr/core/src/java/org/apache/solr/spelling/suggest/jaspell/package-info.java+++ b/solr/core/src/java/org/apache/solr/spelling/suggest/jaspell/package-info.java@@ -16,7 +16,7 @@*//**- * Factories for {@linkplain org.apache.lucene.search.suggest.jaspell JaSpell} based {@link org.apache.solr.spelling.suggest.Suggester}s+ * Factories for {@linkplain org.apache.solr.spelling.suggest.jaspell JaSpell} based {@link org.apache.solr.spelling.suggest.Suggester}s*/package org.apache.solr.spelling.suggest.jaspell;diff --git a/solr/core/src/java/org/apache/solr/util/PayloadUtils.java b/solr/core/src/java/org/apache/solr/util/PayloadUtils.javaindex 7bcfd732f10..7db4562a21b 100644--- a/solr/core/src/java/org/apache/solr/util/PayloadUtils.java+++ b/solr/core/src/java/org/apache/solr/util/PayloadUtils.java@@ -35,10 +35,11 @@ import org.apache.lucene.queries.payloads.MinPayloadFunction;import org.apache.lucene.queries.payloads.PayloadDecoder;import org.apache.lucene.queries.payloads.PayloadFunction;import org.apache.lucene.queries.payloads.SumPayloadFunction;-import org.apache.lucene.search.spans.SpanNearQuery;-import org.apache.lucene.search.spans.SpanOrQuery;-import org.apache.lucene.search.spans.SpanQuery;-import org.apache.lucene.search.spans.SpanTermQuery;++import org.apache.lucene.queries.spans.SpanNearQuery;+import org.apache.lucene.queries.spans.SpanOrQuery;+import org.apache.lucene.queries.spans.SpanQuery;+import org.apache.lucene.queries.spans.SpanTermQuery;import org.apache.lucene.util.BytesRef;import org.apache.solr.analysis.TokenizerChain;import org.apache.solr.schema.FieldType;diff --git a/solr/core/src/test-files/solr/collection1/conf/schema-bm25.xml b/solr/core/src/test-files/solr/collection1/conf/schema-bm25.xmlindex 02a0d08b36b..a9c2a6a1ecb 100644--- a/solr/core/src/test-files/solr/collection1/conf/schema-bm25.xml+++ b/solr/core/src/test-files/solr/collection1/conf/schema-bm25.xml@@ -35,6 +35,7 @@<float name="b">0.76</float></similarity></fieldType>+<field name="id" type="string" indexed="true" stored="true" multiValued="false" required="false"/><field name="text" type="text" indexed="true" stored="false"/>diff --git a/solr/core/src/test-files/solr/collection1/conf/solrconfig-tieredmergepolicyfactory.xml b/solr/core/src/test-files/solr/collection1/conf/solrconfig-tieredmergepolicyfactory.xmlindex 4a5810040f8..3494db00d9c 100644--- a/solr/core/src/test-files/solr/collection1/conf/solrconfig-tieredmergepolicyfactory.xml+++ b/solr/core/src/test-files/solr/collection1/conf/solrconfig-tieredmergepolicyfactory.xml@@ -25,7 +25,7 @@<indexConfig><useCompoundFile>${useCompoundFile:false}</useCompoundFile><mergePolicyFactory class="org.apache.solr.index.TieredMergePolicyFactory">- <int name="maxMergeAtOnceExplicit">19</int>+ <int name="maxMergeAtOnce">19</int><int name="maxMergeAtOnce">7</int><int name="segmentsPerTier">9</int><double name="noCFSRatio">0.1</double>diff --git a/solr/core/src/test/org/apache/solr/analysis/TestLuceneMatchVersion.java b/solr/core/src/test/org/apache/solr/analysis/TestLuceneMatchVersion.javaindex 859f141a9d8..2f6f8564e37 100644--- a/solr/core/src/test/org/apache/solr/analysis/TestLuceneMatchVersion.java+++ b/solr/core/src/test/org/apache/solr/analysis/TestLuceneMatchVersion.java@@ -52,6 +52,5 @@ public class TestLuceneMatchVersion extends SolrTestCaseJ4 {type = schema.getFieldType("textTurkishAnalyzerDefault");Analyzer ana1 = type.getIndexAnalyzer();assertTrue(ana1 instanceof TurkishAnalyzer);- assertEquals(DEFAULT_VERSION, ana1.getVersion());}}diff --git a/solr/core/src/test/org/apache/solr/analysis/TestReversedWildcardFilterFactory.java b/solr/core/src/test/org/apache/solr/analysis/TestReversedWildcardFilterFactory.javaindex e4420558d77..19ac6fc6ac4 100644--- a/solr/core/src/test/org/apache/solr/analysis/TestReversedWildcardFilterFactory.java+++ b/solr/core/src/test/org/apache/solr/analysis/TestReversedWildcardFilterFactory.java@@ -170,7 +170,7 @@ public class TestReversedWildcardFilterFactory extends SolrTestCaseJ4 {}Automaton automaton = ((AutomatonQuery) q).getAutomaton();String prefix = Operations.getCommonPrefix(Operations.determinize(automaton,- Operations.DEFAULT_MAX_DETERMINIZED_STATES));+ Operations.DEFAULT_DETERMINIZE_WORK_LIMIT));return prefix.length() > 0 && prefix.charAt(0) == '\u0001';}diff --git a/solr/core/src/test/org/apache/solr/core/TestMergePolicyConfig.java b/solr/core/src/test/org/apache/solr/core/TestMergePolicyConfig.javaindex 5f4eb95d1bd..bf004af7c74 100644--- a/solr/core/src/test/org/apache/solr/core/TestMergePolicyConfig.java+++ b/solr/core/src/test/org/apache/solr/core/TestMergePolicyConfig.java@@ -110,7 +110,6 @@ public class TestMergePolicyConfig extends SolrTestCaseJ4 {assertEquals(7, tieredMP.getMaxMergeAtOnce());// mp-specific setters- assertEquals(19, tieredMP.getMaxMergeAtOnceExplicit());assertEquals(0.1D, tieredMP.getNoCFSRatio(), 0.0D);// make sure we overrode segmentsPerTier// (split from maxMergeAtOnce out of mergeFactor)diff --git a/solr/core/src/test/org/apache/solr/handler/TestSnapshotCoreBackup.java b/solr/core/src/test/org/apache/solr/handler/TestSnapshotCoreBackup.javaindex c096dd18420..81f5a1b69e5 100644--- a/solr/core/src/test/org/apache/solr/handler/TestSnapshotCoreBackup.java+++ b/solr/core/src/test/org/apache/solr/handler/TestSnapshotCoreBackup.java@@ -379,7 +379,7 @@ public class TestSnapshotCoreBackup extends SolrTestCaseJ4 {new File(backup, expectedSegmentsFileName).exists());}try (Directory dir = FSDirectory.open(backup.toPath())) {- TestUtil.checkIndex(dir, true, true, null);+ TestUtil.checkIndex(dir, true, true, true, null);try (DirectoryReader r = DirectoryReader.open(dir)) {assertEquals("numDocs in " + backup.toString(),numDocs, r.numDocs());diff --git a/solr/core/src/test/org/apache/solr/handler/TestStressThreadBackup.java b/solr/core/src/test/org/apache/solr/handler/TestStressThreadBackup.javaindex 2d760e6f544..43b24364378 100644--- a/solr/core/src/test/org/apache/solr/handler/TestStressThreadBackup.java+++ b/solr/core/src/test/org/apache/solr/handler/TestStressThreadBackup.java@@ -316,7 +316,7 @@ public class TestStressThreadBackup extends SolrCloudTestCase {final int numRealDocsExpected = Integer.parseInt(m.group());try (Directory dir = FSDirectory.open(backup.toPath())) {- TestUtil.checkIndex(dir, true, true, null);+ TestUtil.checkIndex(dir, true, true, true, null);try (DirectoryReader r = DirectoryReader.open(dir)) {assertEquals("num real docs in " + backup.toString(),numRealDocsExpected, r.docFreq(new Term("type_s","real")));diff --git a/solr/core/src/test/org/apache/solr/highlight/HighlighterTest.java b/solr/core/src/test/org/apache/solr/highlight/HighlighterTest.javaindex 0deb6a2e860..0513fd99bac 100644--- a/solr/core/src/test/org/apache/solr/highlight/HighlighterTest.java+++ b/solr/core/src/test/org/apache/solr/highlight/HighlighterTest.java@@ -28,9 +28,9 @@ import org.apache.lucene.analysis.Analyzer;import org.apache.lucene.analysis.TokenStream;import org.apache.lucene.analysis.core.WhitespaceAnalyzer;import org.apache.lucene.index.Term;+import org.apache.lucene.queries.spans.SpanTermQuery;import org.apache.lucene.search.Query;import org.apache.lucene.queries.payloads.SpanPayloadCheckQuery;-import org.apache.lucene.search.spans.SpanTermQuery;import org.apache.lucene.util.BytesRef;import org.apache.solr.SolrTestCaseJ4;import org.apache.solr.common.params.HighlightParams;diff --git a/solr/core/src/test/org/apache/solr/rest/schema/TestBulkSchemaAPI.java b/solr/core/src/test/org/apache/solr/rest/schema/TestBulkSchemaAPI.javaindex 32795f46f90..aa0b86888a2 100644--- a/solr/core/src/test/org/apache/solr/rest/schema/TestBulkSchemaAPI.java+++ b/solr/core/src/test/org/apache/solr/rest/schema/TestBulkSchemaAPI.java@@ -38,7 +38,6 @@ import org.apache.solr.client.solrj.request.schema.SchemaRequest;import org.apache.solr.common.SolrDocumentList;import org.apache.solr.core.CoreContainer;import org.apache.solr.core.SolrCore;-import org.apache.solr.schema.IndexSchema;import org.apache.solr.schema.SimilarityFactory;import org.apache.solr.search.similarities.SchemaSimilarityFactory;import org.apache.solr.util.RESTfulServerProvider;@@ -203,7 +202,7 @@ public class TestBulkSchemaAPI extends RestTestBase {@SuppressWarnings({"rawtypes"})Map analyzer = (Map)map.get("analyzer");assertEquals("org.apache.lucene.analysis.core.WhitespaceAnalyzer", String.valueOf(analyzer.get("class")));- assertEquals("5.0.0", String.valueOf(analyzer.get(IndexSchema.LUCENE_MATCH_VERSION_PARAM)));+}public void testAnalyzerByName() throws Exception {diff --git a/solr/core/src/test/org/apache/solr/search/ApacheLuceneSolrNearQueryBuilder.java b/solr/core/src/test/org/apache/solr/search/ApacheLuceneSolrNearQueryBuilder.javaindex 574a736406a..01c1e63a42b 100644--- a/solr/core/src/test/org/apache/solr/search/ApacheLuceneSolrNearQueryBuilder.java+++ b/solr/core/src/test/org/apache/solr/search/ApacheLuceneSolrNearQueryBuilder.java@@ -18,13 +18,13 @@ package org.apache.solr.search;import org.apache.lucene.analysis.Analyzer;import org.apache.lucene.index.Term;+import org.apache.lucene.queries.spans.SpanNearQuery;+import org.apache.lucene.queries.spans.SpanQuery;+import org.apache.lucene.queries.spans.SpanTermQuery;import org.apache.lucene.queryparser.xml.DOMUtils;import org.apache.lucene.queryparser.xml.ParserException;import org.apache.lucene.queryparser.xml.builders.SpanQueryBuilder;import org.apache.lucene.search.Query;-import org.apache.lucene.search.spans.SpanNearQuery;-import org.apache.lucene.search.spans.SpanQuery;-import org.apache.lucene.search.spans.SpanTermQuery;import org.apache.solr.request.SolrQueryRequest;import org.w3c.dom.Element;diff --git a/solr/core/src/test/org/apache/solr/search/ChooseOneWordQueryBuilder.java b/solr/core/src/test/org/apache/solr/search/ChooseOneWordQueryBuilder.javaindex 6e2112ec47d..3fd29edd679 100644--- a/solr/core/src/test/org/apache/solr/search/ChooseOneWordQueryBuilder.java+++ b/solr/core/src/test/org/apache/solr/search/ChooseOneWordQueryBuilder.java@@ -18,13 +18,13 @@ package org.apache.solr.search;import org.apache.lucene.analysis.Analyzer;import org.apache.lucene.index.Term;+import org.apache.lucene.queries.spans.SpanQuery;+import org.apache.lucene.queries.spans.SpanTermQuery;import org.apache.lucene.queryparser.xml.DOMUtils;import org.apache.lucene.queryparser.xml.ParserException;import org.apache.lucene.queryparser.xml.builders.SpanQueryBuilder;import org.apache.lucene.search.Query;import org.apache.lucene.search.TermQuery;-import org.apache.lucene.search.spans.SpanQuery;-import org.apache.lucene.search.spans.SpanTermQuery;import org.apache.solr.request.SolrQueryRequest;import org.w3c.dom.Element;import org.w3c.dom.Node;diff --git a/solr/core/src/test/org/apache/solr/search/FuzzySearchTest.java b/solr/core/src/test/org/apache/solr/search/FuzzySearchTest.javadeleted file mode 100644index f84cf10b422..00000000000--- a/solr/core/src/test/org/apache/solr/search/FuzzySearchTest.java+++ /dev/null@@ -1,67 +0,0 @@-/*- * 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.- */--package org.apache.solr.search;--import java.io.IOException;--import org.apache.lucene.util.LuceneTestCase;-import org.apache.solr.client.solrj.SolrQuery;-import org.apache.solr.client.solrj.SolrServerException;-import org.apache.solr.client.solrj.impl.BaseHttpSolrClient;-import org.apache.solr.client.solrj.impl.CloudSolrClient;-import org.apache.solr.client.solrj.request.CollectionAdminRequest;-import org.apache.solr.cloud.SolrCloudTestCase;-import org.apache.solr.common.SolrInputDocument;-import org.junit.Before;-import org.junit.BeforeClass;-import org.junit.Test;--public class FuzzySearchTest extends SolrCloudTestCase {- private final static String COLLECTION = "c1";- private CloudSolrClient client;-- @BeforeClass- public static void setupCluster() throws Exception {- configureCluster(1).addConfig(COLLECTION, configset("cloud-minimal")).configure();- }-- @Before- public void setupCollection() throws Exception {- client = cluster.getSolrClient();- client.setDefaultCollection(COLLECTION);-- CollectionAdminRequest.createCollection(COLLECTION, 1, 1).process(client);- cluster.waitForActiveCollection(COLLECTION, 1, 1);- }-- @Test- public void testTooComplex() throws IOException, SolrServerException {- SolrInputDocument doc = new SolrInputDocument();-- doc.setField("id", "1");- doc.setField("text", "foo");- client.add(doc);- client.commit(); // Must have index files written, but the contents don't matter-- SolrQuery query = new SolrQuery("text:headquarters\\(在日米海軍横須賀基地司令部庁舎\\/旧横須賀鎮守府会議所・横須賀海軍艦船部\\)~");-- BaseHttpSolrClient.RemoteSolrException e = expectThrows(BaseHttpSolrClient.RemoteSolrException.class, () -> client.query(query));- assertTrue("Should be client error, not server error", e.code() >= 400 && e.code() < 500);- }-}diff --git a/solr/core/src/test/org/apache/solr/search/HandyQueryBuilder.java b/solr/core/src/test/org/apache/solr/search/HandyQueryBuilder.javaindex f76015fde80..ae6c62025c1 100644--- a/solr/core/src/test/org/apache/solr/search/HandyQueryBuilder.java+++ b/solr/core/src/test/org/apache/solr/search/HandyQueryBuilder.java@@ -17,14 +17,14 @@package org.apache.solr.search;import org.apache.lucene.analysis.Analyzer;+import org.apache.lucene.queries.spans.SpanOrQuery;+import org.apache.lucene.queries.spans.SpanQuery;import org.apache.lucene.queryparser.xml.DOMUtils;import org.apache.lucene.queryparser.xml.ParserException;import org.apache.lucene.queryparser.xml.builders.SpanQueryBuilder;import org.apache.lucene.search.BooleanClause;import org.apache.lucene.search.BooleanQuery;import org.apache.lucene.search.Query;-import org.apache.lucene.search.spans.SpanOrQuery;-import org.apache.lucene.search.spans.SpanQuery;import org.apache.solr.request.SolrQueryRequest;import org.w3c.dom.Element;diff --git a/solr/core/src/test/org/apache/solr/search/TestDocSet.java b/solr/core/src/test/org/apache/solr/search/TestDocSet.javaindex 8a84f2e4c80..47f481a2363 100644--- a/solr/core/src/test/org/apache/solr/search/TestDocSet.java+++ b/solr/core/src/test/org/apache/solr/search/TestDocSet.java@@ -287,6 +287,11 @@ public class TestDocSet extends SolrTestCase {return maxDoc;}+ @Override+ public Fields getTermVectors(int docID) {+ return null;+ }+@Overridepublic int numDocs() {return maxDoc;@@ -307,11 +312,6 @@ public class TestDocSet extends SolrTestCase {return null;}- @Override- public Fields getTermVectors(int doc) {- return null;- }-@Overridepublic NumericDocValues getNumericDocValues(String field) {return null;@@ -353,7 +353,8 @@ public class TestDocSet extends SolrTestCase {}@Override- public TopDocs searchNearestVectors(String field, float[] target, int k, int fanout) {+ public TopDocs searchNearestVectors(String field, float[] target, int k, Bits acceptDocs)+ throws IOException {return null;}diff --git a/solr/core/src/test/org/apache/solr/search/TestSolrCoreParser.java b/solr/core/src/test/org/apache/solr/search/TestSolrCoreParser.javaindex d82abdb89f1..def7a2135b1 100644--- a/solr/core/src/test/org/apache/solr/search/TestSolrCoreParser.java+++ b/solr/core/src/test/org/apache/solr/search/TestSolrCoreParser.java@@ -25,6 +25,9 @@ import org.apache.lucene.analysis.MockAnalyzer;import org.apache.lucene.analysis.MockTokenFilter;import org.apache.lucene.analysis.MockTokenizer;import org.apache.lucene.index.Term;+import org.apache.lucene.queries.spans.SpanNearQuery;+import org.apache.lucene.queries.spans.SpanOrQuery;+import org.apache.lucene.queries.spans.SpanTermQuery;import org.apache.lucene.queryparser.xml.CoreParser;import org.apache.lucene.queryparser.xml.ParserException;import org.apache.lucene.search.BooleanQuery;@@ -32,11 +35,6 @@ import org.apache.lucene.search.MatchAllDocsQuery;import org.apache.lucene.search.MatchNoDocsQuery;import org.apache.lucene.search.Query;import org.apache.lucene.search.TermQuery;-import org.apache.lucene.search.spans.SpanBoostQuery;-import org.apache.lucene.search.spans.SpanNearQuery;-import org.apache.lucene.search.spans.SpanOrQuery;-import org.apache.lucene.search.spans.SpanQuery;-import org.apache.lucene.search.spans.SpanTermQuery;import org.apache.solr.SolrTestCaseJ4;import org.apache.solr.common.util.NamedList;import org.junit.BeforeClass;@@ -122,12 +120,6 @@ public class TestSolrCoreParser extends SolrTestCaseJ4 {assertTrue(bq.clauses().get(1).getQuery() instanceof MatchNoDocsQuery);}- private static SpanQuery unwrapSpanBoostQuery(Query query) {- assertTrue(query instanceof SpanBoostQuery);- final SpanBoostQuery spanBoostQuery = (SpanBoostQuery)query;- return spanBoostQuery.getQuery();- }-// test custom query (HandyQueryBuilder) wrapping a SpanQuerypublic void testHandySpanQuery() throws IOException, ParserException {final String lhsXml = "<SpanOr fieldName='contents'>"@@ -146,10 +138,10 @@ public class TestSolrCoreParser extends SolrTestCaseJ4 {final Query clauseQuery = bq.clauses().get(ii).getQuery();switch (ii) {case 0:- assertTrue(unwrapSpanBoostQuery(clauseQuery) instanceof SpanOrQuery);+ assertTrue(clauseQuery instanceof SpanOrQuery);break;case 1:- assertTrue(unwrapSpanBoostQuery(clauseQuery) instanceof SpanNearQuery);+ assertTrue(clauseQuery instanceof SpanNearQuery);break;default:fail("unexpected clause index "+ii);@@ -185,8 +177,8 @@ public class TestSolrCoreParser extends SolrTestCaseJ4 {// the testfinal Query query = parseXmlString(xml);if (span) {- assertTrue(unwrapSpanBoostQuery(query) instanceof SpanOrQuery);- final SpanOrQuery soq = (SpanOrQuery)unwrapSpanBoostQuery(query);+ assertTrue(query instanceof SpanOrQuery);+ final SpanOrQuery soq = (SpanOrQuery) query;assertEquals(2, soq.getClauses().length);checkChooseOneWordQuery(span, soq.getClauses()[0], fieldName, randomTerms);checkApacheLuceneSolr(soq.getClauses()[1], fieldName);diff --git a/solr/core/src/test/org/apache/solr/update/SolrIndexConfigTest.java b/solr/core/src/test/org/apache/solr/update/SolrIndexConfigTest.javaindex 4f43b10a260..63a25ac79ff 100644--- a/solr/core/src/test/org/apache/solr/update/SolrIndexConfigTest.java+++ b/solr/core/src/test/org/apache/solr/update/SolrIndexConfigTest.java@@ -92,9 +92,10 @@ public class SolrIndexConfigTest extends SolrTestCaseJ4 {assertNotNull("null mp", iwc.getMergePolicy());assertTrue("mp is not TieredMergePolicy", iwc.getMergePolicy() instanceof TieredMergePolicy);TieredMergePolicy mp = (TieredMergePolicy) iwc.getMergePolicy();- assertEquals("mp.maxMergeAtOnceExplicit", 19, mp.getMaxMergeAtOnceExplicit());+ assertEquals("mp.maxMergeAtOnce", 7, mp.getMaxMergeAtOnce());assertEquals("mp.segmentsPerTier",9,(int)mp.getSegmentsPerTier());+assertNotNull("null ms", iwc.getMergeScheduler());assertTrue("ms is not CMS", iwc.getMergeScheduler() instanceof ConcurrentMergeScheduler);ConcurrentMergeScheduler ms = (ConcurrentMergeScheduler) iwc.getMergeScheduler();diff --git a/solr/solrj/src/test/org/apache/solr/client/solrj/request/SchemaTest.java b/solr/solrj/src/test/org/apache/solr/client/solrj/request/SchemaTest.javaindex 78f0eabcf32..24ca22f7948 100644--- a/solr/solrj/src/test/org/apache/solr/client/solrj/request/SchemaTest.java+++ b/solr/solrj/src/test/org/apache/solr/client/solrj/request/SchemaTest.java@@ -625,8 +625,6 @@ public class SchemaTest extends RestTestBase {assertThat(fieldTypeName, is(equalTo(newFieldTypeRepresentation.getAttributes().get("name"))));assertThat(analyzerAttributes.get("class"),is(equalTo(newFieldTypeRepresentation.getAnalyzer().getAttributes().get("class"))));- assertThat(analyzerAttributes.get("luceneMatchVersion"),- is(equalTo(newFieldTypeRepresentation.getAnalyzer().getAttributes().get("luceneMatchVersion"))));}@Testdiff --git a/versions.lock b/versions.lockindex 6960cb01ce4..d3e4025ec34 100644--- a/versions.lock+++ b/versions.lock@@ -132,32 +132,32 @@ org.apache.kerby:kerby-util:1.0.1 (2 constraints: 6518bdb6)org.apache.logging.log4j:log4j-api:2.14.1 (4 constraints: d033fab0)org.apache.logging.log4j:log4j-core:2.14.1 (2 constraints: 0d16b624)org.apache.logging.log4j:log4j-slf4j-impl:2.14.1 (1 constraints: 3a053c3b)-org.apache.lucene:lucene-analysis-common:9.0.0-prerelease5 (10 constraints: 10cca63a)-org.apache.lucene:lucene-analysis-icu:9.0.0-prerelease5 (1 constraints: 95093990)-org.apache.lucene:lucene-analysis-kuromoji:9.0.0-prerelease5 (1 constraints: 95093990)-org.apache.lucene:lucene-analysis-morfologik:9.0.0-prerelease5 (1 constraints: 95093990)-org.apache.lucene:lucene-analysis-nori:9.0.0-prerelease5 (1 constraints: 95093990)-org.apache.lucene:lucene-analysis-opennlp:9.0.0-prerelease5 (1 constraints: 95093990)-org.apache.lucene:lucene-analysis-phonetic:9.0.0-prerelease5 (1 constraints: 95093990)-org.apache.lucene:lucene-analysis-smartcn:9.0.0-prerelease5 (1 constraints: 95093990)-org.apache.lucene:lucene-analysis-stempel:9.0.0-prerelease5 (1 constraints: 95093990)-org.apache.lucene:lucene-backward-codecs:9.0.0-prerelease5 (1 constraints: 95093990)-org.apache.lucene:lucene-classification:9.0.0-prerelease5 (1 constraints: 95093990)-org.apache.lucene:lucene-codecs:9.0.0-prerelease5 (3 constraints: 313301b7)-org.apache.lucene:lucene-core:9.0.0-prerelease5 (26 constraints: a6054f0d)-org.apache.lucene:lucene-expressions:9.0.0-prerelease5 (1 constraints: 95093990)-org.apache.lucene:lucene-grouping:9.0.0-prerelease5 (2 constraints: f01ea971)-org.apache.lucene:lucene-highlighter:9.0.0-prerelease5 (1 constraints: 95093990)-org.apache.lucene:lucene-join:9.0.0-prerelease5 (1 constraints: 95093990)-org.apache.lucene:lucene-memory:9.0.0-prerelease5 (1 constraints: 1f14475c)-org.apache.lucene:lucene-misc:9.0.0-prerelease5 (1 constraints: 95093990)-org.apache.lucene:lucene-queries:9.0.0-prerelease5 (5 constraints: 5a5a7a89)-org.apache.lucene:lucene-queryparser:9.0.0-prerelease5 (1 constraints: 95093990)-org.apache.lucene:lucene-sandbox:9.0.0-prerelease5 (2 constraints: e71d8a14)-org.apache.lucene:lucene-spatial-extras:9.0.0-prerelease5 (1 constraints: 95093990)-org.apache.lucene:lucene-spatial3d:9.0.0-prerelease5 (1 constraints: 4215f39f)-org.apache.lucene:lucene-suggest:9.0.0-prerelease5 (1 constraints: 95093990)-org.apache.lucene:lucene-test-framework:9.0.0-prerelease5 (1 constraints: 95093990)+org.apache.lucene:lucene-analysis-common:9.0.0-prerelease9 (10 constraints: 38cc2665)+org.apache.lucene:lucene-analysis-icu:9.0.0-prerelease9 (1 constraints: 99093d90)+org.apache.lucene:lucene-analysis-kuromoji:9.0.0-prerelease9 (1 constraints: 99093d90)+org.apache.lucene:lucene-analysis-morfologik:9.0.0-prerelease9 (1 constraints: 99093d90)+org.apache.lucene:lucene-analysis-nori:9.0.0-prerelease9 (1 constraints: 99093d90)+org.apache.lucene:lucene-analysis-opennlp:9.0.0-prerelease9 (1 constraints: 99093d90)+org.apache.lucene:lucene-analysis-phonetic:9.0.0-prerelease9 (1 constraints: 99093d90)+org.apache.lucene:lucene-analysis-smartcn:9.0.0-prerelease9 (1 constraints: 99093d90)+org.apache.lucene:lucene-analysis-stempel:9.0.0-prerelease9 (1 constraints: 99093d90)+org.apache.lucene:lucene-backward-codecs:9.0.0-prerelease9 (1 constraints: 99093d90)+org.apache.lucene:lucene-classification:9.0.0-prerelease9 (1 constraints: 99093d90)+org.apache.lucene:lucene-codecs:9.0.0-prerelease9 (3 constraints: 3d33d1b9)+org.apache.lucene:lucene-core:9.0.0-prerelease9 (26 constraints: 0e06b22a)+org.apache.lucene:lucene-expressions:9.0.0-prerelease9 (1 constraints: 99093d90)+org.apache.lucene:lucene-grouping:9.0.0-prerelease9 (2 constraints: f81ea172)+org.apache.lucene:lucene-highlighter:9.0.0-prerelease9 (1 constraints: 99093d90)+org.apache.lucene:lucene-join:9.0.0-prerelease9 (1 constraints: 99093d90)+org.apache.lucene:lucene-memory:9.0.0-prerelease9 (1 constraints: 23144b5c)+org.apache.lucene:lucene-misc:9.0.0-prerelease9 (1 constraints: 99093d90)+org.apache.lucene:lucene-queries:9.0.0-prerelease9 (6 constraints: f06c3251)+org.apache.lucene:lucene-queryparser:9.0.0-prerelease9 (1 constraints: 99093d90)+org.apache.lucene:lucene-sandbox:9.0.0-prerelease9 (2 constraints: ef1d7615)+org.apache.lucene:lucene-spatial-extras:9.0.0-prerelease9 (1 constraints: 99093d90)+org.apache.lucene:lucene-spatial3d:9.0.0-prerelease9 (1 constraints: 4615f79f)+org.apache.lucene:lucene-suggest:9.0.0-prerelease9 (1 constraints: 99093d90)+org.apache.lucene:lucene-test-framework:9.0.0-prerelease9 (1 constraints: 99093d90)org.apache.opennlp:opennlp-tools:1.9.1 (2 constraints: a1164d13)org.apache.pdfbox:fontbox:2.0.17 (1 constraints: 3c05323b)org.apache.pdfbox:jempbox:1.8.16 (1 constraints: 42054b3b)@@ -227,8 +227,8 @@ org.locationtech.spatial4j:spatial4j:0.7 (1 constraints: 58105398)org.openjdk.jmh:jmh-core:1.32 (1 constraints: da04f730)org.ow2.asm:asm:7.2 (3 constraints: a325a35c)org.ow2.asm:asm-commons:7.2 (1 constraints: 6b0f7267)-org.reactivestreams:reactive-streams:1.0.3 (3 constraints: 3c2b02fd)org.quicktheories:quicktheories:0.26 (1 constraints: dc04f530)+org.reactivestreams:reactive-streams:1.0.3 (3 constraints: 3c2b02fd)org.slf4j:jcl-over-slf4j:1.7.24 (1 constraints: 4005473b)org.slf4j:slf4j-api:1.7.24 (19 constraints: 97f04fc1)org.tallison:jmatio:1.5 (1 constraints: aa041f2c)diff --git a/versions.props b/versions.propsindex 2c71a28b947..aac56cf303c 100644--- a/versions.props+++ b/versions.props@@ -90,7 +90,7 @@ org.apache.httpcomponents:httpmime=4.5.10org.apache.james:apache-mime4j*=0.8.3org.apache.kerby:*=1.0.1org.apache.logging.log4j:*=2.14.1-org.apache.lucene:*=9.0.0-prerelease5+org.apache.lucene:*=9.0.0-prerelease9org.apache.opennlp:opennlp-tools=1.9.1org.apache.pdfbox:*=2.0.17org.apache.pdfbox:jempbox=1.8.16