Skip to content

Adding collator-based sorting for terms facet entries #2337

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.

Sign up for GitHub

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

Closed
wants to merge 2 commits into from
Closed

Adding collator-based sorting for terms facet entries #2337

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
7ffb4bc
Adding collator-based sorting for terms facet entries
jprante Oct 18, 2012
fe243d8
Adding collator-based sorting for terms facet entries
jprante Oct 18, 2012
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
98 changes: 0 additions & 98 deletions src/main/java/org/elasticsearch/search/facet/terms/TermsFacet.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -19,10 +19,8 @@

package org.elasticsearch.search.facet.terms;

import org.elasticsearch.ElasticSearchIllegalArgumentException;
import org.elasticsearch.search.facet.Facet;

import java.util.Comparator;
import java.util.List;

/**
Expand Down Expand Up @@ -52,102 +50,6 @@ public interface Entry extends Comparable<Entry> {
int getCount();
}

/**
* Controls how the terms facets are ordered.
*/
public static enum ComparatorType {
/**
* Order by the (higher) count of each term.
*/
COUNT((byte) 0, new Comparator<Entry>() {

@Override
public int compare(Entry o1, Entry o2) {
int i = o2.count() - o1.count();
if (i == 0) {
i = o2.compareTo(o1);
if (i == 0) {
i = System.identityHashCode(o2) - System.identityHashCode(o1);
}
}
return i;
}
}),
/**
* Order by the (lower) count of each term.
*/
REVERSE_COUNT((byte) 1, new Comparator<Entry>() {

@Override
public int compare(Entry o1, Entry o2) {
return -COUNT.comparator().compare(o1, o2);
}
}),
/**
* Order by the terms.
*/
TERM((byte) 2, new Comparator<Entry>() {

@Override
public int compare(Entry o1, Entry o2) {
return o1.compareTo(o2);
}
}),
/**
* Order by the terms.
*/
REVERSE_TERM((byte) 3, new Comparator<Entry>() {

@Override
public int compare(Entry o1, Entry o2) {
return -TERM.comparator().compare(o1, o2);
}
});

private final byte id;

private final Comparator<Entry> comparator;

ComparatorType(byte id, Comparator<Entry> comparator) {
this.id = id;
this.comparator = comparator;
}

public byte id() {
return this.id;
}

public Comparator<Entry> comparator() {
return comparator;
}

public static ComparatorType fromId(byte id) {
if (id == COUNT.id()) {
return COUNT;
} else if (id == REVERSE_COUNT.id()) {
return REVERSE_COUNT;
} else if (id == TERM.id()) {
return TERM;
} else if (id == REVERSE_TERM.id()) {
return REVERSE_TERM;
}
throw new ElasticSearchIllegalArgumentException("No type argument match for terms facet comparator [" + id + "]");
}

public static ComparatorType fromString(String type) {
if ("count".equals(type)) {
return COUNT;
} else if ("term".equals(type)) {
return TERM;
} else if ("reverse_count".equals(type) || "reverseCount".equals(type)) {
return REVERSE_COUNT;
} else if ("reverse_term".equals(type) || "reverseTerm".equals(type)) {
return REVERSE_TERM;
}
throw new ElasticSearchIllegalArgumentException("No type argument match for terms facet comparator [" + type + "]");
}
}

/**
* The number of docs missing a value.
*/
Expand Down
17 changes: 11 additions & 6 deletions src/main/java/org/elasticsearch/search/facet/terms/TermsFacetBuilder.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -19,6 +19,8 @@

package org.elasticsearch.search.facet.terms;

import org.elasticsearch.search.facet.terms.comparator.AbstractTermsFacetComparator;
import org.elasticsearch.search.facet.terms.comparator.TermsFacetComparator;
import com.google.common.collect.Maps;
import org.elasticsearch.common.regex.Regex;
import org.elasticsearch.common.xcontent.XContentBuilder;
Expand All @@ -27,6 +29,7 @@
import org.elasticsearch.search.facet.AbstractFacetBuilder;

import java.io.IOException;
import java.util.Locale;
import java.util.Map;

/**
Expand All @@ -42,7 +45,8 @@ public class TermsFacetBuilder extends AbstractFacetBuilder {
private Object[] exclude;
private String regex;
private int regexFlags = 0;
private TermsFacet.ComparatorType comparatorType;
private Locale locale;
private TermsFacetComparator comparator;
private String script;
private String lang;
private Map<String, Object> params;
Expand Down Expand Up @@ -151,10 +155,10 @@ public TermsFacetBuilder regex(String regex, int flags) {
}

/**
* The order by which to return the facets by. Defaults to {@link TermsFacet.ComparatorType#COUNT}.
* The order by which to return the facets by. Defaults to {@link TermsFacetCountComparator}.
*/
public TermsFacetBuilder order(TermsFacet.ComparatorType comparatorType) {
this.comparatorType = comparatorType;
public TermsFacetBuilder order(AbstractTermsFacetComparator comparator) {
this.comparator = comparator;
return this;
}

Expand Down Expand Up @@ -236,8 +240,9 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
builder.field("regex_flags", Regex.flagsToString(regexFlags));
}
}
if (comparatorType != null) {
builder.field("order", comparatorType.name().toLowerCase());
if (comparator != null) {
builder.field("locale", comparator.getLocale());
builder.field("order", comparator.getType());
}
if (allTerms != null) {
builder.field("all_terms", allTerms);
Expand Down
80 changes: 59 additions & 21 deletions src/main/java/org/elasticsearch/search/facet/terms/TermsFacetProcessor.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -34,6 +34,9 @@
import org.elasticsearch.search.facet.FacetProcessor;
import org.elasticsearch.search.facet.terms.bytes.TermsByteFacetCollector;
import org.elasticsearch.search.facet.terms.bytes.TermsByteOrdinalsFacetCollector;
import org.elasticsearch.search.facet.terms.comparator.AbstractTermsFacetComparator;
import org.elasticsearch.search.facet.terms.comparator.TermsFacetCountComparator;
import org.elasticsearch.search.facet.terms.comparator.TermsFacetComparator;
import org.elasticsearch.search.facet.terms.doubles.TermsDoubleFacetCollector;
import org.elasticsearch.search.facet.terms.doubles.TermsDoubleOrdinalsFacetCollector;
import org.elasticsearch.search.facet.terms.floats.TermsFloatFacetCollector;
Expand All @@ -54,7 +57,9 @@
import org.elasticsearch.search.internal.SearchContext;

import java.io.IOException;
import java.text.Collator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.regex.Pattern;

Expand All @@ -63,6 +68,8 @@
*/
public class TermsFacetProcessor extends AbstractComponent implements FacetProcessor {

private final static TermsFacetComparator DEFAULT_COMPARATOR = new TermsFacetCountComparator("count", false).setLocale(Locale.getDefault());

@Inject
public TermsFacetProcessor(Settings settings) {
super(settings);
Expand All @@ -83,7 +90,12 @@ public FacetCollector parse(String facetName, XContentParser parser, SearchConte
ImmutableSet<String> excluded = ImmutableSet.of();
String regex = null;
String regexFlags = null;
TermsFacet.ComparatorType comparatorType = TermsFacet.ComparatorType.COUNT;
TermsFacetComparator comparator = DEFAULT_COMPARATOR;
Locale locale = DEFAULT_COMPARATOR.getLocale();
int strength = -1;
int decomp = -1;
String rules = null;
boolean reverse = false;
String scriptLang = null;
String script = null;
Map<String, Object> params = null;
Expand Down Expand Up @@ -127,83 +139,109 @@ public FacetCollector parse(String facetName, XContentParser parser, SearchConte
} else if ("regex_flags".equals(currentFieldName) || "regexFlags".equals(currentFieldName)) {
regexFlags = parser.text();
} else if ("order".equals(currentFieldName) || "comparator".equals(currentFieldName)) {
comparatorType = TermsFacet.ComparatorType.fromString(parser.text());
comparator = AbstractTermsFacetComparator.getInstance(parser.text(), reverse, locale, rules, decomp, strength);
} else if ("reverse".equals(currentFieldName)) {
reverse = parser.booleanValue();
} else if ("script".equals(currentFieldName)) {
script = parser.text();
} else if ("lang".equals(currentFieldName)) {
scriptLang = parser.text();
} else if ("execution_hint".equals(currentFieldName) || "executionHint".equals(currentFieldName)) {
executionHint = parser.textOrNull();
} else if ("locale".equals(currentFieldName)) {
locale = new Locale(parser.text());
} else if ("rules".equals(currentFieldName)) {
rules = parser.text();
} else if ("decomp".equals(currentFieldName)) {
String s = parser.text();
if ("NO_DECOMPOSITION".equals(s)) {
decomp = Collator.NO_DECOMPOSITION;
} else if ("CANONICAL_DECOMPOSITION".equals(s)) {
decomp = Collator.CANONICAL_DECOMPOSITION;
} else if ("FULL_DECOMPOSITION".equals(s)) {
decomp = Collator.FULL_DECOMPOSITION;
}
} else if ("strength".equals(currentFieldName)) {
String s = parser.text();
if ("IDENTICAL".equals(s)) {
strength = Collator.IDENTICAL;
} else if ("PRIMARY".equals(s)) {
strength = Collator.PRIMARY;
} else if ("SECONDARY".equals(s)) {
strength = Collator.SECONDARY;
} else if ("TERTIARY".equals(s)) {
strength = Collator.TERTIARY;
}
}
}
}

if ("_index".equals(field)) {
return new IndexNameFacetCollector(facetName, context.shardTarget().index(), comparatorType, size);
return new IndexNameFacetCollector(facetName, context.shardTarget().index(), comparator, size);
}

Pattern pattern = null;
if (regex != null) {
pattern = Regex.compile(regex, regexFlags);
}
if (fieldsNames != null) {
return new FieldsTermsStringFacetCollector(facetName, fieldsNames, size, comparatorType, allTerms, context, excluded, pattern, scriptLang, script, params);
return new FieldsTermsStringFacetCollector(facetName, fieldsNames, size, comparator, allTerms, context, excluded, pattern, scriptLang, script, params);
}
if (field == null && fieldsNames == null && script != null) {
return new ScriptTermsStringFieldFacetCollector(facetName, size, comparatorType, context, excluded, pattern, scriptLang, script, params);
return new ScriptTermsStringFieldFacetCollector(facetName, size, comparator, context, excluded, pattern, scriptLang, script, params);
}

FieldMapper fieldMapper = context.smartNameFieldMapper(field);
if (fieldMapper != null) {
if (fieldMapper instanceof IpFieldMapper) {
if (script != null || "map".equals(executionHint)) {
return new TermsIpFacetCollector(facetName, field, size, comparatorType, allTerms, context, scriptLang, script, params);
return new TermsIpFacetCollector(facetName, field, size, comparator, allTerms, context, scriptLang, script, params);
} else {
return new TermsIpOrdinalsFacetCollector(facetName, field, size, comparatorType, allTerms, context, null);
return new TermsIpOrdinalsFacetCollector(facetName, field, size, comparator, allTerms, context, null);
}
} else if (fieldMapper.fieldDataType() == FieldDataType.DefaultTypes.LONG) {
if (script != null || "map".equals(executionHint)) {
return new TermsLongFacetCollector(facetName, field, size, comparatorType, allTerms, context, excluded, scriptLang, script, params);
return new TermsLongFacetCollector(facetName, field, size, comparator, allTerms, context, excluded, scriptLang, script, params);
} else {
return new TermsLongOrdinalsFacetCollector(facetName, field, size, comparatorType, allTerms, context, excluded);
return new TermsLongOrdinalsFacetCollector(facetName, field, size, comparator, allTerms, context, excluded);
}
} else if (fieldMapper.fieldDataType() == FieldDataType.DefaultTypes.DOUBLE) {
if (script != null) {
return new TermsDoubleFacetCollector(facetName, field, size, comparatorType, allTerms, context, excluded, scriptLang, script, params);
return new TermsDoubleFacetCollector(facetName, field, size, comparator, allTerms, context, excluded, scriptLang, script, params);
} else {
return new TermsDoubleOrdinalsFacetCollector(facetName, field, size, comparatorType, allTerms, context, excluded);
return new TermsDoubleOrdinalsFacetCollector(facetName, field, size, comparator, allTerms, context, excluded);
}
} else if (fieldMapper.fieldDataType() == FieldDataType.DefaultTypes.INT) {
if (script != null || "map".equals(executionHint)) {
return new TermsIntFacetCollector(facetName, field, size, comparatorType, allTerms, context, excluded, scriptLang, script, params);
return new TermsIntFacetCollector(facetName, field, size, comparator, allTerms, context, excluded, scriptLang, script, params);
} else {
return new TermsIntOrdinalsFacetCollector(facetName, field, size, comparatorType, allTerms, context, excluded);
return new TermsIntOrdinalsFacetCollector(facetName, field, size, comparator, allTerms, context, excluded);
}
} else if (fieldMapper.fieldDataType() == FieldDataType.DefaultTypes.FLOAT) {
if (script != null || "map".equals(executionHint)) {
return new TermsFloatFacetCollector(facetName, field, size, comparatorType, allTerms, context, excluded, scriptLang, script, params);
return new TermsFloatFacetCollector(facetName, field, size, comparator, allTerms, context, excluded, scriptLang, script, params);
} else {
return new TermsFloatOrdinalsFacetCollector(facetName, field, size, comparatorType, allTerms, context, excluded);
return new TermsFloatOrdinalsFacetCollector(facetName, field, size, comparator, allTerms, context, excluded);
}
} else if (fieldMapper.fieldDataType() == FieldDataType.DefaultTypes.SHORT) {
if (script != null || "map".equals(executionHint)) {
return new TermsShortFacetCollector(facetName, field, size, comparatorType, allTerms, context, excluded, scriptLang, script, params);
return new TermsShortFacetCollector(facetName, field, size, comparator, allTerms, context, excluded, scriptLang, script, params);
} else {
return new TermsShortOrdinalsFacetCollector(facetName, field, size, comparatorType, allTerms, context, excluded);
return new TermsShortOrdinalsFacetCollector(facetName, field, size, comparator, allTerms, context, excluded);
}
} else if (fieldMapper.fieldDataType() == FieldDataType.DefaultTypes.BYTE) {
if (script != null || "map".equals(executionHint)) {
return new TermsByteFacetCollector(facetName, field, size, comparatorType, allTerms, context, excluded, scriptLang, script, params);
return new TermsByteFacetCollector(facetName, field, size, comparator, allTerms, context, excluded, scriptLang, script, params);
} else {
return new TermsByteOrdinalsFacetCollector(facetName, field, size, comparatorType, allTerms, context, excluded);
return new TermsByteOrdinalsFacetCollector(facetName, field, size, comparator, allTerms, context, excluded);
}
} else if (fieldMapper.fieldDataType() == FieldDataType.DefaultTypes.STRING) {
if (script == null && !"map".equals(executionHint)) {
return new TermsStringOrdinalsFacetCollector(facetName, field, size, comparatorType, allTerms, context, excluded, pattern);
return new TermsStringOrdinalsFacetCollector(facetName, field, size, comparator, allTerms, context, excluded, pattern);
}
}
}
return new TermsStringFacetCollector(facetName, field, size, comparatorType, allTerms, context, excluded, pattern, scriptLang, script, params);
return new TermsStringFacetCollector(facetName, field, size, comparator, allTerms, context, excluded, pattern, scriptLang, script, params);
}

@Override
Expand Down
Loading