Faceting is the arrangement of search results into categories based on indexed terms.
Searchers are presented with the indexed terms, along with numerical counts of how many matching documents were found for each term. Faceting makes it easy for users to explore search results, narrowing in on exactly the results they are looking for.
General Facet Parameters
There are two general parameters for controlling faceting.
facet-
If set to
true, this parameter enables facet counts in the query response. If set tofalse, a blank or missing value, this parameter disables faceting. None of the other parameters listed below will have any effect unless this parameter is set totrue. The default value is blank (false). facet.query-
This parameter allows you to specify an arbitrary query in the Lucene default syntax to generate a facet count.
By default, Solr’s faceting feature automatically determines the unique terms for a field and returns a count for each of those terms. Using
facet.query, you can override this default behavior and select exactly which terms or expressions you would like to see counted. In a typical implementation of faceting, you will specify a number offacet.queryparameters. This parameter can be particularly useful for numeric-range-based facets or prefix-based facets.You can set the
facet.queryparameter multiple times to indicate that multiple queries should be used as separate facet constraints.To use facet queries in a syntax other than the default syntax, prefix the facet query with the name of the query notation. For example, to use the hypothetical
myfuncquery parser, you could set thefacet.queryparameter like so:facet.query={!myfunc}name~fred
Field-Value Faceting Parameters
Several parameters can be used to trigger faceting based on the indexed terms in a field.
When using these parameters, it is important to remember that "term" is a very specific concept in Lucene: it relates to the literal field/value pairs that are indexed after any analysis occurs. For text fields that include stemming, lowercasing, or word splitting, the resulting terms may not be what you expect.
If you want Solr to perform both analysis (for searching) and faceting on the full literal strings, use the copyField directive in your Schema to create two versions of the field: one Text and one String. Make sure both are indexed="true". (For more information about the copyField directive, see Documents, Fields, and Schema Design.)
Unless otherwise specified, all of the parameters below can be specified on a per-field basis with the syntax of f.<fieldname>.facet.<parameter>
facet.field-
The
facet.fieldparameter identifies a field that should be treated as a facet. It iterates over each Term in the field and generate a facet count using that Term as the constraint. This parameter can be specified multiple times in a query to select multiple facet fields.If you do not set this parameter to at least one field in the schema, none of the other parameters described in this section will have any effect. facet.prefix-
The
facet.prefixparameter limits the terms on which to facet to those starting with the given string prefix. This does not limit the query in any way, only the facets that would be returned in response to the query. facet.contains-
The
facet.containsparameter limits the terms on which to facet to those containing the given substring. This does not limit the query in any way, only the facets that would be returned in response to the query. facet.contains.ignoreCase-
If
facet.containsis used, thefacet.contains.ignoreCaseparameter causes case to be ignored when matching the given substring against candidate facet terms. facet.sort-
This parameter determines the ordering of the facet field constraints.
There are two options for this parameter.
count-
Sort the constraints by count (highest count first).
index-
Return the constraints sorted in their index order (lexicographic by indexed term). For terms in the ASCII range, this will be alphabetically sorted.
The default is
countiffacet.limitis greater than 0, otherwise, the default isindex. facet.limit-
This parameter specifies the maximum number of constraint counts (essentially, the number of facets for a field that are returned) that should be returned for the facet fields. A negative value means that Solr will return unlimited number of constraint counts.
The default value is
100. facet.offset-
The
facet.offsetparameter indicates an offset into the list of constraints to allow paging.The default value is
0. facet.mincount-
The
facet.mincountparameter specifies the minimum counts required for a facet field to be included in the response. If a field’s counts are below the minimum, the field’s facet is not returned.The default value is
0. facet.missing-
If set to
true, this parameter indicates that, in addition to the Term-based constraints of a facet field, a count of all results that match the query but which have no facet value for the field should be computed and returned in the response.The default value is
false. facet.method-
The
facet.methodparameter selects the type of algorithm or method Solr should use when faceting a field.The following methods are available.
enum-
Enumerates all terms in a field, calculating the set intersection of documents that match the term with documents that match the query.
This method is recommended for faceting multi-valued fields that have only a few distinct values. The average number of values per document does not matter.
For example, faceting on a field with U.S. States such as
Alabama, Alaska, … Wyomingwould lead to fifty cached filters which would be used over and over again. ThefilterCacheshould be large enough to hold all the cached filters. fc-
Calculates facet counts by iterating over documents that match the query and summing the terms that appear in each document.
This is currently implemented using an
UnInvertedFieldcache if the field either is multi-valued or is tokenized (according toFieldType.isTokened()). Each document is looked up in the cache to see what terms/values it contains, and a tally is incremented for each value.This method is excellent for situations where the number of indexed values for the field is high, but the number of values per document is low. For multi-valued fields, a hybrid approach is used that uses term filters from the
filterCachefor terms that match many documents. The lettersfcstand for field cache. fcs-
Per-segment field faceting for single-valued string fields. Enable with
facet.method=fcsand control the number of threads used with thethreadslocal parameter. This parameter allows faceting to be faster in the presence of rapid index changes.
The default value is
fc(except for fields using theBoolFieldfield type and whenfacet.exists=trueis requested) since it tends to use less memory and is faster when a field has many unique terms in the index. facet.enum.cache.minDf-
This parameter indicates the minimum document frequency (the number of documents matching a term) for which the filterCache should be used when determining the constraint count for that term. This is only used with the
facet.method=enummethod of faceting.A value greater than zero decreases the filterCache’s memory usage, but increases the time required for the query to be processed. If you are faceting on a field with a very large number of terms, and you wish to decrease memory usage, try setting this parameter to a value between
25and50, and run a few tests. Then, optimize the parameter setting as necessary.The default value is
0, causing the filterCache to be used for all terms in the field. facet.exists-
To cap facet counts by 1, specify
facet.exists=true. This parameter can be used withfacet.method=enumor when it’s omitted. It can be used only on non-trie fields (such as strings). It may speed up facet counting on large indices and/or high-cardinality facet values. facet.excludeTerms-
If you want to remove terms from facet counts but keep them in the index, the
facet.excludeTermsparameter allows you to do that. facet.overrequest.countandfacet.overrequest.ratio-
In some situations, the accuracy in selecting the "top" constraints returned for a facet in a distributed Solr query can be improved by "over requesting" the number of desired constraints (i.e.,
facet.limit) from each of the individual shards. In these situations, each shard is by default asked for the top10 + (1.5 * facet.limit)constraints.In some situations, depending on how your docs are partitioned across your shards and what
facet.limitvalue you used, you may find it advantageous to increase or decrease the amount of over-requesting Solr does. This can be achieved by setting thefacet.overrequest.count(defaults to10) andfacet.overrequest.ratio(defaults to1.5) parameters. facet.threads-
This parameter will cause loading the underlying fields used in faceting to be executed in parallel with the number of threads specified. Specify as
facet.threads=NwhereNis the maximum number of threads used.Omitting this parameter or specifying the thread count as
0will not spawn any threads, and only the main request thread will be used. Specifying a negative number of threads will create up toInteger.MAX_VALUEthreads.
Range Faceting
You can use Range Faceting on any date field or any numeric field that supports range queries. This is particularly useful for stitching together a series of range queries (as facet by query) for things like prices.
facet.range-
The
facet.rangeparameter defines the field for which Solr should create range facets. For example:facet.range=price&facet.range=agefacet.range=lastModified_dt facet.range.start-
The
facet.range.startparameter specifies the lower bound of the ranges. You can specify this parameter on a per field basis with the syntax off.<fieldname>.facet.range.start. For example:f.price.facet.range.start=0.0&f.age.facet.range.start=10f.lastModified_dt.facet.range.start=NOW/DAY-30DAYS facet.range.end-
The
facet.range.endspecifies the upper bound of the ranges. You can specify this parameter on a per field basis with the syntax off.<fieldname>.facet.range.end. For example:f.price.facet.range.end=1000.0&f.age.facet.range.start=99f.lastModified_dt.facet.range.end=NOW/DAY+30DAYS facet.range.gap-
The span of each range expressed as a value to be added to the lower bound. For date fields, this should be expressed using the
DateMathParsersyntax (such as,facet.range.gap=%2B1DAY … '+1DAY'). You can specify this parameter on a per-field basis with the syntax off.<fieldname>.facet.range.gap. For example:f.price.facet.range.gap=100&f.age.facet.range.gap=10f.lastModified_dt.facet.range.gap=+1DAY facet.range.hardend-
The
facet.range.hardendparameter is a Boolean parameter that specifies how Solr should handle cases where thefacet.range.gapdoes not divide evenly betweenfacet.range.startandfacet.range.end.If
true, the last range constraint will have thefacet.range.endvalue as an upper bound. Iffalse, the last range will have the smallest possible upper bound greater thenfacet.range.endsuch that the range is the exact width of the specified range gap. The default value for this parameter is false.This parameter can be specified on a per field basis with the syntax
f.<fieldname>.facet.range.hardend. facet.range.include-
By default, the ranges used to compute range faceting between
facet.range.startandfacet.range.endare inclusive of their lower bounds and exclusive of the upper bounds. The "before" range defined with thefacet.range.otherparameter is exclusive and the "after" range is inclusive. This default, equivalent to "lower" below, will not result in double counting at the boundaries. You can use thefacet.range.includeparameter to modify this behavior using the following options:-
lower: All gap-based ranges include their lower bound. -
upper: All gap-based ranges include their upper bound. -
edge: The first and last gap ranges include their edge bounds (lower for the first one, upper for the last one) even if the corresponding upper/lower option is not specified. -
outer: The "before" and "after" ranges will be inclusive of their bounds, even if the first or last ranges already include those boundaries. -
all: Includes all options:lower,upper,edge, andouter.
You can specify this parameter on a per field basis with the syntax of
f.<fieldname>.facet.range.include, and you can specify it multiple times to indicate multiple choices.To ensure you avoid double-counting, do not choose both lowerandupper, do not chooseouter, and do not chooseall. -
facet.range.other-
The
facet.range.otherparameter specifies that in addition to the counts for each range constraint betweenfacet.range.startandfacet.range.end, counts should also be computed for these options:-
before: All records with field values lower then lower bound of the first range. -
after: All records with field values greater then the upper bound of the last range. -
between: All records with field values between the start and end bounds of all ranges. -
none: Do not compute any counts. -
all: Compute counts for before, between, and after.
This parameter can be specified on a per field basis with the syntax of
f.<fieldname>.facet.range.other. In addition to thealloption, this parameter can be specified multiple times to indicate multiple choices, butnonewill override all other options. -
facet.range.method-
The
facet.range.methodparameter selects the type of algorithm or method Solr should use for range faceting. Both methods produce the same results, but performance may vary.- filter
-
This method generates the ranges based on other facet.range parameters, and for each of them executes a filter that later intersects with the main query resultset to get the count. It will make use of the filterCache, so it will benefit of a cache large enough to contain all ranges.
- dv
-
This method iterates the documents that match the main query, and for each of them finds the correct range for the value. This method will make use of docValues (if enabled for the field) or fieldCache. The
dvmethod is not supported for field type DateRangeField or when using group.facets.
The default value for this parameter is
filter.
|
Date Ranges & Time Zones
Range faceting on date fields is a common situation where the For more information, see the examples in the Working with Dates section. |
facet.mincount in Range Faceting
The facet.mincount parameter, the same one as used in field faceting is also applied to range faceting. When used, no ranges with a count below the minimum will be included in the response.
Pivot (Decision Tree) Faceting
Pivoting is a summarization tool that lets you automatically sort, count, total or average data stored in a table. The results are typically displayed in a second table showing the summarized data. Pivot faceting lets you create a summary table of the results from a faceting documents by multiple fields.
Another way to look at it is that the query produces a Decision Tree, in that Solr tells you "for facet A, the constraints/counts are X/N, Y/M, etc. If you were to constrain A by X, then the constraint counts for B would be S/P, T/Q, etc.". In other words, it tells you in advance what the "next" set of facet results would be for a field if you apply a constraint from the current facet results.
facet.pivot-
The
facet.pivotparameter defines the fields to use for the pivot. Multiplefacet.pivotvalues will create multiple "facet_pivot" sections in the response. Separate each list of fields with a comma. facet.pivot.mincount-
The
facet.pivot.mincountparameter defines the minimum number of documents that need to match in order for the facet to be included in results. The default is 1.Using the “bin/solr -e techproducts” example, A query URL like this one will return the data below, with the pivot faceting results found in the section "facet_pivot":
http://localhost:8983/solr/techproducts/select?q=*:*&facet.pivot=cat,popularity,inStock
&facet.pivot=popularity,cat&facet=true&facet.field=cat&facet.limit=5&rows=0&facet.pivot.mincount=2{ "facet_counts":{
"facet_queries":{},
"facet_fields":{
"cat":[
"electronics",14,
"currency",4,
"memory",3,
"connector",2,
"graphics card",2]},
"facet_dates":{},
"facet_ranges":{},
"facet_pivot":{
"cat,popularity,inStock":[{
"field":"cat",
"value":"electronics",
"count":14,
"pivot":[{
"field":"popularity",
"value":6,
"count":5,
"pivot":[{
"field":"inStock",
"value":true,
"count":5}]}]
}]}}}Combining Stats Component With Pivots
In addition to some of the general local parameters supported by other types of faceting, a stats local parameters can be used with facet.pivot to refer to stats.field instances (by tag) that you would like to have computed for each Pivot Constraint.
In the example below, two different (overlapping) sets of statistics are computed for each of the facet.pivot result hierarchies:
stats=true
stats.field={!tag=piv1,piv2 min=true max=true}price
stats.field={!tag=piv2 mean=true}popularity
facet=true
facet.pivot={!stats=piv1}cat,inStock
facet.pivot={!stats=piv2}manu,inStockResults:
{"facet_pivot":{
"cat,inStock":[{
"field":"cat",
"value":"electronics",
"count":12,
"pivot":[{
"field":"inStock",
"value":true,
"count":8,
"stats":{
"stats_fields":{
"price":{
"min":74.98999786376953,
"max":399.0}}}},
{
"field":"inStock",
"value":false,
"count":4,
"stats":{
"stats_fields":{
"price":{
"min":11.5,
"max":649.989990234375}}}}],
"stats":{
"stats_fields":{
"price":{
"min":11.5,
"max":649.989990234375}}}},
{
"field":"cat",
"value":"currency",
"count":4,
"pivot":[{
"field":"inStock",
"value":true,
"count":4,
"stats":{
"stats_fields":{
"price":{
"..."
"manu,inStock":[{
"field":"manu",
"value":"inc",
"count":8,
"pivot":[{
"field":"inStock",
"value":true,
"count":7,
"stats":{
"stats_fields":{
"price":{
"min":74.98999786376953,
"max":2199.0},
"popularity":{
"mean":5.857142857142857}}}},
{
"field":"inStock",
"value":false,
"count":1,
"stats":{
"stats_fields":{
"price":{
"min":479.95001220703125,
"max":479.95001220703125},
"popularity":{
"mean":7.0}}}}],
"..."}]}}}}]}]}}Combining Facet Queries And Facet Ranges With Pivot Facets
A query local parameter can be used with facet.pivot to refer to facet.query instances (by tag) that should be computed for each pivot constraint. Similarly, a range local parameter can be used with facet.pivot to refer to facet.range instances.
In the example below, two query facets are computed for h of the facet.pivot result hierarchies:
facet=true
facet.query={!tag=q1}manufacturedate_dt:[2006-01-01T00:00:00Z TO NOW]
facet.query={!tag=q1}price:[0 TO 100]
facet.pivot={!query=q1}cat,inStock{"facet_counts": {
"facet_queries": {
"{!tag=q1}manufacturedate_dt:[2006-01-01T00:00:00Z TO NOW]": 9,
"{!tag=q1}price:[0 TO 100]": 7
},
"facet_fields": {},
"facet_dates": {},
"facet_ranges": {},
"facet_intervals": {},
"facet_heatmaps": {},
"facet_pivot": {
"cat,inStock": [
{
"field": "cat",
"value": "electronics",
"count": 12,
"queries": {
"{!tag=q1}manufacturedate_dt:[2006-01-01T00:00:00Z TO NOW]": 9,
"{!tag=q1}price:[0 TO 100]": 4
},
"pivot": [
{
"field": "inStock",
"value": true,
"count": 8,
"queries": {
"{!tag=q1}manufacturedate_dt:[2006-01-01T00:00:00Z TO NOW]": 6,
"{!tag=q1}price:[0 TO 100]": 2
}
},
"..."]}]}}}In a similar way, in the example below, two range facets are computed for each of the facet.pivot result hierarchies:
facet=true
facet.range={!tag=r1}manufacturedate_dt
facet.range.start=2006-01-01T00:00:00Z
facet.range.end=NOW/YEAR
facet.range.gap=+1YEAR
facet.pivot={!range=r1}cat,inStock{"facet_counts":{
"facet_queries":{},
"facet_fields":{},
"facet_dates":{},
"facet_ranges":{
"manufacturedate_dt":{
"counts":[
"2006-01-01T00:00:00Z",9,
"2007-01-01T00:00:00Z",0,
"2008-01-01T00:00:00Z",0,
"2009-01-01T00:00:00Z",0,
"2010-01-01T00:00:00Z",0,
"2011-01-01T00:00:00Z",0,
"2012-01-01T00:00:00Z",0,
"2013-01-01T00:00:00Z",0,
"2014-01-01T00:00:00Z",0],
"gap":"+1YEAR",
"start":"2006-01-01T00:00:00Z",
"end":"2015-01-01T00:00:00Z"}},
"facet_intervals":{},
"facet_heatmaps":{},
"facet_pivot":{
"cat,inStock":[{
"field":"cat",
"value":"electronics",
"count":12,
"ranges":{
"manufacturedate_dt":{
"counts":[
"2006-01-01T00:00:00Z",9,
"2007-01-01T00:00:00Z",0,
"2008-01-01T00:00:00Z",0,
"2009-01-01T00:00:00Z",0,
"2010-01-01T00:00:00Z",0,
"2011-01-01T00:00:00Z",0,
"2012-01-01T00:00:00Z",0,
"2013-01-01T00:00:00Z",0,
"2014-01-01T00:00:00Z",0],
"gap":"+1YEAR",
"start":"2006-01-01T00:00:00Z",
"end":"2015-01-01T00:00:00Z"}},
"pivot":[{
"field":"inStock",
"value":true,
"count":8,
"ranges":{
"manufacturedate_dt":{
"counts":[
"2006-01-01T00:00:00Z",6,
"2007-01-01T00:00:00Z",0,
"2008-01-01T00:00:00Z",0,
"2009-01-01T00:00:00Z",0,
"2010-01-01T00:00:00Z",0,
"2011-01-01T00:00:00Z",0,
"2012-01-01T00:00:00Z",0,
"2013-01-01T00:00:00Z",0,
"2014-01-01T00:00:00Z",0],
"gap":"+1YEAR",
"start":"2006-01-01T00:00:00Z",
"end":"2015-01-01T00:00:00Z"}}},
"..."]}]}}}Additional Pivot Parameters
Although facet.pivot.mincount deviates in name from the facet.mincount parameter used by field faceting, many of the faceting parameters described above can also be used with pivot faceting:
-
facet.limit -
facet.offset -
facet.sort -
facet.overrequest.count -
facet.overrequest.ratio
Interval Faceting
Another supported form of faceting is interval faceting. This sounds similar to range faceting, but the functionality is really closer to doing facet queries with range queries. Interval faceting allows you to set variable intervals and count the number of documents that have values within those intervals in the specified field.
Even though the same functionality can be achieved by using a facet query with range queries, the implementation of these two methods is very different and will provide different performance depending on the context.
If you are concerned about the performance of your searches you should test with both options. Interval faceting tends to be better with multiple intervals for the same fields, while facet query tend to be better in environments where filter cache is more effective (static indexes for example).
This method will use docValues if they are enabled for the field, will use fieldCache otherwise.
Use these parameters for interval faceting:
facet.interval-
This parameter Indicates the field where interval faceting must be applied. It can be used multiple times in the same request to indicate multiple fields.
facet.interval=price&facet.interval=size facet.interval.set-
This parameter is used to set the intervals for the field, it can be specified multiple times to indicate multiple intervals. This parameter is global, which means that it will be used for all fields indicated with
facet.intervalunless there is an override for a specific field. To override this parameter on a specific field you can use:f.<fieldname>.facet.interval.set, for example:f.price.facet.interval.set=[0,10]&f.price.facet.interval.set=(10,100]
Interval Syntax
Intervals must begin with either '(' or '[', be followed by the start value, then a comma (','), the end value, and finally a closing ')' or ']’.
For example:
-
(1,10) -> will include values greater than 1 and lower than 10
-
[1,10) -> will include values greater or equal to 1 and lower than 10
-
[1,10] -> will include values greater or equal to 1 and lower or equal to 10
The initial and end values cannot be empty.
If the interval needs to be unbounded, the special character * can be used for both, start and end, limits. When using this special character, the start syntax options (( and [), and end syntax options () and ]) will be treated the same. [*,*] will include all documents with a value in the field.
The interval limits may be strings but there is no need to add quotes. All the text until the comma will be treated as the start limit, and the text after that will be the end limit. For example: [Buenos Aires,New York]. Keep in mind that a string-like comparison will be done to match documents in string intervals (case-sensitive). The comparator can’t be changed.
Commas, brackets and square brackets can be escaped by using \ in front of them. Whitespaces before and after the values will be omitted.
The start limit can’t be grater than the end limit. Equal limits are allowed, this allows you to indicate the specific values that you want to count, like [A,A], [B,B] and [C,Z].
Interval faceting supports output key replacement described below. Output keys can be replaced in both the facet.interval parameter and in the facet.interval.set parameter. For example:
&facet.interval={!key=popularity}some_field
&facet.interval.set={!key=bad}[0,5]
&facet.interval.set={!key=good}[5,*]
&facet=trueLocal Parameters for Faceting
The LocalParams syntax allows overriding global settings. It can also provide a method of adding metadata to other parameter values, much like XML attributes.
Tagging and Excluding Filters
You can tag specific filters and exclude those filters when faceting. This is useful when doing multi-select faceting.
Consider the following example query with faceting:
q=mainquery&fq=status:public&fq=doctype:pdf&facet=true&facet.field=doctype
Because everything is already constrained by the filter doctype:pdf, the facet.field=doctype facet command is currently redundant and will return 0 counts for everything except doctype:pdf.
To implement a multi-select facet for doctype, a GUI may want to still display the other doctype values and their associated counts, as if the doctype:pdf constraint had not yet been applied. For example:
=== Document Type ===
[ ] Word (42)
[x] PDF (96)
[ ] Excel(11)
[ ] HTML (63)To return counts for doctype values that are currently not selected, tag filters that directly constrain doctype, and exclude those filters when faceting on doctype.
q=mainquery&fq=status:public&fq={!tag=dt}doctype:pdf&facet=true&facet.field={!ex=dt}doctype
Filter exclusion is supported for all types of facets. Both the tag and ex local parameters may specify multiple values by separating them with commas.
Changing the Output Key
To change the output key for a faceting command, specify a new name with the key local parameter. For example:
facet.field={!ex=dt key=mylabel}doctype
The parameter setting above causes the field facet results for the "doctype" field to be returned using the key "mylabel" rather than "doctype" in the response. This can be helpful when faceting on the same field multiple times with different exclusions.
Limiting Facet with Certain Terms
To limit field facet with certain terms specify them comma separated with terms local parameter. Commas and quotes in terms can be escaped with backslash, as in \,. In this case facet is calculated on a way similar to facet.method=enum , but ignores facet.enum.cache.minDf. For example:
facet.field={!terms='alfa,betta,with\,with\',with space'}symbol
Related Topics
See also Heatmap Faceting (Spatial).
We welcome feedback on Solr documentation. However, we cannot provide application support via comments. If you need help, please send a message to the Solr User mailing list.