for (QueryIndex.OrderEntry orderEntry : sortOrder) { SolrQuery.ORDER order; if (QueryIndex.OrderEntry.Order.ASCENDING.equals(orderEntry.getOrder())) { order = SolrQuery.ORDER.asc; } else { if (JcrConstants.JCR_PATH.equals(orderEntry.getPropertyName())) { sortingField = partialEscape(configuration.getPathField()).toString(); } else if (JcrConstants.JCR_SCORE.equals(orderEntry.getPropertyName())) { sortingField = "score"; } else { if (orderEntry.getPropertyName().indexOf('/') >= 0) { log.warn("cannot sort on relative properties, ignoring {} clause", orderEntry); continue; // sorting by relative properties not supported until index time aggregation is supported sortingField = partialEscape(getSortingField(orderEntry.getPropertyType().tag(), orderEntry.getPropertyName())).toString();
for (QueryIndex.OrderEntry orderEntry : sortOrder) { SolrQuery.ORDER order; if (QueryIndex.OrderEntry.Order.ASCENDING.equals(orderEntry.getOrder())) { order = SolrQuery.ORDER.asc; } else { if (JcrConstants.JCR_PATH.equals(orderEntry.getPropertyName())) { sortingField = partialEscape(configuration.getPathField()).toString(); } else if (JcrConstants.JCR_SCORE.equals(orderEntry.getPropertyName())) { sortingField = "score"; } else { if (orderEntry.getPropertyName().indexOf('/') >= 0) { log.warn("cannot sort on relative properties, ignoring {} clause", orderEntry); continue; // sorting by relative properties not supported until index time aggregation is supported sortingField = partialEscape(getSortingField(orderEntry.getPropertyType().tag(), orderEntry.getPropertyName())).toString();
PropertyDefinition pd = planResult.getOrderedProperty(i); PropertyRestriction orderRest = new PropertyRestriction(); orderRest.propertyName = oe.getPropertyName(); Query q = createQuery(oe.getPropertyName(), orderRest, pd); if (q != null) { qs.add(q);
PropertyDefinition pd = planResult.getOrderedProperty(i); PropertyRestriction orderRest = new PropertyRestriction(); orderRest.propertyName = oe.getPropertyName(); Query q = createQuery(oe.getPropertyName(), orderRest, pd); if (q != null) { qs.add(q);
if (!pn.equals(e.getPropertyName())) { if (o.isDescending() != (e.getOrder() == Order.DESCENDING)) {
if (!pn.equals(e.getPropertyName())) { if (o.isDescending() != (e.getOrder() == Order.DESCENDING)) {
if (!pn.equals(e.getPropertyName())) { if (o.isDescending() != (e.getOrder() == Order.DESCENDING)) {
private List<OrderEntry> createSortOrder(IndexDefinition.IndexingRule rule) { if (sortOrder == null) { return Collections.emptyList(); } List<OrderEntry> orderEntries = newArrayListWithCapacity(sortOrder.size()); for (OrderEntry o : sortOrder) { PropertyDefinition pd = rule.getConfig(o.getPropertyName()); if (pd != null && pd.ordered && o.getPropertyType() != null && !o.getPropertyType().isArray()) { orderEntries.add(o); // can manage any order desc/asc result.sortedProperties.add(pd); } else if (o.getPropertyName().equals(IndexDefinition.NATIVE_SORT_ORDER.getPropertyName())) { // Supports jcr:score descending natively orderEntries.add(IndexDefinition.NATIVE_SORT_ORDER); } for (PropertyDefinition functionIndex : rule.getFunctionRestrictions()) { if (o.getPropertyName().equals(functionIndex.function)) { // can manage any order desc/asc orderEntries.add(o); result.sortedProperties.add(functionIndex); } } } //TODO Should we return order entries only when all order clauses are satisfied return orderEntries; }
private static Sort getSort(IndexPlan plan) { List<OrderEntry> sortOrder = plan.getSortOrder(); if (sortOrder == null || sortOrder.isEmpty()) { return null; } sortOrder = removeNativeSort(sortOrder); List<SortField> fieldsList = newArrayListWithCapacity(sortOrder.size()); PlanResult planResult = getPlanResult(plan); for (int i = 0; i < sortOrder.size(); i++) { OrderEntry oe = sortOrder.get(i); PropertyDefinition pd = planResult.getOrderedProperty(i); boolean reverse = oe.getOrder() != OrderEntry.Order.ASCENDING; String propName = oe.getPropertyName(); propName = FieldNames.createDocValFieldName(propName); fieldsList.add(new SortField(propName, toLuceneSortType(oe, pd), reverse)); } if (fieldsList.isEmpty()) { return null; } else { return new Sort(fieldsList.toArray(new SortField[0])); } }
private static Sort getSort(IndexPlan plan) { List<OrderEntry> sortOrder = plan.getSortOrder(); if (sortOrder == null || sortOrder.isEmpty()) { return null; } sortOrder = removeNativeSort(sortOrder); List<SortField> fieldsList = newArrayListWithCapacity(sortOrder.size()); PlanResult planResult = getPlanResult(plan); for (int i = 0; i < sortOrder.size(); i++) { OrderEntry oe = sortOrder.get(i); PropertyDefinition pd = planResult.getOrderedProperty(i); boolean reverse = oe.getOrder() != OrderEntry.Order.ASCENDING; String propName = oe.getPropertyName(); propName = FieldNames.createDocValFieldName(propName); fieldsList.add(new SortField(propName, toLuceneSortType(oe, pd), reverse)); } if (fieldsList.isEmpty()) { return null; } else { return new Sort(fieldsList.toArray(new SortField[0])); } }
@Test public void syncIndex_NotUsedWithFulltext() throws Exception{ IndexDefinitionBuilder defnb = new IndexDefinitionBuilder(); defnb.indexRule("nt:base").property("foo").propertyIndex().sync(); defnb.indexRule("nt:base").property("bar").analyzed(); LuceneIndexDefinition defn = new LuceneIndexDefinition(root, defnb.build(), "/foo"); LuceneIndexNode node = createIndexNode(defn, 100); FilterImpl filter = createFilter("nt:base"); filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar")); filter.setFullTextConstraint(FullTextParser.parse("bar", "mountain")); FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, ImmutableList.of(new OrderEntry("bar", Type.LONG, OrderEntry.Order.ASCENDING))); QueryIndex.IndexPlan plan = planner.getPlan(); assertNotNull(plan); assertEquals(documentsPerValue(100), plan.getEstimatedEntryCount()); PropertyIndexResult hr = pr(plan).getPropertyIndexResult(); assertNull(hr); }
@Test public void syncIndex_NotUsedWithSort() throws Exception{ IndexDefinitionBuilder defnb = new IndexDefinitionBuilder(); defnb.indexRule("nt:base").property("foo").propertyIndex().sync(); defnb.indexRule("nt:base").property("bar").propertyIndex().ordered(); LuceneIndexDefinition defn = new LuceneIndexDefinition(root, defnb.build(), "/foo"); LuceneIndexNode node = createIndexNode(defn, 100); FilterImpl filter = createFilter("nt:base"); filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar")); FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, ImmutableList.of(new OrderEntry("bar", Type.LONG, OrderEntry.Order.ASCENDING))); QueryIndex.IndexPlan plan = planner.getPlan(); assertNotNull(plan); assertEquals(documentsPerValue(100), plan.getEstimatedEntryCount()); PropertyIndexResult hr = pr(plan).getPropertyIndexResult(); assertNull(hr); }
private static SortField.Type toLuceneSortType(OrderEntry oe, PropertyDefinition defn) { Type<?> t = oe.getPropertyType(); checkState(t != null, "Type cannot be null"); checkState(!t.isArray(), "Array types are not supported"); int type = getPropertyType(defn, oe.getPropertyName(), t.tag()); switch (type) { case PropertyType.LONG: case PropertyType.DATE: return SortField.Type.LONG; case PropertyType.DOUBLE: return SortField.Type.DOUBLE; default: //TODO Check about SortField.Type.STRING_VAL return SortField.Type.STRING; } }
private static SortField.Type toLuceneSortType(OrderEntry oe, PropertyDefinition defn) { Type<?> t = oe.getPropertyType(); checkState(t != null, "Type cannot be null"); checkState(!t.isArray(), "Array types are not supported"); int type = getPropertyType(defn, oe.getPropertyName(), t.tag()); switch (type) { case PropertyType.LONG: case PropertyType.DATE: return SortField.Type.LONG; case PropertyType.DOUBLE: return SortField.Type.DOUBLE; default: //TODO Check about SortField.Type.STRING_VAL return SortField.Type.STRING; } }
@Test public void noRestrictionWithTwoSortableFields() throws Exception{ NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo", "bar"), "async"); defn.setProperty(createProperty(ORDERED_PROP_NAMES, of("foo", "bar"), STRINGS)); LuceneIndexDefinition definition = new LuceneIndexDefinition(root, defn.getNodeState(), "/test"); LuceneIndexNode node = createIndexNode(definition); FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/test", createFilter("nt:base"), ImmutableList.of(new OrderEntry("foo", Type.LONG, OrderEntry.Order.ASCENDING), new OrderEntry("bar", Type.LONG, OrderEntry.Order.ASCENDING))); assertNotNull(planner.getPlan()); assertEquals(1, planner.getPlan().getEstimatedEntryCount()); assertEquals(definition.getCostPerEntry()/3, planner.getPlan().getCostPerEntry(), 0.0001); }
@Override public OrderEntry getOrderEntry(SelectorImpl s, OrderingImpl o) { if (!s.equals(selector)) { // ordered by a different selector return null; } String pn = normalizePropertyName(propertyName); return new OrderEntry( pn, Type.UNDEFINED, o.isDescending() ? OrderEntry.Order.DESCENDING : OrderEntry.Order.ASCENDING); }
@Override public OrderEntry getOrderEntry(SelectorImpl s, OrderingImpl o) { if (!s.equals(selector)) { // ordered by a different selector return null; } String pn = normalizePropertyName(propertyName); return new OrderEntry( pn, Type.UNDEFINED, o.isDescending() ? OrderEntry.Order.DESCENDING : OrderEntry.Order.ASCENDING); }
@Test public void noRestrictionWithSingleSortableField() throws Exception{ NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async"); defn.setProperty(createProperty(ORDERED_PROP_NAMES, of("foo"), STRINGS)); LuceneIndexDefinition definition = new LuceneIndexDefinition(root, defn.getNodeState(), "/test"); LuceneIndexNode node = createIndexNode(definition); FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/test", createFilter("nt:base"), ImmutableList.of(new OrderEntry("foo", Type.LONG, OrderEntry.Order.ASCENDING), new OrderEntry("bar", Type.LONG, OrderEntry.Order.ASCENDING))); assertNotNull(planner.getPlan()); assertEquals(1, planner.getPlan().getEstimatedEntryCount()); assertEquals(definition.getCostPerEntry()/2, planner.getPlan().getCostPerEntry(), 0.0001); }
@Override public OrderEntry getOrderEntry(SelectorImpl s, OrderingImpl o) { String fn = getFunction(s); if (fn != null) { return new OrderEntry( QueryConstants.FUNCTION_RESTRICTION_PREFIX + fn, Type.STRING, o.isDescending() ? OrderEntry.Order.DESCENDING : OrderEntry.Order.ASCENDING); } return null; }
@Override public OrderEntry getOrderEntry(SelectorImpl s, OrderingImpl o) { String fn = getFunction(s); if (fn != null) { return new OrderEntry( QueryConstants.FUNCTION_RESTRICTION_PREFIX + fn, Type.STRING, o.isDescending() ? OrderEntry.Order.DESCENDING : OrderEntry.Order.ASCENDING); } return null; }