diff --git oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/FieldNames.java oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/FieldNames.java index 9615e05..0653023 100644 --- oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/FieldNames.java +++ oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/FieldNames.java @@ -75,6 +75,12 @@ public final class FieldNames { public static final String FULLTEXT_RELATIVE_NODE = "fullnode:"; /** + * Name of the field that contains those property names which are not found + * (or were null) for the given + */ + public static final String NULL_PROPS = ":nullProps"; + + /** * Used to select only the PATH field from the lucene documents */ public static final Set PATH_SELECTOR = new HashSet( diff --git oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/IndexDefinition.java oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/IndexDefinition.java index 16f96df..fcd547c 100644 --- oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/IndexDefinition.java +++ oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/IndexDefinition.java @@ -72,7 +72,6 @@ import static org.apache.jackrabbit.JcrConstants.JCR_SCORE; import static org.apache.jackrabbit.JcrConstants.NT_BASE; import static org.apache.jackrabbit.oak.api.Type.NAMES; import static org.apache.jackrabbit.oak.commons.PathUtils.getParentPath; -import static org.apache.jackrabbit.oak.commons.PathUtils.isAbsolute; import static org.apache.jackrabbit.oak.plugins.index.IndexConstants.DECLARING_NODE_TYPES; import static org.apache.jackrabbit.oak.plugins.index.IndexConstants.ENTRY_COUNT_PROPERTY_NAME; import static org.apache.jackrabbit.oak.plugins.index.IndexConstants.REINDEX_COUNT; @@ -562,6 +561,7 @@ class IndexDefinition implements Aggregate.AggregateMapper{ private final String nodeTypeName; private final Map propConfigs; private final List namePatterns; + private final List nullCheckEnabledProperties; private final boolean indexesAllNodesOfMatchingType; final float boost; @@ -582,15 +582,18 @@ class IndexDefinition implements Aggregate.AggregateMapper{ this.propertyTypes = getSupportedTypes(config, INCLUDE_PROPERTY_TYPES, TYPES_ALLOW_ALL); List namePatterns = newArrayList(); + List nonExistentProperties = newArrayList(); List propIncludes = newArrayList(); - this.propConfigs = collectPropConfigs(config, namePatterns, propIncludes); + this.propConfigs = collectPropConfigs(config, namePatterns, propIncludes, nonExistentProperties); this.propAggregate = new Aggregate(nodeTypeName, propIncludes); this.aggregate = combine(propAggregate, nodeTypeName); this.namePatterns = ImmutableList.copyOf(namePatterns); + this.nullCheckEnabledProperties = ImmutableList.copyOf(nonExistentProperties); this.fulltextEnabled = aggregate.hasNodeAggregates() || hasAnyFullTextEnabledProperty(); this.propertyIndexEnabled = hasAnyPropertyIndexConfigured(); this.indexesAllNodesOfMatchingType = allMatchingNodeByTypeIndexed(); + validateRuleDefinition(); } /** @@ -610,6 +613,7 @@ class IndexDefinition implements Aggregate.AggregateMapper{ this.propertyTypes = original.propertyTypes; this.propertyIndexEnabled = original.propertyIndexEnabled; this.propAggregate = original.propAggregate; + this.nullCheckEnabledProperties = original.nullCheckEnabledProperties; this.aggregate = combine(propAggregate, nodeTypeName); this.fulltextEnabled = aggregate.hasNodeAggregates() || original.fulltextEnabled; this.indexesAllNodesOfMatchingType = allMatchingNodeByTypeIndexed(); @@ -637,6 +641,10 @@ class IndexDefinition implements Aggregate.AggregateMapper{ return nodeTypeName; } + public List getNullCheckEnabledProperties() { + return nullCheckEnabledProperties; + } + @Override public String toString() { String str = "IndexRule: "+ nodeTypeName; @@ -729,7 +737,8 @@ class IndexDefinition implements Aggregate.AggregateMapper{ } private Map collectPropConfigs(NodeState config, List patterns, - List propAggregate) { + List propAggregate, + List nonExistentProperties) { Map propDefns = newHashMap(); NodeState propNode = config.getChildNode(LuceneIndexConstants.PROP_NODE); @@ -755,9 +764,13 @@ class IndexDefinition implements Aggregate.AggregateMapper{ propDefns.put(pd.name, pd); } - if (isRelativeProperty(pd.name)){ + if (pd.relative){ propAggregate.add(new Aggregate.PropertyInclude(pd)); } + + if (pd.nullCheckEnabled){ + nonExistentProperties.add(pd); + } } } return ImmutableMap.copyOf(propDefns); @@ -800,6 +813,15 @@ class IndexDefinition implements Aggregate.AggregateMapper{ return true; } + //If there is nullCheckEnabled property which is not relative then + //all nodes would be indexed. relativeProperty with nullCheckEnabled might + //not ensure that (OAK-1085) + for (PropertyDefinition pd : nullCheckEnabledProperties){ + if (!pd.relative) { + return true; + } + } + //jcr:primaryType is present on all node. So if such a property //is indexed then it would mean all nodes covered by this index rule //are indexed @@ -819,6 +841,13 @@ class IndexDefinition implements Aggregate.AggregateMapper{ } return new Aggregate(nodeTypeName, includes); } + + private void validateRuleDefinition() { + if (!nullCheckEnabledProperties.isEmpty() && isBasedOnNtBase()){ + throw new IllegalStateException("nt:base based rule cannot have a " + + "PropertyDefinition with nullCheckEnabled"); + } + } } /** @@ -948,7 +977,7 @@ class IndexDefinition implements Aggregate.AggregateMapper{ String propNodeName = propName; //For proper propName use the propName as childNode name - if(isRelativeProperty(propName) + if(PropertyDefinition.isRelativeProperty(propName) || propName.equals(includeAllProp)){ propNodeName = "prop" + i++; } @@ -1010,7 +1039,7 @@ class IndexDefinition implements Aggregate.AggregateMapper{ private static NodeState getPropDefnNode(NodeState defn, String propName){ NodeState propNode = defn.getChildNode(LuceneIndexConstants.PROP_NODE); NodeState propDefNode; - if (isRelativeProperty(propName)) { + if (PropertyDefinition.isRelativeProperty(propName)) { NodeState result = propNode; for (String name : PathUtils.elements(propName)) { result = result.getChildNode(name); @@ -1239,7 +1268,4 @@ class IndexDefinition implements Aggregate.AggregateMapper{ return defn.getChildNode(LuceneIndexConstants.INDEX_RULES).exists(); } - private static boolean isRelativeProperty(String propertyName){ - return !isAbsolute(propertyName) && PathUtils.getNextSlash(propertyName, 0) > 0; - } } diff --git oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/IndexPlanner.java oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/IndexPlanner.java index 7974a51..5372ce3 100644 --- oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/IndexPlanner.java +++ oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/IndexPlanner.java @@ -47,6 +47,7 @@ import static org.apache.jackrabbit.JcrConstants.JCR_SCORE; import static org.apache.jackrabbit.oak.commons.PathUtils.getAncestorPath; import static org.apache.jackrabbit.oak.commons.PathUtils.getDepth; import static org.apache.jackrabbit.oak.commons.PathUtils.getParentPath; +import static org.apache.jackrabbit.oak.plugins.index.lucene.LucenePropertyIndex.propertyIsNullRestriction; import static org.apache.jackrabbit.oak.spi.query.Filter.PropertyRestriction; import static org.apache.jackrabbit.oak.spi.query.QueryIndex.IndexPlan; import static org.apache.jackrabbit.oak.spi.query.QueryIndex.OrderEntry; @@ -141,6 +142,10 @@ class IndexPlanner { for (PropertyRestriction pr : filter.getPropertyRestrictions()) { PropertyDefinition pd = indexingRule.getConfig(pr.propertyName); if (pd != null && pd.propertyIndexEnabled()) { + //TODO Add test + if (propertyIsNullRestriction(pr) && !pd.nullCheckEnabled){ + continue; + } indexedProps.add(pr.propertyName); result.propDefns.put(pr.propertyName, pd); } diff --git oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/LuceneIndexConstants.java oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/LuceneIndexConstants.java index 258071a..43bded7 100644 --- oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/LuceneIndexConstants.java +++ oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/LuceneIndexConstants.java @@ -241,4 +241,10 @@ public interface LuceneIndexConstants { * whether use this property values for spellchecking */ String PROP_USE_IN_SPELLCHECK = "useInSpellcheck"; + + /** + * Property definition config indicating that null check support should be + * enabled for this property + */ + String PROP_NULL_CHECK_ENABLED = "nullCheckEnabled"; } diff --git oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/LuceneIndexEditor.java oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/LuceneIndexEditor.java index 68e0904..0a33b3f 100644 --- oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/LuceneIndexEditor.java +++ oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/LuceneIndexEditor.java @@ -303,6 +303,7 @@ public class LuceneIndexEditor implements IndexEditor, Aggregate.AggregateRoot { } dirty |= indexAggregates(path, fields, state); + dirty |= indexNullCheckEnabledProps(path, fields, state); if (isUpdate && !dirty) { // updated the state but had no relevant changes @@ -514,6 +515,46 @@ public class LuceneIndexEditor implements IndexEditor, Aggregate.AggregateRoot { return fields; } + //~-------------------------------------------------------< NullCheck Support > + + private boolean indexNullCheckEnabledProps(String path, List fields, NodeState state) { + boolean fieldAdded = false; + for (PropertyDefinition pd : indexingRule.getNullCheckEnabledProperties()) { + if (isPropertyNull(state, pd)) { + fields.add(new StringField(FieldNames.NULL_PROPS, pd.name, Field.Store.NO)); + fieldAdded = true; + } + } + return fieldAdded; + } + + /** + * Determine if the property as defined by PropertyDefinition exists or not. + * + *

For relative property if the intermediate nodes do not exist then property is + * not considered to be null

+ * + * @return true if the property does not exist + */ + private boolean isPropertyNull(NodeState state, PropertyDefinition pd){ + NodeState propertyNode = getPropertyNode(state, pd); + if (!propertyNode.exists()){ + return false; + } + return !propertyNode.hasProperty(pd.nonRelativeName); + } + + private static NodeState getPropertyNode(NodeState nodeState, PropertyDefinition pd) { + if (!pd.relative){ + return nodeState; + } + NodeState node = nodeState; + for (String name : pd.ancestors) { + node = node.getChildNode(name); + } + return node; + } + //~-------------------------------------------------------< Aggregate > @Override diff --git oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/LucenePropertyIndex.java oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/LucenePropertyIndex.java index 4c31129..0e7c08f 100644 --- oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/LucenePropertyIndex.java +++ oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/LucenePropertyIndex.java @@ -718,6 +718,11 @@ public class LucenePropertyIndex implements AdvancedQueryIndex, QueryIndex, Nati private static Query createQuery(PropertyRestriction pr, PropertyDefinition defn) { int propType = determinePropertyType(defn, pr); + + if (propertyIsNullRestriction(pr)){ + return new TermQuery(new Term(FieldNames.NULL_PROPS, defn.name)); + } + switch (propType) { case PropertyType.DATE: { Long first = pr.first != null ? FieldFactory.dateToLong(pr.first.getValue(Type.DATE)) : null; @@ -742,7 +747,7 @@ public class LucenePropertyIndex implements AdvancedQueryIndex, QueryIndex, Nati in.add(NumericRangeQuery.newLongRange(pr.propertyName, dateVal, dateVal, true, true), BooleanClause.Occur.SHOULD); } return in; - } else if (pr.first == null && pr.last == null ) { + } else if (propertyNotNullRestriction(pr)) { // not null. For date lower bound of zero can be used return NumericRangeQuery.newLongRange(pr.propertyName, 0L, Long.MAX_VALUE, true, true); } @@ -772,7 +777,7 @@ public class LucenePropertyIndex implements AdvancedQueryIndex, QueryIndex, Nati in.add(NumericRangeQuery.newDoubleRange(pr.propertyName, doubleVal, doubleVal, true, true), BooleanClause.Occur.SHOULD); } return in; - } else if (pr.first == null && pr.last == null ) { + } else if (propertyNotNullRestriction(pr)) { // not null. return NumericRangeQuery.newDoubleRange(pr.propertyName, Double.MIN_VALUE, Double.MAX_VALUE, true, true); } @@ -801,7 +806,7 @@ public class LucenePropertyIndex implements AdvancedQueryIndex, QueryIndex, Nati in.add(NumericRangeQuery.newLongRange(pr.propertyName, longVal, longVal, true, true), BooleanClause.Occur.SHOULD); } return in; - } else if (pr.first == null && pr.last == null ) { + } else if (propertyNotNullRestriction(pr)) { // not null. return NumericRangeQuery.newLongRange(pr.propertyName, Long.MIN_VALUE, Long.MAX_VALUE, true, true); } @@ -835,7 +840,7 @@ public class LucenePropertyIndex implements AdvancedQueryIndex, QueryIndex, Nati in.add(new TermQuery(new Term(pr.propertyName, strVal)), BooleanClause.Occur.SHOULD); } return in; - } else if (pr.first == null && pr.last == null ) { + } else if (propertyNotNullRestriction(pr)) { return new TermRangeQuery(pr.propertyName, null, null, true, true); } } @@ -843,6 +848,14 @@ public class LucenePropertyIndex implements AdvancedQueryIndex, QueryIndex, Nati throw new IllegalStateException("PropertyRestriction not handled " + pr + " for index " + defn ); } + static boolean propertyNotNullRestriction(PropertyRestriction pr) { + return pr.first == null && pr.last == null && !pr.lastIncluding && !pr.firstIncluding; + } + + static boolean propertyIsNullRestriction(PropertyRestriction pr) { + return pr.first == null && pr.last == null && pr.lastIncluding && pr.firstIncluding; + } + private static void addReferenceConstraint(String uuid, List qs, IndexReader reader) { if (reader == null) { diff --git oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/PropertyDefinition.java oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/PropertyDefinition.java index 3362847..00e6325 100644 --- oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/PropertyDefinition.java +++ oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/PropertyDefinition.java @@ -19,16 +19,22 @@ package org.apache.jackrabbit.oak.plugins.index.lucene; +import javax.annotation.CheckForNull; import javax.jcr.PropertyType; import org.apache.jackrabbit.oak.api.PropertyState; import org.apache.jackrabbit.oak.api.Type; +import org.apache.jackrabbit.oak.commons.PathUtils; import org.apache.jackrabbit.oak.plugins.index.lucene.IndexDefinition.IndexingRule; import org.apache.jackrabbit.oak.plugins.index.lucene.util.LuceneIndexHelper; import org.apache.jackrabbit.oak.spi.state.NodeState; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import static com.google.common.collect.ImmutableList.copyOf; +import static com.google.common.collect.Iterables.toArray; +import static org.apache.jackrabbit.oak.commons.PathUtils.elements; +import static org.apache.jackrabbit.oak.commons.PathUtils.isAbsolute; import static org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexConstants.FIELD_BOOST; import static org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexConstants.PROP_IS_REGEX; import static org.apache.jackrabbit.oak.plugins.index.lucene.util.ConfigUtil.getOptionalValue; @@ -68,15 +74,29 @@ class PropertyDefinition { final boolean ordered; + final boolean nullCheckEnabled; + final int includedPropertyTypes; - boolean useInSuggest; + final boolean relative; + + final boolean useInSuggest; + + final boolean useInSpellcheck; - boolean useInSpellcheck; + final String[] ancestors; + + /** + * Property name excluding the relativePath. For regular expression based definition + * its set to null + */ + @CheckForNull + final String nonRelativeName; - public PropertyDefinition(IndexingRule idxDefn, String name, NodeState defn) { + public PropertyDefinition(IndexingRule idxDefn, String nodeName, NodeState defn) { this.isRegexp = getOptionalValue(defn, PROP_IS_REGEX, false); - this.name = getName(defn, name); + this.name = getName(defn, nodeName); + this.relative = isRelativeProperty(name); this.boost = getOptionalValue(defn, FIELD_BOOST, DEFAULT_BOOST); //By default if a property is defined it is indexed @@ -93,11 +113,16 @@ class PropertyDefinition { //TODO Add test case for above cases - this.propertyType = getPropertyType(idxDefn, name, defn); + this.propertyType = getPropertyType(idxDefn, nodeName, defn); this.useInSuggest = getOptionalValue(defn, LuceneIndexConstants.PROP_USE_IN_SUGGEST, false); this.useInSpellcheck = getOptionalValue(defn, LuceneIndexConstants.PROP_USE_IN_SPELLCHECK, false); + this.nullCheckEnabled = getOptionalValue(defn, LuceneIndexConstants.PROP_NULL_CHECK_ENABLED, false); + this.nonRelativeName = determineNonRelativeName(); + this.ancestors = computeAncestors(name); + validate(); } + /** * If 'analyzed' is enabled then property value would be used to evaluate the * contains clause related to those properties. In such mode also some properties @@ -156,12 +181,40 @@ class PropertyDefinition { ", analyzed=" + analyzed + ", ordered=" + ordered + ", useInSuggest=" + useInSuggest+ - ", useInSpellcheck=" + useInSpellcheck+ + ", nullCheckEnabled=" + nullCheckEnabled+ '}'; } + static boolean isRelativeProperty(String propertyName){ + return !isAbsolute(propertyName) && PathUtils.getNextSlash(propertyName, 0) > 0; + } + //~---------------------------------------------< internal > + private void validate() { + if (nullCheckEnabled && isRegexp){ + throw new IllegalStateException(String.format("%s can be set to true for property definition using " + + "regular expression", LuceneIndexConstants.PROP_NULL_CHECK_ENABLED)); + } + } + + private String determineNonRelativeName() { + if (isRegexp){ + return null; + } + + if (!relative){ + return name; + } + + return PathUtils.getName(name); + } + + private static String[] computeAncestors(String parentPath) { + return toArray(copyOf(elements(PathUtils.getParentPath(parentPath))), String.class); + } + + private static String getName(NodeState definition, String defaultName){ PropertyState ps = definition.getProperty(LuceneIndexConstants.PROP_NAME); return ps == null ? defaultName : ps.getValue(Type.STRING); diff --git oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/IndexDefinitionTest.java oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/IndexDefinitionTest.java index 5215d8f..fe06cf1 100644 --- oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/IndexDefinitionTest.java +++ oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/IndexDefinitionTest.java @@ -51,12 +51,14 @@ import static org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexConstant import static org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexConstants.PROP_NAME; import static org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexConstants.PROP_NODE; import static org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexConstants.TIKA; +import static org.apache.jackrabbit.oak.plugins.index.lucene.TestUtil.registerTestNodeType; import static org.apache.jackrabbit.oak.plugins.index.lucene.util.LuceneIndexHelper.newLuceneIndexDefinition; import static org.apache.jackrabbit.oak.plugins.index.lucene.util.LuceneIndexHelper.newLucenePropertyIndexDefinition; import static org.apache.jackrabbit.oak.plugins.memory.EmptyNodeState.EMPTY_NODE; import static org.apache.jackrabbit.oak.plugins.memory.PropertyStates.createProperty; import static org.apache.jackrabbit.oak.plugins.nodetype.write.InitialContent.INITIAL_CONTENT; import static org.apache.jackrabbit.oak.plugins.tree.impl.TreeConstants.OAK_CHILD_ORDER; +import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; @@ -154,6 +156,8 @@ public class IndexDefinitionTest { assertNotNull(rule.getConfig("foo1/bar")); assertEquals(PropertyType.DATE, rule.getConfig("foo1/bar").getType()); assertEquals(PropertyType.LONG, rule.getConfig("foo2/bar2/baz").getType()); + assertTrue(rule.getConfig("foo1/bar").relative); + assertArrayEquals(new String[]{"foo2", "bar2"}, rule.getConfig("foo2/bar2/baz").ancestors); } @Test @@ -519,6 +523,38 @@ public class IndexDefinitionTest { assertEquals(1000, defn.getMaxExtractLength()); } + @Test(expected = IllegalStateException.class) + public void nullCheckEnabledWithNtBase() throws Exception{ + builder.child(PROP_NODE).child("foo").setProperty(LuceneIndexConstants.PROP_NULL_CHECK_ENABLED, true); + IndexDefinition idxDefn = new IndexDefinition(root, builder.getNodeState()); + } + + @Test(expected = IllegalStateException.class) + public void nullCheckEnabledWithRegex() throws Exception{ + NodeBuilder rules = builder.child(INDEX_RULES); + rules.child(TestUtil.NT_TEST); + child(rules, "oak:TestNode/properties/prop2") + .setProperty(LuceneIndexConstants.PROP_NAME, ".*") + .setProperty(LuceneIndexConstants.PROP_IS_REGEX, true) + .setProperty(LuceneIndexConstants.PROP_NULL_CHECK_ENABLED, true); + root = registerTestNodeType(builder).getNodeState(); + IndexDefinition idxDefn = new IndexDefinition(root, builder.getNodeState()); + } + + @Test + public void nullCheckEnabledWithTestNode() throws Exception{ + NodeBuilder rules = builder.child(INDEX_RULES); + rules.child(TestUtil.NT_TEST); + child(rules, "oak:TestNode/properties/prop2") + .setProperty(LuceneIndexConstants.PROP_NAME, "foo") + .setProperty(LuceneIndexConstants.PROP_NULL_CHECK_ENABLED, true); + root = registerTestNodeType(builder).getNodeState(); + IndexDefinition idxDefn = new IndexDefinition(root, builder.getNodeState()); + assertTrue(!idxDefn.getApplicableIndexingRule(TestUtil.NT_TEST).getNullCheckEnabledProperties().isEmpty()); + } + + //TODO indexesAllNodesOfMatchingType - with nullCheckEnabled + private static IndexingRule getRule(IndexDefinition defn, String typeName){ return defn.getApplicableIndexingRule(newTree(newNode(typeName))); } diff --git oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/LuceneIndexTest.java oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/LuceneIndexTest.java index cee4ca0..3ea287e 100644 --- oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/LuceneIndexTest.java +++ oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/LuceneIndexTest.java @@ -48,6 +48,8 @@ import static org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexConstant import static org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexConstants.PERSISTENCE_FILE; import static org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexConstants.PERSISTENCE_NAME; import static org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexConstants.PERSISTENCE_PATH; +import static org.apache.jackrabbit.oak.plugins.index.lucene.TestUtil.NT_TEST; +import static org.apache.jackrabbit.oak.plugins.index.lucene.TestUtil.createNodeWithType; import static org.apache.jackrabbit.oak.plugins.index.lucene.util.LuceneIndexHelper.newLuceneIndexDefinition; import static org.apache.jackrabbit.oak.plugins.index.lucene.util.LuceneIndexHelper.newLucenePropertyIndexDefinition; import static org.apache.jackrabbit.oak.plugins.nodetype.NodeTypeConstants.JCR_NODE_TYPES; @@ -227,6 +229,81 @@ public class LuceneIndexTest { } @Test + public void testPropertyNonExistence() throws Exception { + root = TestUtil.registerTestNodeType(builder).getNodeState(); + + NodeBuilder index = newLucenePropertyIndexDefinition(builder.child(INDEX_DEFINITIONS_NAME), + "lucene", ImmutableSet.of("foo"), null); + NodeBuilder rules = index.child(INDEX_RULES); + NodeBuilder propNode = rules.child(NT_TEST).child(LuceneIndexConstants.PROP_NODE); + + NodeBuilder fooProp = propNode.child("foo"); + fooProp.setProperty(LuceneIndexConstants.PROP_PROPERTY_INDEX, true); + fooProp.setProperty(LuceneIndexConstants.PROP_NULL_CHECK_ENABLED, true); + + NodeState before = builder.getNodeState(); + createNodeWithType(builder, "a", NT_TEST).setProperty("foo", "bar"); + createNodeWithType(builder, "b", NT_TEST).setProperty("foo", "bar"); + createNodeWithType(builder, "c", NT_TEST); + + NodeState after = builder.getNodeState(); + + NodeState indexed = HOOK.processCommit(before, after,CommitInfo.EMPTY); + + IndexTracker tracker = new IndexTracker(); + tracker.update(indexed); + AdvancedQueryIndex queryIndex = new LucenePropertyIndex(tracker); + + FilterImpl filter = createFilter(NT_TEST); + filter.restrictProperty("foo", Operator.EQUAL, null); + assertFilter(filter, queryIndex, indexed, ImmutableList.of("/c")); + } + + @Test + public void testRelativePropertyNonExistence() throws Exception { + root = TestUtil.registerTestNodeType(builder).getNodeState(); + + NodeBuilder index = newLucenePropertyIndexDefinition(builder.child(INDEX_DEFINITIONS_NAME), + "lucene", ImmutableSet.of("foo"), null); + NodeBuilder rules = index.child(INDEX_RULES); + NodeBuilder propNode = rules.child(NT_TEST).child(LuceneIndexConstants.PROP_NODE); + + propNode.child("bar") + .setProperty(LuceneIndexConstants.PROP_NAME, "jcr:content/bar") + .setProperty(LuceneIndexConstants.PROP_PROPERTY_INDEX, true) + .setProperty(LuceneIndexConstants.PROP_NULL_CHECK_ENABLED, true); + + NodeState before = builder.getNodeState(); + + NodeBuilder a1 = createNodeWithType(builder, "a1", NT_TEST); + a1.child("jcr:content").setProperty("bar", "foo"); + + NodeBuilder b1 = createNodeWithType(builder, "b1", NT_TEST); + b1.child("jcr:content"); + + NodeState after = builder.getNodeState(); + + NodeState indexed = HOOK.processCommit(before, after,CommitInfo.EMPTY); + + IndexTracker tracker = new IndexTracker(); + tracker.update(indexed); + AdvancedQueryIndex queryIndex = new LucenePropertyIndex(tracker); + + FilterImpl filter = createFilter(NT_TEST); + filter.restrictProperty("jcr:content/bar", Operator.EQUAL, null); + assertFilter(filter, queryIndex, indexed, ImmutableList.of("/b1")); + + builder.child("b1").child("jcr:content").setProperty("bar", "foo"); + after = builder.getNodeState(); + indexed = HOOK.processCommit(before, after, CommitInfo.EMPTY); + tracker.update(indexed); + + filter = createFilter(NT_TEST); + filter.restrictProperty("jcr:content/bar", Operator.EQUAL, null); + assertFilter(filter, queryIndex, indexed, Collections.emptyList()); + } + + @Test public void testPathRestrictions() throws Exception { NodeBuilder idx = newLucenePropertyIndexDefinition(builder.child(INDEX_DEFINITIONS_NAME), "lucene", ImmutableSet.of("foo"), null); @@ -494,7 +571,8 @@ public class LuceneIndexTest { for (String p : expected) { assertTrue("Expected path " + p + " not found", paths.contains(p)); } - assertEquals("Result set size is different", expected.size(), paths.size()); + assertEquals("Result set size is different \nExpected: " + + expected + "\nActual: " + paths, expected.size(), paths.size()); return paths; } diff --git oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/LucenePropertyIndexTest.java oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/LucenePropertyIndexTest.java index bdcf687..8db9dd3 100644 --- oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/LucenePropertyIndexTest.java +++ oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/LucenePropertyIndexTest.java @@ -33,6 +33,7 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.Iterables; import com.google.common.collect.Lists; import com.google.common.collect.Maps; +import org.apache.commons.io.IOUtils; import org.apache.jackrabbit.JcrConstants; import org.apache.jackrabbit.oak.Oak; import org.apache.jackrabbit.oak.api.CommitFailedException; @@ -46,6 +47,7 @@ import org.apache.jackrabbit.oak.plugins.index.nodetype.NodeTypeIndexProvider; import org.apache.jackrabbit.oak.plugins.index.property.PropertyIndexEditorProvider; import org.apache.jackrabbit.oak.plugins.memory.PropertyStates; import org.apache.jackrabbit.oak.plugins.nodetype.write.InitialContent; +import org.apache.jackrabbit.oak.plugins.nodetype.write.NodeTypeRegistry; import org.apache.jackrabbit.oak.query.AbstractQueryTest; import org.apache.jackrabbit.oak.spi.commit.Observer; import org.apache.jackrabbit.oak.spi.query.QueryIndexProvider; @@ -296,8 +298,9 @@ public class LucenePropertyIndexTest extends AbstractQueryTest { assertQuery(propabQuery, asList("/test/a", "/test/b", "/test")); } - private static void setNodeType(Tree t, String typeName){ + private static Tree setNodeType(Tree t, String typeName){ t.setProperty(JcrConstants.JCR_PRIMARYTYPE, typeName, Type.NAME); + return t; } @Test @@ -328,6 +331,34 @@ public class LucenePropertyIndexTest extends AbstractQueryTest { assertQuery("select [jcr:path] from [nt:base] where propa is not null", asList("/test/a", "/test/b")); } + + @Test + public void propertyNonExistenceQuery() throws Exception { + String nodeTypeDefn = "[oak:TestNode]\n" + + " - * (UNDEFINED) multiple\n" + + " - * (UNDEFINED)\n" + + " + * (nt:base) = oak:TestNode VERSION"; + + NodeTypeRegistry.register(root, IOUtils.toInputStream(nodeTypeDefn), "test nodeType"); + + Tree idx = createIndex("test1", of("propa", "propb")); + idx.addChild(PROP_NODE).addChild("propa"); + root.commit(); + + Tree test = root.getTree("/").addChild("test"); + createNodeWithType(test, "a", "oak:TestNode").setProperty("propa", "a"); + createNodeWithType(test, "b", "oak:TestNode").setProperty("propa", "c"); + createNodeWithType(test, "c", "oak:TestNode").setProperty("propb", "e"); + root.commit(); + + assertQuery("select [jcr:path] from [oak:TestNode] where [propa] is null", asList("/test/c")); + } + + private static Tree createNodeWithType(Tree t, String nodeName, String typeName){ + t = t.addChild(nodeName); + t.setProperty(JcrConstants.JCR_PRIMARYTYPE, typeName, Type.NAME); + return t; + } @Test public void orderByScore() throws Exception { @@ -781,9 +812,9 @@ public class LucenePropertyIndexTest extends AbstractQueryTest { getSortedPaths(tuples, OrderDirection.ASC)))); // Append the path of property added as timestamp string to the sorted list assertOrderedQuery( - "select [jcr:path] from [nt:base] where [bar] = 'baz' order by [foo] DESC", Lists - .newArrayList(Iterables.concat(getSortedPaths(tuples, OrderDirection.DESC), - Lists.newArrayList("/test/n0")))); + "select [jcr:path] from [nt:base] where [bar] = 'baz' order by [foo] DESC", Lists + .newArrayList(Iterables.concat(getSortedPaths(tuples, OrderDirection.DESC), + Lists.newArrayList("/test/n0")))); } @Test diff --git oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/TestUtil.java oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/TestUtil.java index ed5c61a..562e735 100644 --- oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/TestUtil.java +++ oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/TestUtil.java @@ -26,13 +26,35 @@ import java.util.concurrent.atomic.AtomicInteger; import javax.annotation.Nonnull; import javax.annotation.Nullable; +import org.apache.commons.io.IOUtils; +import org.apache.jackrabbit.JcrConstants; +import org.apache.jackrabbit.oak.api.Root; import org.apache.jackrabbit.oak.api.Tree; +import org.apache.jackrabbit.oak.api.Type; import org.apache.jackrabbit.oak.plugins.index.lucene.util.LuceneIndexHelper; +import org.apache.jackrabbit.oak.plugins.memory.MemoryNodeStore; +import org.apache.jackrabbit.oak.plugins.memory.ModifiedNodeState; +import org.apache.jackrabbit.oak.plugins.name.NamespaceEditorProvider; +import org.apache.jackrabbit.oak.plugins.nodetype.TypeEditorProvider; +import org.apache.jackrabbit.oak.plugins.nodetype.write.NodeTypeRegistry; +import org.apache.jackrabbit.oak.plugins.tree.RootFactory; +import org.apache.jackrabbit.oak.spi.commit.CompositeEditorProvider; +import org.apache.jackrabbit.oak.spi.commit.EditorHook; +import org.apache.jackrabbit.oak.spi.state.ApplyDiff; import org.apache.jackrabbit.oak.spi.state.NodeBuilder; +import org.apache.jackrabbit.oak.spi.state.NodeState; +import org.apache.jackrabbit.oak.spi.state.NodeStore; public class TestUtil { private static final AtomicInteger COUNTER = new AtomicInteger(); + public static final String NT_TEST = "oak:TestNode"; + + private static final String TEST_NODE_TYPE = "[oak:TestNode]\n" + + " - * (UNDEFINED) multiple\n" + + " - * (UNDEFINED)\n" + + " + * (nt:base) = oak:TestNode VERSION"; + static void useV2(NodeBuilder idxNb) { idxNb.setProperty(LuceneIndexConstants.COMPAT_MODE, IndexFormatVersion.V2.getVersion()); } @@ -108,4 +130,34 @@ public class TestUtil { static String unique(String name){ return name + COUNTER.getAndIncrement(); } + + public static NodeBuilder registerTestNodeType(NodeBuilder builder){ + registerNodeType(builder, TEST_NODE_TYPE); + return builder; + } + + public static void registerNodeType(NodeBuilder builder, String nodeTypeDefn){ + //Taken from org.apache.jackrabbit.oak.plugins.nodetype.write.InitialContent + NodeState base = ModifiedNodeState.squeeze(builder.getNodeState()); + NodeStore store = new MemoryNodeStore(base); + Root root = RootFactory.createSystemRoot( + store, new EditorHook(new CompositeEditorProvider( + new NamespaceEditorProvider(), + new TypeEditorProvider())), null, null, null, null); + NodeTypeRegistry.register(root, IOUtils.toInputStream(nodeTypeDefn), "test node types"); + NodeState target = store.getRoot(); + target.compareAgainstBaseState(base, new ApplyDiff(builder)); + } + + public static Tree createNodeWithType(Tree t, String nodeName, String typeName){ + t = t.addChild(nodeName); + t.setProperty(JcrConstants.JCR_PRIMARYTYPE, typeName, Type.NAME); + return t; + } + + public static NodeBuilder createNodeWithType(NodeBuilder builder, String nodeName, String typeName){ + builder = builder.child(nodeName); + builder.setProperty(JcrConstants.JCR_PRIMARYTYPE, typeName, Type.NAME); + return builder; + } }