You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by no...@apache.org on 2019/07/30 03:38:59 UTC
[lucene-solr] branch jira/SOLR-13659 updated: SOLR-13659: initial
commit
This is an automated email from the ASF dual-hosted git repository.
noble pushed a commit to branch jira/SOLR-13659
in repository https://gitbox.apache.org/repos/asf/lucene-solr.git
The following commit(s) were added to refs/heads/jira/SOLR-13659 by this push:
new 1c2392d SOLR-13659: initial commit
1c2392d is described below
commit 1c2392ddbb98e961921272ba0c779bf0644840e1
Author: noble <no...@apache.org>
AuthorDate: Tue Jul 30 13:38:44 2019 +1000
SOLR-13659: initial commit
---
.../src/java/org/apache/solr/core/SolrConfig.java | 37 +++--
.../org/apache/solr/search/SolrCacheHolder.java | 179 +++++++++++++++++++++
.../apache/solr/search/SolrDocumentFetcher.java | 7 +-
.../org/apache/solr/search/SolrIndexSearcher.java | 152 ++++++++---------
.../src/test/org/apache/solr/core/TestConfig.java | 18 +--
5 files changed, 281 insertions(+), 112 deletions(-)
diff --git a/solr/core/src/java/org/apache/solr/core/SolrConfig.java b/solr/core/src/java/org/apache/solr/core/SolrConfig.java
index e212f50..a14786e 100644
--- a/solr/core/src/java/org/apache/solr/core/SolrConfig.java
+++ b/solr/core/src/java/org/apache/solr/core/SolrConfig.java
@@ -61,10 +61,9 @@ import org.apache.solr.response.QueryResponseWriter;
import org.apache.solr.response.transform.TransformerFactory;
import org.apache.solr.rest.RestManager;
import org.apache.solr.schema.IndexSchemaFactory;
-import org.apache.solr.search.CacheConfig;
-import org.apache.solr.search.FastLRUCache;
import org.apache.solr.search.QParserPlugin;
import org.apache.solr.search.SolrCache;
+import org.apache.solr.search.SolrCacheHolder;
import org.apache.solr.search.ValueSourceParser;
import org.apache.solr.search.stats.StatsCache;
import org.apache.solr.servlet.SolrRequestParsers;
@@ -260,19 +259,19 @@ public class SolrConfig extends XmlConfigFile implements MapSerializable {
useRangeVersionsForPeerSync = getBool("peerSync/useRangeVersions", true);
- filterCacheConfig = CacheConfig.getConfig(this, "query/filterCache");
- queryResultCacheConfig = CacheConfig.getConfig(this, "query/queryResultCache");
- documentCacheConfig = CacheConfig.getConfig(this, "query/documentCache");
- CacheConfig conf = CacheConfig.getConfig(this, "query/fieldValueCache");
+ filterCacheFactory = SolrCacheHolder.Factory.create(this, "query/filterCache");
+ queryResultCacheFactory = SolrCacheHolder.Factory.create(this, "query/queryResultCache");
+ documentCacheFactory = SolrCacheHolder.Factory.create(this, "query/documentCache");
+ SolrCacheHolder.Factory conf = SolrCacheHolder.Factory.create(this, "query/fieldValueCache");
if (conf == null) {
Map<String, String> args = new HashMap<>();
args.put(NAME, "fieldValueCache");
args.put("size", "10000");
args.put("initialSize", "10");
args.put("showItems", "-1");
- conf = new CacheConfig(FastLRUCache.class, args, null);
+ conf = new SolrCacheHolder.Factory(args);
}
- fieldValueCacheConfig = conf;
+ fieldValueCacheFactory = conf;
useColdSearcher = getBool("query/useColdSearcher", false);
dataDir = get("dataDir", null);
if (dataDir != null && dataDir.length() == 0) dataDir = null;
@@ -293,14 +292,14 @@ public class SolrConfig extends XmlConfigFile implements MapSerializable {
slowQueryThresholdMillis = getInt("query/slowQueryThresholdMillis", -1);
for (SolrPluginInfo plugin : plugins) loadPluginInfo(plugin);
- Map<String, CacheConfig> userCacheConfigs = CacheConfig.getMultipleConfigs(this, "query/cache");
+ Map<String, SolrCacheHolder.Factory> userCacheConfigs = SolrCacheHolder.Factory.create(this, "query/cache",true);
List<PluginInfo> caches = getPluginInfos(SolrCache.class.getName());
if (!caches.isEmpty()) {
for (PluginInfo c : caches) {
- userCacheConfigs.put(c.name, CacheConfig.getConfig(this, "cache", c.attributes, null));
+ userCacheConfigs.put(c.name, new SolrCacheHolder.Factory(c.attributes));
}
}
- this.userCacheConfigs = Collections.unmodifiableMap(userCacheConfigs);
+ this.userCacheFactory = Collections.unmodifiableMap(userCacheConfigs);
updateHandlerInfo = loadUpdatehandlerInfo();
@@ -547,11 +546,11 @@ public class SolrConfig extends XmlConfigFile implements MapSerializable {
// public final int filtOptCacheSize;
// public final float filtOptThreshold;
// SolrIndexSearcher - caches configurations
- public final CacheConfig filterCacheConfig;
- public final CacheConfig queryResultCacheConfig;
- public final CacheConfig documentCacheConfig;
- public final CacheConfig fieldValueCacheConfig;
- public final Map<String, CacheConfig> userCacheConfigs;
+ public final SolrCacheHolder.Factory filterCacheFactory;
+ public final SolrCacheHolder.Factory queryResultCacheFactory;
+ public final SolrCacheHolder.Factory documentCacheFactory;
+ public final SolrCacheHolder.Factory fieldValueCacheFactory;
+ public final Map<String, SolrCacheHolder.Factory> userCacheFactory;
// SolrIndexSearcher - more...
public final boolean useFilterForSortedQuery;
public final int queryResultWindowSize;
@@ -919,7 +918,7 @@ public class SolrConfig extends XmlConfigFile implements MapSerializable {
}
- addCacheConfig(m, filterCacheConfig, queryResultCacheConfig, documentCacheConfig, fieldValueCacheConfig);
+ addCacheConfig(m, filterCacheFactory, queryResultCacheFactory, documentCacheFactory, fieldValueCacheFactory);
m = new LinkedHashMap();
result.put("requestDispatcher", m);
m.put("handleSelect", handleSelect);
@@ -938,9 +937,9 @@ public class SolrConfig extends XmlConfigFile implements MapSerializable {
return result;
}
- private void addCacheConfig(Map queryMap, CacheConfig... cache) {
+ private void addCacheConfig(Map queryMap, SolrCacheHolder.Factory... cache) {
if (cache == null) return;
- for (CacheConfig config : cache) if (config != null) queryMap.put(config.getNodeName(), config);
+ for (SolrCacheHolder.Factory config : cache) if (config != null) queryMap.put(config.getName(), config);
}
diff --git a/solr/core/src/java/org/apache/solr/search/SolrCacheHolder.java b/solr/core/src/java/org/apache/solr/search/SolrCacheHolder.java
new file mode 100644
index 0000000..11bbd49
--- /dev/null
+++ b/solr/core/src/java/org/apache/solr/search/SolrCacheHolder.java
@@ -0,0 +1,179 @@
+/*
+ * 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 javax.xml.xpath.XPathConstants;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import org.apache.lucene.analysis.util.ResourceLoader;
+import org.apache.solr.common.MapWriter;
+import org.apache.solr.common.SolrException;
+import org.apache.solr.core.ConfigOverlay;
+import org.apache.solr.core.SolrConfig;
+import org.apache.solr.core.SolrCore;
+import org.apache.solr.util.DOMUtil;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+import static org.apache.solr.common.params.CommonParams.NAME;
+
+public class SolrCacheHolder<K, V> {
+
+
+ protected volatile SolrCache<K, V> delegate;
+
+ public SolrCacheHolder(SolrCache<K, V> delegate) {
+ this.delegate = delegate;
+ }
+
+ public int size() {
+ return delegate.size();
+ }
+
+ public V put(K key, V value) {
+ return delegate.put(key, value);
+
+ }
+
+ public V get(K key) {
+ return delegate.get(key);
+ }
+
+ public void clear() {
+ delegate.clear();
+ }
+
+ public SolrCache<K, V> get() {
+ return delegate;
+ }
+
+ public void close() {
+ delegate.close();
+ }
+
+
+ public void warm(SolrIndexSearcher searcher, SolrCacheHolder src) {
+ delegate.warm(searcher, src.get());
+ }
+
+ public String name() {
+ return delegate.name();
+ }
+
+ public static class Factory implements MapWriter {
+ final Map<String, String> args;
+ private CacheRegenerator defRegen;
+ private final String name;
+ private String cacheImpl, regenImpl;
+ private Object[] persistence = new Object[1];
+
+
+ public Factory(Map<String, String> args) {
+ this.args = copyValsAsString(args);
+ this.name = args.get(NAME);
+ this.cacheImpl = args.getOrDefault("class", "solr.LRUCache");
+ this.regenImpl = args.get("regenerator");
+ }
+ static Map<String,String> copyValsAsString(Map m){
+ Map<String,String> copy = new LinkedHashMap(m.size());
+ m.forEach((k, v) -> copy.put(String.valueOf(k), String.valueOf(v)));
+ return copy;
+ }
+
+ public static Factory create(SolrConfig solrConfig, String xpath) {
+ Node node = solrConfig.getNode(xpath, false);
+ if (node == null || !"true".equals(DOMUtil.getAttrOrDefault(node, "enabled", "true"))) {
+ Map<String, String> m = solrConfig.getOverlay().getEditableSubProperties(xpath);
+ if (m == null) return null;
+ return new Factory(m);
+ } else {
+ Map<String, String> attrs = DOMUtil.toMap(node.getAttributes());
+ attrs.put(NAME, node.getNodeName());
+ return new Factory(applyOverlay(xpath, solrConfig.getOverlay(), attrs));
+
+ }
+
+
+ }
+
+ private static Map applyOverlay(String xpath, ConfigOverlay overlay, Map args) {
+ Map<String, String> map = xpath == null ? null : overlay.getEditableSubProperties(xpath);
+ if (map != null) {
+ HashMap<String, String> mapCopy = new HashMap<>(args);
+ for (Map.Entry<String, String> e : map.entrySet()) {
+ mapCopy.put(e.getKey(), String.valueOf(e.getValue()));
+ }
+ return mapCopy;
+ }
+ return args;
+ }
+
+ public static Map<String, Factory> create(SolrConfig solrConfig, String configPath, boolean multiple) {
+ NodeList nodes = (NodeList) solrConfig.evaluate(configPath, XPathConstants.NODESET);
+ if (nodes == null || nodes.getLength() == 0) return new LinkedHashMap<>();
+ Map<String, Factory> result = new HashMap<>(nodes.getLength());
+ for (int i = 0; i < nodes.getLength(); i++) {
+ Map<String, String> args = DOMUtil.toMap(nodes.item(i).getAttributes());
+ result.put(args.get(NAME), new Factory(args));
+ }
+ return result;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+
+ public <K, V> SolrCacheHolder<K, V> create(SolrCore core) {
+ ResourceLoader loader = core.getResourceLoader();
+
+ SolrCache inst = null;
+ CacheRegenerator regen = null;
+ try {
+ inst = loader.findClass(cacheImpl, SolrCache.class).getConstructor().newInstance();
+ regen = null;
+ if (regenImpl != null) {
+ regen = loader.findClass(regenImpl, CacheRegenerator.class).getConstructor().newInstance();
+ }
+ } catch (Exception e) {
+ throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "Error loading cache " + jsonStr(), e);
+
+ }
+ if (regen == null && defRegen != null) regen = defRegen;
+
+ inst.init(args, persistence[0], regen);
+
+
+ return new SolrCacheHolder<>(inst);
+
+ }
+
+ public void setDefaultRegenerator(CacheRegenerator regen) {
+ this.defRegen = regen;
+
+ }
+
+ @Override
+ public void writeMap(EntryWriter ew) throws IOException {
+ args.forEach(ew.getBiConsumer());
+ }
+ }
+}
diff --git a/solr/core/src/java/org/apache/solr/search/SolrDocumentFetcher.java b/solr/core/src/java/org/apache/solr/search/SolrDocumentFetcher.java
index 313d91b..d07c013 100644
--- a/solr/core/src/java/org/apache/solr/search/SolrDocumentFetcher.java
+++ b/solr/core/src/java/org/apache/solr/search/SolrDocumentFetcher.java
@@ -86,7 +86,7 @@ public class SolrDocumentFetcher {
private final boolean enableLazyFieldLoading;
- private final SolrCache<Integer,Document> documentCache;
+ private final SolrCacheHolder<Integer,Document> documentCache;
private final Set<String> allStored;
@@ -111,7 +111,8 @@ public class SolrDocumentFetcher {
this.searcher = searcher;
this.enableLazyFieldLoading = solrConfig.enableLazyFieldLoading;
if (cachingEnabled) {
- documentCache = solrConfig.documentCacheConfig == null ? null : solrConfig.documentCacheConfig.newInstance();
+ documentCache = solrConfig.documentCacheFactory == null ? null :
+ solrConfig.documentCacheFactory.create(searcher.getCore());
} else {
documentCache = null;
}
@@ -174,7 +175,7 @@ public class SolrDocumentFetcher {
return enableLazyFieldLoading;
}
- public SolrCache<Integer, Document> getDocumentCache() {
+ public SolrCacheHolder<Integer, Document> getDocumentCache() {
return documentCache;
}
diff --git a/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java b/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java
index 8b121e0..9edf2ae 100644
--- a/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java
+++ b/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java
@@ -97,8 +97,8 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
// These should *only* be used for debugging or monitoring purposes
public static final AtomicLong numOpens = new AtomicLong();
public static final AtomicLong numCloses = new AtomicLong();
- private static final Map<String,SolrCache> NO_GENERIC_CACHES = Collections.emptyMap();
- private static final SolrCache[] NO_CACHES = new SolrCache[0];
+ private static final Map<String, SolrCacheHolder> NO_GENERIC_CACHES = Collections.emptyMap();
+ private static final SolrCacheHolder[] NO_CACHES = new SolrCacheHolder[0];
private final SolrCore core;
private final IndexSchema schema;
@@ -117,15 +117,15 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
private final boolean useFilterForSortedQuery;
private final boolean cachingEnabled;
- private final SolrCache<Query,DocSet> filterCache;
- private final SolrCache<QueryResultKey,DocList> queryResultCache;
- private final SolrCache<String,UnInvertedField> fieldValueCache;
+ private final SolrCacheHolder<Query, DocSet> filterCache;
+ private final SolrCacheHolder<QueryResultKey, DocList> queryResultCache;
+ private final SolrCacheHolder<String, UnInvertedField> fieldValueCache;
// map of generic caches - not synchronized since it's read-only after the constructor.
- private final Map<String,SolrCache> cacheMap;
+ private final Map<String, SolrCacheHolder> cacheMap;
// list of all caches associated with this searcher.
- private final SolrCache[] cacheList;
+ private final SolrCacheHolder[] cacheList;
private DirectoryFactory directoryFactory;
@@ -266,24 +266,24 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
this.cachingEnabled = enableCache;
if (cachingEnabled) {
- final ArrayList<SolrCache> clist = new ArrayList<>();
- fieldValueCache = solrConfig.fieldValueCacheConfig == null ? null
- : solrConfig.fieldValueCacheConfig.newInstance();
- if (fieldValueCache != null) clist.add(fieldValueCache);
- filterCache = solrConfig.filterCacheConfig == null ? null : solrConfig.filterCacheConfig.newInstance();
+ final ArrayList<SolrCacheHolder> clist = new ArrayList<>();
+ fieldValueCache = solrConfig.fieldValueCacheFactory == null ? null
+ : solrConfig.fieldValueCacheFactory.create(core);
+ if (fieldValueCache != null) clist.add( fieldValueCache);
+ filterCache = solrConfig.filterCacheFactory == null ? null : solrConfig.filterCacheFactory.create(core);
if (filterCache != null) clist.add(filterCache);
- queryResultCache = solrConfig.queryResultCacheConfig == null ? null
- : solrConfig.queryResultCacheConfig.newInstance();
+ queryResultCache = solrConfig.queryResultCacheFactory == null ? null
+ : solrConfig.queryResultCacheFactory.create(core);
if (queryResultCache != null) clist.add(queryResultCache);
- SolrCache<Integer, Document> documentCache = docFetcher.getDocumentCache();
+ SolrCacheHolder<Integer, Document> documentCache = docFetcher.getDocumentCache();
if (documentCache != null) clist.add(documentCache);
- if (solrConfig.userCacheConfigs.isEmpty()) {
+ if (solrConfig.userCacheFactory.isEmpty()) {
cacheMap = NO_GENERIC_CACHES;
} else {
- cacheMap = new HashMap<>(solrConfig.userCacheConfigs.size());
- for (Map.Entry<String,CacheConfig> e : solrConfig.userCacheConfigs.entrySet()) {
- SolrCache cache = e.getValue().newInstance();
+ cacheMap = new HashMap<>(solrConfig.userCacheFactory.size());
+ for (Map.Entry<String, SolrCacheHolder.Factory> e : solrConfig.userCacheFactory.entrySet()) {
+ SolrCacheHolder cache = e.getValue().create(core);
if (cache != null) {
cacheMap.put(cache.name(), cache);
clist.add(cache);
@@ -291,7 +291,7 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
}
}
- cacheList = clist.toArray(new SolrCache[clist.size()]);
+ cacheList = clist.toArray(new SolrCacheHolder[clist.size()]);
} else {
this.filterCache = null;
this.queryResultCache = null;
@@ -419,14 +419,14 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
// register self
infoRegistry.put(STATISTICS_KEY, this);
infoRegistry.put(name, this);
- for (SolrCache cache : cacheList) {
- cache.setState(SolrCache.State.LIVE);
- infoRegistry.put(cache.name(), cache);
+ for (SolrCacheHolder cache : cacheList) {
+ cache.get().setState(SolrCache.State.LIVE);
+ infoRegistry.put(cache.get().name(), cache.get());
}
metricManager = core.getCoreContainer().getMetricManager();
registryName = core.getCoreMetricManager().getRegistryName();
- for (SolrCache cache : cacheList) {
- cache.initializeMetrics(metricManager, registryName, core.getMetricTag(), SolrMetricManager.mkName(cache.name(), STATISTICS_KEY));
+ for (SolrCacheHolder cache : cacheList) {
+ cache.get(). initializeMetrics(metricManager, registryName, core.getMetricTag(), SolrMetricManager.mkName(cache.name(), STATISTICS_KEY));
}
initializeMetrics(metricManager, registryName, core.getMetricTag(), STATISTICS_KEY);
registerTime = new Date();
@@ -443,7 +443,7 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
if (cachingEnabled) {
final StringBuilder sb = new StringBuilder();
sb.append("Closing ").append(name);
- for (SolrCache cache : cacheList) {
+ for (SolrCacheHolder cache : cacheList) {
sb.append("\n\t");
sb.append(cache);
}
@@ -470,7 +470,7 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
core.getDeletionPolicy().releaseCommitPoint(cpg);
}
- for (SolrCache cache : cacheList) {
+ for (SolrCacheHolder cache : cacheList) {
cache.close();
}
@@ -495,71 +495,60 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
return Iterables.transform(getFieldInfos(), fieldInfo -> fieldInfo.name);
}
- public SolrCache<Query,DocSet> getFilterCache() {
+ public SolrCacheHolder<Query,DocSet> getFilterCache() {
return filterCache;
}
//
// Set default regenerators on filter and query caches if they don't have any
//
+
public static void initRegenerators(SolrConfig solrConfig) {
- if (solrConfig.fieldValueCacheConfig != null && solrConfig.fieldValueCacheConfig.getRegenerator() == null) {
- solrConfig.fieldValueCacheConfig.setRegenerator(new CacheRegenerator() {
- @Override
- public boolean regenerateItem(SolrIndexSearcher newSearcher, SolrCache newCache, SolrCache oldCache,
- Object oldKey, Object oldVal) throws IOException {
- if (oldVal instanceof UnInvertedField) {
- UnInvertedField.getUnInvertedField((String) oldKey, newSearcher);
- }
- return true;
+ if (solrConfig.fieldValueCacheFactory != null) {
+ solrConfig.fieldValueCacheFactory.setDefaultRegenerator((newSearcher, newCache, oldCache, oldKey, oldVal) -> {
+ if (oldVal instanceof UnInvertedField) {
+ UnInvertedField.getUnInvertedField((String) oldKey, newSearcher);
}
+ return true;
});
}
- if (solrConfig.filterCacheConfig != null && solrConfig.filterCacheConfig.getRegenerator() == null) {
- solrConfig.filterCacheConfig.setRegenerator(new CacheRegenerator() {
- @Override
- public boolean regenerateItem(SolrIndexSearcher newSearcher, SolrCache newCache, SolrCache oldCache,
- Object oldKey, Object oldVal) throws IOException {
- newSearcher.cacheDocSet((Query) oldKey, null, false);
- return true;
- }
+ if (solrConfig.filterCacheFactory != null ) {
+ solrConfig.filterCacheFactory.setDefaultRegenerator((newSearcher, newCache, oldCache, oldKey, oldVal) -> {
+ newSearcher.cacheDocSet((Query) oldKey, null, false);
+ return true;
});
}
- if (solrConfig.queryResultCacheConfig != null && solrConfig.queryResultCacheConfig.getRegenerator() == null) {
+ if (solrConfig.queryResultCacheFactory != null ) {
final int queryResultWindowSize = solrConfig.queryResultWindowSize;
- solrConfig.queryResultCacheConfig.setRegenerator(new CacheRegenerator() {
- @Override
- public boolean regenerateItem(SolrIndexSearcher newSearcher, SolrCache newCache, SolrCache oldCache,
- Object oldKey, Object oldVal) throws IOException {
- QueryResultKey key = (QueryResultKey) oldKey;
- int nDocs = 1;
- // request 1 doc and let caching round up to the next window size...
- // unless the window size is <=1, in which case we will pick
- // the minimum of the number of documents requested last time and
- // a reasonable number such as 40.
- // TODO: make more configurable later...
-
- if (queryResultWindowSize <= 1) {
- DocList oldList = (DocList) oldVal;
- int oldnDocs = oldList.offset() + oldList.size();
- // 40 has factors of 2,4,5,10,20
- nDocs = Math.min(oldnDocs, 40);
- }
-
- int flags = NO_CHECK_QCACHE | key.nc_flags;
- QueryCommand qc = new QueryCommand();
- qc.setQuery(key.query)
- .setFilterList(key.filters)
- .setSort(key.sort)
- .setLen(nDocs)
- .setSupersetMaxDoc(nDocs)
- .setFlags(flags);
- QueryResult qr = new QueryResult();
- newSearcher.getDocListC(qr, qc);
- return true;
+ solrConfig.queryResultCacheFactory.setDefaultRegenerator((newSearcher, newCache, oldCache, oldKey, oldVal) -> {
+ QueryResultKey key = (QueryResultKey) oldKey;
+ int nDocs = 1;
+ // request 1 doc and let caching round up to the next window size...
+ // unless the window size is <=1, in which case we will pick
+ // the minimum of the number of documents requested last time and
+ // a reasonable number such as 40.
+ // TODO: make more configurable later...
+
+ if (queryResultWindowSize <= 1) {
+ DocList oldList = (DocList) oldVal;
+ int oldnDocs = oldList.offset() + oldList.size();
+ // 40 has factors of 2,4,5,10,20
+ nDocs = Math.min(oldnDocs, 40);
}
+
+ int flags = NO_CHECK_QCACHE | key.nc_flags;
+ QueryCommand qc = new QueryCommand();
+ qc.setQuery(key.query)
+ .setFilterList(key.filters)
+ .setSort(key.sort)
+ .setLen(nDocs)
+ .setSupersetMaxDoc(nDocs)
+ .setFlags(flags);
+ QueryResult qr = new QueryResult();
+ newSearcher.getDocListC(qr, qc);
+ return true;
});
}
}
@@ -624,7 +613,7 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
/** expert: internal API, subject to change */
public SolrCache<String,UnInvertedField> getFieldValueCache() {
- return fieldValueCache;
+ return fieldValueCache == null? null : fieldValueCache.get();
}
/** Returns a weighted sort according to this searcher */
@@ -2184,14 +2173,15 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
* return the named generic cache
*/
public SolrCache getCache(String cacheName) {
- return cacheMap.get(cacheName);
+ SolrCacheHolder holder = cacheMap.get(cacheName);
+ return holder == null ?null: holder.get();
}
/**
* lookup an entry in a generic cache
*/
public Object cacheLookup(String cacheName, Object key) {
- SolrCache cache = cacheMap.get(cacheName);
+ SolrCacheHolder cache = cacheMap.get(cacheName);
return cache == null ? null : cache.get(key);
}
@@ -2199,7 +2189,7 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
* insert an entry in a generic cache
*/
public Object cacheInsert(String cacheName, Object key, Object val) {
- SolrCache cache = cacheMap.get(cacheName);
+ SolrCacheHolder cache = cacheMap.get(cacheName);
return cache == null ? null : cache.put(key, val);
}
@@ -2469,7 +2459,7 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
@Override
public int hashCode() {
- return classHash()
+ return classHash()
+ 31 * Objects.hashCode(topFilter)
+ 31 * Objects.hashCode(weights);
}
diff --git a/solr/core/src/test/org/apache/solr/core/TestConfig.java b/solr/core/src/test/org/apache/solr/core/TestConfig.java
index 69882c6..a94f2a4 100644
--- a/solr/core/src/test/org/apache/solr/core/TestConfig.java
+++ b/solr/core/src/test/org/apache/solr/core/TestConfig.java
@@ -111,27 +111,27 @@ public class TestConfig extends SolrTestCaseJ4 {
public void testCacheEnablingDisabling() throws Exception {
// ensure if cache is not defined in the config then cache is disabled
SolrConfig sc = new SolrConfig(new SolrResourceLoader(TEST_PATH().resolve("collection1")), "solrconfig-defaults.xml", null);
- assertNull(sc.filterCacheConfig);
- assertNull(sc.queryResultCacheConfig);
- assertNull(sc.documentCacheConfig);
+ assertNull(sc.filterCacheFactory);
+ assertNull(sc.queryResultCacheFactory);
+ assertNull(sc.documentCacheFactory);
// enable all the caches via system properties and verify
System.setProperty("filterCache.enabled", "true");
System.setProperty("queryResultCache.enabled", "true");
System.setProperty("documentCache.enabled", "true");
sc = new SolrConfig(new SolrResourceLoader(TEST_PATH().resolve("collection1")), "solrconfig-cache-enable-disable.xml", null);
- assertNotNull(sc.filterCacheConfig);
- assertNotNull(sc.queryResultCacheConfig);
- assertNotNull(sc.documentCacheConfig);
+ assertNotNull(sc.filterCacheFactory);
+ assertNotNull(sc.queryResultCacheFactory);
+ assertNotNull(sc.documentCacheFactory);
// disable all the caches via system properties and verify
System.setProperty("filterCache.enabled", "false");
System.setProperty("queryResultCache.enabled", "false");
System.setProperty("documentCache.enabled", "false");
sc = new SolrConfig(new SolrResourceLoader(TEST_PATH().resolve("collection1")), "solrconfig-cache-enable-disable.xml", null);
- assertNull(sc.filterCacheConfig);
- assertNull(sc.queryResultCacheConfig);
- assertNull(sc.documentCacheConfig);
+ assertNull(sc.filterCacheFactory);
+ assertNull(sc.queryResultCacheFactory);
+ assertNull(sc.documentCacheFactory);
System.clearProperty("filterCache.enabled");
System.clearProperty("queryResultCache.enabled");