-
Notifications
You must be signed in to change notification settings - Fork 674
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
SOLR-17477: Support custom aggregates in plugin code #2742
base: main
Are you sure you want to change the base?
Changes from 2 commits
File filter
Filter by extension
Conversations
Jump to
Diff view
Diff view
There are no files selected for viewing
Original file line number | Diff line number | Diff line change |
---|---|---|
|
@@ -22,6 +22,7 @@ | |
import java.util.List; | ||
import java.util.Map; | ||
import java.util.Optional; | ||
import java.util.concurrent.ConcurrentHashMap; | ||
import java.util.stream.Collectors; | ||
import org.apache.solr.common.SolrException; | ||
import org.apache.solr.common.params.SolrParams; | ||
|
@@ -33,7 +34,7 @@ | |
import org.apache.solr.search.QParser; | ||
import org.apache.solr.search.SyntaxError; | ||
|
||
abstract class FacetParser<T extends FacetRequest> { | ||
public abstract class FacetParser<T extends FacetRequest> { | ||
protected T facet; | ||
protected FacetParser<?> parent; | ||
protected String key; | ||
|
@@ -138,21 +139,30 @@ public Object parseFacetOrStat(String key, Object o) throws SyntaxError { | |
return parseFacetOrStat(key, type, args); | ||
} | ||
|
||
public interface ParseHandler { | ||
Object doParse(FacetParser<?> parent, String key, Object args) throws SyntaxError; | ||
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Here, return type is a little bit tricky There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. This is already how it is, the calling code allows the parser to return either a FacetRequest or a AggValueSource hence that Object type was needed here too. It's not ideal, and perhaps in practice most people will want to produce a AggValueSource only. Creating new subclasses of FacetRequest outside the package is harder, and I've not yet looked at how feasible it is to do that from a plugin (it's not the focus of this issue). But it would be interesting if eventually you can define custom types of faceting too. |
||
} | ||
|
||
private static final Map<String, ParseHandler> REGISTERED_TYPES = new ConcurrentHashMap<>(); | ||
|
||
static { | ||
ParseHandler fieldParser = (p, k, a) -> new FacetFieldParser(p, k).parse(a); | ||
REGISTERED_TYPES.put("field", fieldParser); | ||
REGISTERED_TYPES.put("terms", fieldParser); | ||
REGISTERED_TYPES.put("query", (p, k, a) -> new FacetQueryParser(p, k).parse(a)); | ||
REGISTERED_TYPES.put("range", (p, k, a) -> new FacetRangeParser(p, k).parse(a)); | ||
REGISTERED_TYPES.put("heatmap", (p, k, a) -> new FacetHeatmap.Parser(p, k).parse(a)); | ||
REGISTERED_TYPES.put("func", (p, k, a) -> p.parseStat(k, a)); | ||
} | ||
|
||
public static void registerParseHandler(String type, ParseHandler parseHandler) { | ||
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Thanks for the https://issues.apache.org/jira/browse/SOLR-17477 comment w.r.t. how this is called! There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Not sure where to discuss it. But registering anything in static initializer is asking for trouble, imho. I'd rather hookup a component via solrconfig.xml (or a plugin??), which just calls There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Yeah it's perhaps not the best way of hooking things up, especially as the whole process is already kicked off from solrconfig.xml where you declare a valueSourceParser. I was relying on the point at which that custom parser object is instantiated to run a static initialiser to also register it for json parsing too. But maybe it's safer to invert that and have the Solr code register the custom parser if it implements json parsing. I'll have another look and think about the alternatives. My main reason for suggesting custom code uses a static block to register is when you have many hundreds of SolrCores in your CoreContainer and each one would be instantiated and call the register method, when really you might only need it done once. But now thinking if you run a mixed workload with different solrconfig and they're not homogenous, you don't want static registering maybe (each SolrCore is distinct) There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Although the 'standard set' of registered types in the static block above probably is appropriate as those are built-in and common to all SolrCores. There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more.
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Yes all good points, I'm going to change this to remove the statics and make it per-core which probably fits better with how it's hooked in too |
||
REGISTERED_TYPES.put(type, parseHandler); | ||
} | ||
|
||
public Object parseFacetOrStat(String key, String type, Object args) throws SyntaxError { | ||
// TODO: a place to register all these facet types? | ||
|
||
switch (type) { | ||
case "field": | ||
case "terms": | ||
return new FacetFieldParser(this, key).parse(args); | ||
case "query": | ||
return new FacetQueryParser(this, key).parse(args); | ||
case "range": | ||
return new FacetRangeParser(this, key).parse(args); | ||
case "heatmap": | ||
return new FacetHeatmap.Parser(this, key).parse(args); | ||
case "func": | ||
return parseStat(key, args); | ||
ParseHandler parseHandler = REGISTERED_TYPES.get(type); | ||
if (parseHandler != null) { | ||
return parseHandler.doParse(this, key, args); | ||
} | ||
|
||
throw err("Unknown facet or stat. key=" + key + " type=" + type + " args=" + args); | ||
|
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
btw, is there an other exemplar of such a naming convention like
doSometh
? why not justparse
?There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
No particular strong feelings on this, I tend to use
doSomething
when it's an inner helper method called from an outer/wrapper method that is thesomething(..)
but in this case it's not really directly called. In practice I think people would use lambda anyway and never actually write this method name. But happy to change it toparse
!