diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndex.java oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndex.java index 3ec211f..5560f59 100644 --- oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndex.java +++ oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndex.java @@ -28,6 +28,7 @@ import java.util.Set; import org.apache.jackrabbit.oak.api.PropertyValue; import org.apache.jackrabbit.oak.api.Type; +import org.apache.jackrabbit.oak.spi.mount.MountInfoProvider; import org.apache.jackrabbit.oak.spi.query.Cursor; import org.apache.jackrabbit.oak.spi.query.Filter; import org.apache.jackrabbit.oak.spi.query.QueryIndex; @@ -98,11 +99,17 @@ class PropertyIndex implements QueryIndex { private static final Logger LOG = LoggerFactory.getLogger(PropertyIndex.class); + private final MountInfoProvider mountInfoProvider; + /** * Cached property index plan */ private PropertyIndexPlan plan; + PropertyIndex(MountInfoProvider mountInfoProvider) { + this.mountInfoProvider = mountInfoProvider; + } + static Set encode(PropertyValue value) { if (value == null) { return null; @@ -135,13 +142,14 @@ class PropertyIndex implements QueryIndex { if (plan != null && plan.getFilter().toString().equals(filter.toString())) { return plan; } else { - plan = createPlan(root, filter); + plan = createPlan(root, filter, mountInfoProvider); this.plan = plan; return plan; } } - private static PropertyIndexPlan createPlan(NodeState root, Filter filter) { + private static PropertyIndexPlan createPlan(NodeState root, Filter filter, + MountInfoProvider mountInfoProvider) { PropertyIndexPlan bestPlan = null; // TODO support indexes on a path @@ -152,7 +160,7 @@ class PropertyIndex implements QueryIndex { if (PROPERTY.equals(definition.getString(TYPE_PROPERTY_NAME)) && definition.hasChildNode(INDEX_CONTENT_NODE_NAME)) { PropertyIndexPlan plan = new PropertyIndexPlan( - entry.getName(), root, definition, filter); + entry.getName(), root, definition, filter, mountInfoProvider); if (plan.getCost() != Double.POSITIVE_INFINITY) { LOG.debug("property cost for {} is {}", plan.getName(), plan.getCost()); diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndexEditor.java oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndexEditor.java index be91e11..afe463f 100644 --- oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndexEditor.java +++ oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndexEditor.java @@ -43,9 +43,11 @@ import org.apache.jackrabbit.oak.plugins.index.IndexUpdateCallback; import org.apache.jackrabbit.oak.plugins.index.PathFilter; import org.apache.jackrabbit.oak.plugins.index.property.strategy.ContentMirrorStoreStrategy; import org.apache.jackrabbit.oak.plugins.index.property.strategy.IndexStoreStrategy; +import org.apache.jackrabbit.oak.plugins.index.property.strategy.MultiplexingIndexStoreStrategy; import org.apache.jackrabbit.oak.plugins.index.property.strategy.UniqueEntryStoreStrategy; import org.apache.jackrabbit.oak.plugins.nodetype.TypePredicate; import org.apache.jackrabbit.oak.spi.commit.Editor; +import org.apache.jackrabbit.oak.spi.mount.MountInfoProvider; import org.apache.jackrabbit.oak.spi.query.PropertyValues; import org.apache.jackrabbit.oak.spi.state.NodeBuilder; import org.apache.jackrabbit.oak.spi.state.NodeState; @@ -61,11 +63,11 @@ import com.google.common.base.Predicate; class PropertyIndexEditor implements IndexEditor { /** Index storage strategy */ - private static final IndexStoreStrategy MIRROR = + private static final ContentMirrorStoreStrategy MIRROR = new ContentMirrorStoreStrategy(); /** Index storage strategy */ - private static final IndexStoreStrategy UNIQUE = + private static final UniqueEntryStoreStrategy UNIQUE = new UniqueEntryStoreStrategy(); /** Parent editor, or {@code null} if this is the root editor. */ @@ -115,8 +117,10 @@ class PropertyIndexEditor implements IndexEditor { private final PathFilter.Result pathFilterResult; + private final MountInfoProvider mountInfoProvider; + public PropertyIndexEditor(NodeBuilder definition, NodeState root, - IndexUpdateCallback updateCallback) { + IndexUpdateCallback updateCallback, MountInfoProvider mountInfoProvider) { this.parent = null; this.name = null; this.path = "/"; @@ -152,6 +156,7 @@ class PropertyIndexEditor implements IndexEditor { this.keysToCheckForUniqueness = null; } this.updateCallback = updateCallback; + this.mountInfoProvider = mountInfoProvider; } PropertyIndexEditor(PropertyIndexEditor parent, String name, PathFilter.Result pathFilterResult) { @@ -166,6 +171,7 @@ class PropertyIndexEditor implements IndexEditor { this.updateCallback = parent.updateCallback; this.pathFilter = parent.pathFilter; this.pathFilterResult = pathFilterResult; + this.mountInfoProvider = parent.mountInfoProvider; } /** @@ -221,8 +227,10 @@ class PropertyIndexEditor implements IndexEditor { return keys; } - IndexStoreStrategy getStrategy(boolean unique) { - return unique ? UNIQUE : MIRROR; + MultiplexingIndexStoreStrategy getStrategy(boolean unique) { + //[multiplex] TODO Avoid creating new instance and maintain them in root state OAK-3757 + return unique ? new MultiplexingIndexStoreStrategy(UNIQUE, mountInfoProvider) : + new MultiplexingIndexStoreStrategy(MIRROR, mountInfoProvider); } @Override @@ -285,14 +293,16 @@ class PropertyIndexEditor implements IndexEditor { if (!beforeKeys.isEmpty() || !afterKeys.isEmpty()) { updateCallback.indexUpdate(); - NodeBuilder index = definition.child(INDEX_CONTENT_NODE_NAME); - String properties = definition.getString(PROPERTY_NAMES); boolean uniqueIndex = keysToCheckForUniqueness != null; + MultiplexingIndexStoreStrategy strategy = getStrategy(uniqueIndex); + NodeBuilder index = getIndexNode(strategy); + String properties = definition.getString(PROPERTY_NAMES); + if (uniqueIndex) { keysToCheckForUniqueness.addAll( - getExistingKeys(afterKeys, index)); + getExistingKeys(afterKeys)); } - getStrategy(uniqueIndex).update( + strategy.update( index, getPath(), properties, definition, beforeKeys, afterKeys); } } @@ -330,11 +340,10 @@ class PropertyIndexEditor implements IndexEditor { * @param index the index * @return the set of keys that already exist in this unique index */ - private Set getExistingKeys(Set keys, NodeBuilder index) { + private Set getExistingKeys(Set keys) { Set existing = null; - IndexStoreStrategy s = getStrategy(true); for (String key : keys) { - if (s.exists(index, key)) { + if (keyExists(key)) { if (existing == null) { existing = newHashSet(); } @@ -346,7 +355,7 @@ class PropertyIndexEditor implements IndexEditor { } return existing; } - + /** * From a set of keys, get the first that has multiple entries, if any. * @@ -442,4 +451,12 @@ class PropertyIndexEditor implements IndexEditor { private PathFilter.Result getPathFilterResult(String childNodeName) { return pathFilter.filter(concat(getPath(), childNodeName)); } + + private boolean keyExists(String key) { + return getStrategy(true).existsInAnyStore(definition, key); + } + + private NodeBuilder getIndexNode(MultiplexingIndexStoreStrategy store) { + return definition.child(store.getIndexNodeName(getPath())); + } } \ No newline at end of file diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndexEditorProvider.java oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndexEditorProvider.java index 052c0e1..9fe2837 100644 --- oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndexEditorProvider.java +++ oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndexEditorProvider.java @@ -20,11 +20,13 @@ import javax.annotation.Nonnull; import org.apache.felix.scr.annotations.Component; import org.apache.felix.scr.annotations.Property; +import org.apache.felix.scr.annotations.Reference; import org.apache.felix.scr.annotations.Service; import org.apache.jackrabbit.oak.plugins.index.IndexConstants; import org.apache.jackrabbit.oak.plugins.index.IndexEditorProvider; import org.apache.jackrabbit.oak.spi.commit.Editor; import org.apache.jackrabbit.oak.plugins.index.IndexUpdateCallback; +import org.apache.jackrabbit.oak.spi.mount.MountInfoProvider; import org.apache.jackrabbit.oak.spi.state.NodeBuilder; import org.apache.jackrabbit.oak.spi.state.NodeState; @@ -42,13 +44,20 @@ public class PropertyIndexEditorProvider implements IndexEditorProvider { public static final String TYPE = "property"; + @Reference + private MountInfoProvider mountInfoProvider = MountInfoProvider.DEFAULT; + @Override public Editor getIndexEditor( @Nonnull String type, @Nonnull NodeBuilder definition, @Nonnull NodeState root, @Nonnull IndexUpdateCallback callback) { if (TYPE.equals(type)) { - return new PropertyIndexEditor(definition, root, callback); + return new PropertyIndexEditor(definition, root, callback, mountInfoProvider); } return null; } + public PropertyIndexEditorProvider with(MountInfoProvider mountInfoProvider) { + this.mountInfoProvider = mountInfoProvider; + return this; + } } \ No newline at end of file diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndexLookup.java oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndexLookup.java index 4ecde59..5b914f1 100644 --- oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndexLookup.java +++ oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndexLookup.java @@ -37,7 +37,9 @@ import org.apache.jackrabbit.oak.commons.PathUtils; import org.apache.jackrabbit.oak.plugins.index.IndexConstants; import org.apache.jackrabbit.oak.plugins.index.property.strategy.ContentMirrorStoreStrategy; import org.apache.jackrabbit.oak.plugins.index.property.strategy.IndexStoreStrategy; +import org.apache.jackrabbit.oak.plugins.index.property.strategy.MultiplexingIndexStoreStrategy; import org.apache.jackrabbit.oak.plugins.index.property.strategy.UniqueEntryStoreStrategy; +import org.apache.jackrabbit.oak.spi.mount.MountInfoProvider; import org.apache.jackrabbit.oak.spi.query.Filter; import org.apache.jackrabbit.oak.spi.state.ChildNodeEntry; import org.apache.jackrabbit.oak.spi.state.NodeState; @@ -69,17 +71,24 @@ public class PropertyIndexLookup { static final int MAX_COST = 100; /** Index storage strategy */ - private static final IndexStoreStrategy MIRROR = + private static final ContentMirrorStoreStrategy MIRROR = new ContentMirrorStoreStrategy(); /** Index storage strategy */ - private static final IndexStoreStrategy UNIQUE = + private static final UniqueEntryStoreStrategy UNIQUE = new UniqueEntryStoreStrategy(); private final NodeState root; + private final MountInfoProvider mountInfoProvider; + public PropertyIndexLookup(NodeState root) { + this(root, MountInfoProvider.DEFAULT); + } + + public PropertyIndexLookup(NodeState root, MountInfoProvider mountInfoProvider) { this.root = root; + this.mountInfoProvider = mountInfoProvider; } /** @@ -117,9 +126,9 @@ public class PropertyIndexLookup { IndexStoreStrategy getStrategy(NodeState indexMeta) { if (indexMeta.getBoolean(IndexConstants.UNIQUE_PROPERTY_NAME)) { - return UNIQUE; + return new MultiplexingIndexStoreStrategy(UNIQUE, mountInfoProvider); } - return MIRROR; + return new MultiplexingIndexStoreStrategy(MIRROR, mountInfoProvider); } public double getCost(Filter filter, String propertyName, PropertyValue value) { diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndexPlan.java oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndexPlan.java index d15c273..9dbee36 100644 --- oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndexPlan.java +++ oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndexPlan.java @@ -33,8 +33,10 @@ import org.apache.jackrabbit.oak.commons.PathUtils; import org.apache.jackrabbit.oak.plugins.index.PathFilter; import org.apache.jackrabbit.oak.plugins.index.property.strategy.ContentMirrorStoreStrategy; import org.apache.jackrabbit.oak.plugins.index.property.strategy.IndexStoreStrategy; +import org.apache.jackrabbit.oak.plugins.index.property.strategy.MultiplexingIndexStoreStrategy; import org.apache.jackrabbit.oak.plugins.index.property.strategy.UniqueEntryStoreStrategy; import org.apache.jackrabbit.oak.query.QueryEngineSettings; +import org.apache.jackrabbit.oak.spi.mount.MountInfoProvider; import org.apache.jackrabbit.oak.spi.query.Cursor; import org.apache.jackrabbit.oak.spi.query.Cursors; import org.apache.jackrabbit.oak.spi.query.Filter; @@ -57,11 +59,11 @@ public class PropertyIndexPlan { static final int MAX_COST = 100; /** Index storage strategy */ - private static final IndexStoreStrategy MIRROR = + private static final ContentMirrorStoreStrategy MIRROR = new ContentMirrorStoreStrategy(); /** Index storage strategy */ - private static final IndexStoreStrategy UNIQUE = + private static final UniqueEntryStoreStrategy UNIQUE = new UniqueEntryStoreStrategy(); private final NodeState definition; @@ -86,16 +88,22 @@ public class PropertyIndexPlan { private final PathFilter pathFilter; - PropertyIndexPlan(String name, NodeState root, NodeState definition, Filter filter) { + PropertyIndexPlan(String name, NodeState root, NodeState definition, + Filter filter){ + this(name, root, definition, filter, MountInfoProvider.DEFAULT); + } + + PropertyIndexPlan(String name, NodeState root, NodeState definition, + Filter filter, MountInfoProvider mountInfoProvider) { this.name = name; this.definition = definition; this.properties = newHashSet(definition.getNames(PROPERTY_NAMES)); pathFilter = PathFilter.from(definition.builder()); if (definition.getBoolean(UNIQUE_PROPERTY_NAME)) { - this.strategy = UNIQUE; + this.strategy = new MultiplexingIndexStoreStrategy(UNIQUE, mountInfoProvider); } else { - this.strategy = MIRROR; + this.strategy = new MultiplexingIndexStoreStrategy(MIRROR, mountInfoProvider); } this.filter = filter; diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndexProvider.java oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndexProvider.java index 88675ed..72d33d4 100644 --- oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndexProvider.java +++ oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndexProvider.java @@ -21,7 +21,9 @@ import java.util.List; import javax.annotation.Nonnull; import org.apache.felix.scr.annotations.Component; +import org.apache.felix.scr.annotations.Reference; import org.apache.felix.scr.annotations.Service; +import org.apache.jackrabbit.oak.spi.mount.MountInfoProvider; import org.apache.jackrabbit.oak.spi.query.QueryIndex; import org.apache.jackrabbit.oak.spi.query.QueryIndexProvider; import org.apache.jackrabbit.oak.spi.state.NodeState; @@ -40,8 +42,16 @@ import com.google.common.collect.ImmutableList; @Service(QueryIndexProvider.class) public class PropertyIndexProvider implements QueryIndexProvider { + @Reference + private MountInfoProvider mountInfoProvider = MountInfoProvider.DEFAULT; + @Override @Nonnull public List getQueryIndexes(NodeState state) { - return ImmutableList.of(new PropertyIndex()); + return ImmutableList.of(new PropertyIndex(mountInfoProvider)); + } + + public PropertyIndexProvider with(MountInfoProvider mountInfoProvider) { + this.mountInfoProvider = mountInfoProvider; + return this; } } diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/strategy/ConfigurableStorageStrategy.java oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/strategy/ConfigurableStorageStrategy.java new file mode 100644 index 0000000..ac481f9 --- /dev/null +++ oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/strategy/ConfigurableStorageStrategy.java @@ -0,0 +1,35 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.jackrabbit.oak.plugins.index.property.strategy; + +import java.util.Set; + +import org.apache.jackrabbit.oak.spi.query.Filter; +import org.apache.jackrabbit.oak.spi.state.NodeState; + +interface ConfigurableStorageStrategy extends IndexStoreStrategy{ + + Iterable query(Filter filter, String indexName, + NodeState indexMeta, String indexStorageNodeName, + Iterable values); + + long count(Filter filter, NodeState root, NodeState indexMeta, final String indexStorageNodeName, + Set values, int max); +} diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/strategy/ContentMirrorStoreStrategy.java oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/strategy/ContentMirrorStoreStrategy.java index 10c0162..ee55e5f 100644 --- oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/strategy/ContentMirrorStoreStrategy.java +++ oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/strategy/ContentMirrorStoreStrategy.java @@ -71,7 +71,7 @@ import com.google.common.collect.Sets; * * */ -public class ContentMirrorStoreStrategy implements IndexStoreStrategy { +public class ContentMirrorStoreStrategy implements IndexStoreStrategy, ConfigurableStorageStrategy { static final Logger LOG = LoggerFactory.getLogger(ContentMirrorStoreStrategy.class); @@ -130,6 +130,7 @@ public class ContentMirrorStoreStrategy implements IndexStoreStrategy { builder.setProperty("match", true); } + @Override public Iterable query(final Filter filter, final String indexName, final NodeState indexMeta, final String indexStorageNodeName, final Iterable values) { @@ -183,6 +184,7 @@ public class ContentMirrorStoreStrategy implements IndexStoreStrategy { return count(null, root, indexMeta, indexStorageNodeName, values, max); } + @Override public long count(Filter filter, NodeState root, NodeState indexMeta, final String indexStorageNodeName, Set values, int max) { NodeState index = indexMeta.getChildNode(indexStorageNodeName); diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/strategy/MultiplexingIndexStoreStrategy.java oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/strategy/MultiplexingIndexStoreStrategy.java new file mode 100644 index 0000000..e67aae2 --- /dev/null +++ oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/strategy/MultiplexingIndexStoreStrategy.java @@ -0,0 +1,149 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.jackrabbit.oak.plugins.index.property.strategy; + +import java.util.List; +import java.util.Set; + +import com.google.common.collect.Iterables; +import com.google.common.collect.Lists; +import org.apache.jackrabbit.oak.spi.mount.Mount; +import org.apache.jackrabbit.oak.spi.mount.MountInfoProvider; +import org.apache.jackrabbit.oak.spi.query.Filter; +import org.apache.jackrabbit.oak.spi.state.ChildNodeEntry; +import org.apache.jackrabbit.oak.spi.state.NodeBuilder; +import org.apache.jackrabbit.oak.spi.state.NodeState; +import org.apache.jackrabbit.oak.spi.state.NodeStateUtils; + +import static org.apache.jackrabbit.oak.plugins.index.IndexConstants.INDEX_CONTENT_NODE_NAME; + +public class MultiplexingIndexStoreStrategy implements IndexStoreStrategy { + private final ConfigurableStorageStrategy strategy; + private final MountInfoProvider mountInfoProvider; + private final String indexNodeSuffix; + private final String defaultNodeName; + + public MultiplexingIndexStoreStrategy(ConfigurableStorageStrategy strategy, + MountInfoProvider mountInfoProvider){ + this(strategy, mountInfoProvider, INDEX_CONTENT_NODE_NAME); + } + + public MultiplexingIndexStoreStrategy(ConfigurableStorageStrategy strategy, + MountInfoProvider mountInfoProvider, + String defaultNodeName) { + this.strategy = strategy; + this.mountInfoProvider = mountInfoProvider; + this.defaultNodeName = defaultNodeName; + this.indexNodeSuffix = "-" + stripStartingColon(defaultNodeName); + } + + @Override + public void update(NodeBuilder index, String path, String indexName, NodeBuilder indexMeta, + Set beforeKeys, Set afterKeys) { + strategy.update(index, path, indexName, indexMeta, beforeKeys, afterKeys); + } + + @Override + public boolean exists(NodeBuilder index, String key) { + return strategy.exists(index, key); + } + + public boolean existsInAnyStore(NodeBuilder indexMeta, String key) { + for(String name : indexMeta.getChildNodeNames()){ + if (isIndexStorageNode(name)){ + if (strategy.exists(indexMeta.getChildNode(name), key)){ + return true; + } + } + } + return false; + } + + @Override + public Iterable query(Filter filter, String indexName, NodeState indexMeta, + Iterable values) { + //TODO We try to avoid the cost unnecessary checking for child node + //Another option would be to have some config on index indicating that it is enabled + //for multiplexing + if (noMounts()){ + return strategy.query(filter, indexName, indexMeta, values); + } + + List> iterables = Lists.newArrayList(); + //TODO Currently we just look for child nodes of type index node. Other way would be to + //check of existing mount names and then use that to check if child node with given mount + //name exist + for(ChildNodeEntry cne : indexMeta.getChildNodeEntries()){ + String name = cne.getName(); + if (isIndexStorageNode(name)){ + iterables.add(strategy.query(filter, indexName, indexMeta, name, values)); + } + } + return Iterables.concat(iterables); + } + + @Override + public long count(NodeState root, NodeState indexMeta, Set values, int max) { + return count(null, root, indexMeta, values, max); + } + + @Override + public long count(Filter filter, NodeState root, NodeState indexMeta, Set values, int max) { + if (noMounts()) { + return strategy.count(filter, root, indexMeta, values, max); + } + + long count = 0; + for (ChildNodeEntry cne : indexMeta.getChildNodeEntries()) { + String name = cne.getName(); + if (isIndexStorageNode(name)) { + count += strategy.count(filter, root, indexMeta, name, values, max); + } + } + return count; + } + + public String getIndexNodeName(String path){ + Mount mount = mountInfoProvider.getMountByPath(path); + return getNodeForMount(mount); + } + + public String getNodeForMount(Mount mount){ + if (mount.isDefault()) { + return defaultNodeName; + } + return ":" + mount.getPathFragmentName() + indexNodeSuffix; + } + + private boolean noMounts() { + return !mountInfoProvider.hasNonDefaultMounts(); + } + + private boolean isIndexStorageNode(String name) { + return NodeStateUtils.isHidden(name) && (name.equals(defaultNodeName) || name.endsWith(indexNodeSuffix)); + } + + private static String stripStartingColon(String name){ + if (name.startsWith(":")){ + return name.substring(1); + } + return name; + } +} diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/strategy/UniqueEntryStoreStrategy.java oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/strategy/UniqueEntryStoreStrategy.java index 0e011d1..1477054 100644 --- oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/strategy/UniqueEntryStoreStrategy.java +++ oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/property/strategy/UniqueEntryStoreStrategy.java @@ -43,7 +43,7 @@ import org.slf4j.LoggerFactory; * For example for a node that is under {@code /test/node}, the index * structure will be {@code /oak:index/index/@key}: */ -public class UniqueEntryStoreStrategy implements IndexStoreStrategy { +public class UniqueEntryStoreStrategy implements IndexStoreStrategy, ConfigurableStorageStrategy { static final Logger LOG = LoggerFactory.getLogger(UniqueEntryStoreStrategy.class); @@ -108,7 +108,14 @@ public class UniqueEntryStoreStrategy implements IndexStoreStrategy { @Override public Iterable query(final Filter filter, final String indexName, final NodeState indexMeta, final Iterable values) { - final NodeState index = indexMeta.getChildNode(INDEX_CONTENT_NODE_NAME); + return query(filter, indexName, indexMeta, INDEX_CONTENT_NODE_NAME, values); + } + + @Override + public Iterable query(final Filter filter, final String indexName, + final NodeState indexMeta, final String indexStorageNodeName, + final Iterable values){ + final NodeState index = indexMeta.getChildNode(indexStorageNodeName); return new Iterable() { @Override public Iterator iterator() { @@ -157,7 +164,13 @@ public class UniqueEntryStoreStrategy implements IndexStoreStrategy { @Override public long count(NodeState root, NodeState indexMeta, Set values, int max) { - NodeState index = indexMeta.getChildNode(INDEX_CONTENT_NODE_NAME); + return count(null, root, indexMeta, INDEX_CONTENT_NODE_NAME, values, max); + } + + @Override + public long count(Filter filter, NodeState root, NodeState indexMeta, final String indexStorageNodeName, + Set values, int max){ + NodeState index = indexMeta.getChildNode(indexStorageNodeName); long count = 0; if (values == null) { PropertyState ec = indexMeta.getProperty(ENTRY_COUNT_PROPERTY_NAME); @@ -191,7 +204,7 @@ public class UniqueEntryStoreStrategy implements IndexStoreStrategy { @Override public long count(final Filter filter, NodeState root, NodeState indexMeta, Set values, int max) { - return count(root, indexMeta, values, max); + return count(filter, root, indexMeta, INDEX_CONTENT_NODE_NAME, values, max); } } diff --git oak-core/src/test/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndexTest.java oak-core/src/test/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndexTest.java index 3967245..7bcc78b 100644 --- oak-core/src/test/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndexTest.java +++ oak-core/src/test/java/org/apache/jackrabbit/oak/plugins/index/property/PropertyIndexTest.java @@ -30,6 +30,7 @@ import static org.apache.jackrabbit.oak.plugins.index.counter.NodeCounterEditor. 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.spi.state.NodeStateUtils.getNode; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; @@ -42,7 +43,9 @@ import org.apache.jackrabbit.oak.api.CommitFailedException; import org.apache.jackrabbit.oak.api.Type; import org.apache.jackrabbit.oak.plugins.index.IndexUpdateProvider; import org.apache.jackrabbit.oak.plugins.index.property.strategy.ContentMirrorStoreStrategy; +import org.apache.jackrabbit.oak.plugins.index.property.strategy.MultiplexingIndexStoreStrategy; import org.apache.jackrabbit.oak.plugins.memory.EmptyNodeState; +import org.apache.jackrabbit.oak.plugins.multiplex.SimpleMountInfoProvider; import org.apache.jackrabbit.oak.query.NodeStateNodeTypeInfoProvider; import org.apache.jackrabbit.oak.query.QueryEngineSettings; import org.apache.jackrabbit.oak.query.ast.NodeTypeInfo; @@ -53,6 +56,8 @@ import org.apache.jackrabbit.oak.query.index.FilterImpl; import org.apache.jackrabbit.oak.query.index.TraversingIndex; import org.apache.jackrabbit.oak.spi.commit.CommitInfo; import org.apache.jackrabbit.oak.spi.commit.EditorHook; +import org.apache.jackrabbit.oak.spi.mount.Mount; +import org.apache.jackrabbit.oak.spi.mount.MountInfoProvider; import org.apache.jackrabbit.oak.spi.query.Filter; import org.apache.jackrabbit.oak.spi.query.PropertyValues; import org.apache.jackrabbit.oak.spi.state.NodeBuilder; @@ -399,7 +404,7 @@ public class PropertyIndexTest { private static FilterImpl createFilter(NodeState root, String nodeTypeName) { NodeTypeInfoProvider nodeTypes = new NodeStateNodeTypeInfoProvider(root); - NodeTypeInfo type = nodeTypes.getNodeTypeInfo(nodeTypeName); + NodeTypeInfo type = nodeTypes.getNodeTypeInfo(nodeTypeName); SelectorImpl selector = new SelectorImpl(type, nodeTypeName); return new FilterImpl(selector, "SELECT * FROM [" + nodeTypeName + "]", new QueryEngineSettings()); } @@ -746,6 +751,99 @@ public class PropertyIndexTest { assertEquals("/oak:index/foo", idxDefn.getString(INDEX_PATH)); } + @Test + public void singleMount() throws Exception{ + NodeState root = INITIAL_CONTENT; + + // Add index definition + NodeBuilder builder = root.builder(); + NodeBuilder index = createIndexDefinition(builder.child(INDEX_DEFINITIONS_NAME), "foo", + true, false, ImmutableSet.of("foo"), null); + index.setProperty("entryCount", -1); + NodeState before = builder.getNodeState(); + + // Add some content and process it through the property index hook + builder.child("a").setProperty("foo", "abc"); + builder.child("b").child("x").setProperty("foo", "abc"); + builder.child("a").child("x").setProperty("foo", "abc"); + builder.child("m").child("n").setProperty("foo", "abc"); + builder.child("m").child("n").child("o").setProperty("foo", "abc"); + builder.child("m").setProperty("foo", "abc"); + + NodeState after = builder.getNodeState(); + + MountInfoProvider mip = SimpleMountInfoProvider.newBuilder() + .mount("foo", "/a", "/m/n") + .build(); + + MultiplexingIndexStoreStrategy store = + new MultiplexingIndexStoreStrategy(new ContentMirrorStoreStrategy(), mip); + + Mount fooMount = mip.getMountByName("foo"); + + EditorHook hook = new EditorHook( + new IndexUpdateProvider(new PropertyIndexEditorProvider().with(mip))); + + NodeState indexed = hook.processCommit(before, after, CommitInfo.EMPTY); + + FilterImpl f = createFilter(indexed, NT_BASE); + + // Query the index + PropertyIndexLookup lookup = new PropertyIndexLookup(indexed,mip); + assertEquals(ImmutableSet.of("a", "b/x", "a/x", "m", "m/n", "m/n/o"), find(lookup, "foo", "abc", f)); + assertEquals(ImmutableSet.of(), find(lookup, "foo", "ghi", f)); + + assertTrue(getNode(indexed, "/oak:index/foo/:index").exists()); + + //Separate node for mount + assertTrue(getNode(indexed, "/oak:index/foo/"+ store.getNodeForMount(fooMount)).exists()); + + //Index entries for paths in foo mount should go to :oak:foo-index + assertTrue(getNode(indexed, pathInIndex(store, fooMount, "/oak:index/foo", "/a", "abc")).exists()); + assertTrue(getNode(indexed, pathInIndex(store, fooMount, "/oak:index/foo", "/a/x", "abc")).exists()); + assertTrue(getNode(indexed, pathInIndex(store, fooMount, "/oak:index/foo", "/m/n", "abc")).exists()); + assertTrue(getNode(indexed, pathInIndex(store, fooMount, "/oak:index/foo", "/m/n/o", "abc")).exists()); + + //All other index entries should go to :index + assertTrue(getNode(indexed, pathInIndex(store, Mount.DEFAULT, "/oak:index/foo", "/b", "abc")).exists()); + assertTrue(getNode(indexed, pathInIndex(store, Mount.DEFAULT, "/oak:index/foo", "/b/x", "abc")).exists()); + assertTrue(getNode(indexed, pathInIndex(store, Mount.DEFAULT, "/oak:index/foo", "/m", "abc")).exists()); + + //System.out.println(NodeStateUtils.toString(getNode(indexed, "/oak:index/foo"))); + + } + + @Test(expected = CommitFailedException.class) + public void mountAndUniqueIndexes() throws Exception{ + NodeState root = INITIAL_CONTENT; + + // Add index definition + NodeBuilder builder = root.builder(); + NodeBuilder index = createIndexDefinition(builder.child(INDEX_DEFINITIONS_NAME), "foo", + true, true, ImmutableSet.of("foo"), null); + index.setProperty("entryCount", -1); + NodeState before = builder.getNodeState(); + + MountInfoProvider mip = SimpleMountInfoProvider.newBuilder() + .mount("foo", "/a") + .build(); + + builder.child("a").setProperty("foo", "abc"); + builder.child("b").setProperty("foo", Arrays.asList("abc", "def"), + Type.STRINGS); + NodeState after = builder.getNodeState(); + + EditorHook hook = new EditorHook( + new IndexUpdateProvider(new PropertyIndexEditorProvider().with(mip))); + // should throw + hook.processCommit(before, after, CommitInfo.EMPTY); + } + + private static String pathInIndex(MultiplexingIndexStoreStrategy store, Mount mount, + String indexPath, String indexedPath, String indexedValue){ + return indexPath + "/" + store.getNodeForMount(mount) + "/" + indexedValue + indexedPath; + } + private int getResultSize(NodeState indexed, String name, String value){ FilterImpl f = createFilter(indexed, NT_BASE); diff --git oak-core/src/test/java/org/apache/jackrabbit/oak/plugins/index/property/strategy/MultiplexingIndexStoreStrategyTest.java oak-core/src/test/java/org/apache/jackrabbit/oak/plugins/index/property/strategy/MultiplexingIndexStoreStrategyTest.java new file mode 100644 index 0000000..9b1d349 --- /dev/null +++ oak-core/src/test/java/org/apache/jackrabbit/oak/plugins/index/property/strategy/MultiplexingIndexStoreStrategyTest.java @@ -0,0 +1,231 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.jackrabbit.oak.plugins.index.property.strategy; + +import java.util.HashSet; +import java.util.Set; + +import org.apache.jackrabbit.oak.api.Type; +import org.apache.jackrabbit.oak.plugins.multiplex.SimpleMountInfoProvider; +import org.apache.jackrabbit.oak.spi.mount.Mount; +import org.apache.jackrabbit.oak.spi.mount.MountInfoProvider; +import org.apache.jackrabbit.oak.spi.query.Filter; +import org.apache.jackrabbit.oak.spi.state.NodeBuilder; +import org.apache.jackrabbit.oak.spi.state.NodeState; +import org.junit.Test; + +import static com.google.common.collect.ImmutableSet.copyOf; +import static com.google.common.collect.ImmutableSet.of; +import static java.util.Arrays.asList; +import static org.apache.jackrabbit.oak.plugins.index.IndexConstants.INDEX_CONTENT_NODE_NAME; +import static org.apache.jackrabbit.oak.plugins.memory.EmptyNodeState.EMPTY_NODE; +import static org.apache.jackrabbit.oak.plugins.memory.PropertyStates.createProperty; +import static org.junit.Assert.assertEquals; + +public class MultiplexingIndexStoreStrategyTest { + + @Test + public void defaultSetup() throws Exception{ + MultiplexingIndexStoreStrategy store = new MultiplexingIndexStoreStrategy(new ContentMirrorStoreStrategy(), + MountInfoProvider.DEFAULT); + + assertEquals(INDEX_CONTENT_NODE_NAME, store.getIndexNodeName("/foo")); + assertEquals(INDEX_CONTENT_NODE_NAME, store.getNodeForMount(Mount.DEFAULT)); + } + + @Test + public void customNodeName() throws Exception{ + MountInfoProvider mip = SimpleMountInfoProvider.newBuilder() + .mount("foo", "/a", "/b") + .build(); + + Mount m = mip.getMountByName("foo"); + MultiplexingIndexStoreStrategy store = new MultiplexingIndexStoreStrategy(new ContentMirrorStoreStrategy(), + mip); + + assertEquals(":index", store.getIndexNodeName("/foo")); + assertEquals(":index", store.getNodeForMount(Mount.DEFAULT)); + + assertEquals(":" + m.getPathFragmentName() + "-index", store.getIndexNodeName("/a")); + assertEquals(":" + m.getPathFragmentName() + "-index", store.getNodeForMount(m)); + } + + @Test + public void nodeForMount() throws Exception{ + + } + + @Test + public void countDefault() throws Exception{ + ConfigurableStorageStrategy s = new TestStrategy() { + @Override + public long count(Filter filter, NodeState root, NodeState indexMeta, + String indexStorageNodeName, Set values, int max) { + throw new AssertionError(); + } + + @Override + public long count(Filter filter, NodeState root, NodeState indexMeta, + Set values, int max) { + return 42; + } + }; + + MultiplexingIndexStoreStrategy store = new MultiplexingIndexStoreStrategy(s, MountInfoProvider.DEFAULT); + assertEquals(42, store.count(null, EMPTY_NODE, EMPTY_NODE, null, -1)); + } + + @Test + public void countWithMount() throws Exception{ + final Set nodeNames = new HashSet(); + ConfigurableStorageStrategy s = new TestStrategy() { + @Override + public long count(Filter filter, NodeState root, NodeState indexMeta, + String indexStorageNodeName, Set values, int max) { + NodeState ns = indexMeta.getChildNode(indexStorageNodeName); + nodeNames.add(ns.getString("name")); + return ns.getLong("count"); + } + + @Override + public long count(Filter filter, NodeState root, NodeState indexMeta, + Set values, int max) { + throw new AssertionError(); + } + }; + + MountInfoProvider mip = SimpleMountInfoProvider.newBuilder() + .mount("foo", "/a", "/b") + .build(); + + NodeBuilder builder = EMPTY_NODE.builder(); + builder.child(":a-index").setProperty("name",":a-index").setProperty("count", 5); + builder.child(":b-index").setProperty("name",":b-index").setProperty("count", 7); + builder.child("foo").setProperty("name","foo").setProperty("count", 42); + + MultiplexingIndexStoreStrategy store = new MultiplexingIndexStoreStrategy(s, mip); + assertEquals(12, store.count(null, EMPTY_NODE, builder.getNodeState(), null, -1)); + assertEquals(of(":a-index",":b-index"), nodeNames); + } + + @Test + public void queryDefault() throws Exception{ + ConfigurableStorageStrategy s = new TestStrategy() { + @Override + public Iterable query(Filter filter, String indexName, NodeState indexMeta, Iterable values) { + return asList("/a", "/b"); + } + + @Override + public Iterable query(Filter filter, String indexName, NodeState indexMeta, + String indexStorageNodeName, Iterable values) { + throw new AssertionError(); + } + }; + + MultiplexingIndexStoreStrategy store = new MultiplexingIndexStoreStrategy(s, MountInfoProvider.DEFAULT); + assertEquals(of("/a", "/b"), copyOf(store.query(null, "foo", EMPTY_NODE, null))); + } + + + @Test + public void queryMount() throws Exception{ + final Set nodeNames = new HashSet(); + ConfigurableStorageStrategy s = new TestStrategy() { + @Override + public Iterable query(Filter filter, String indexName, NodeState indexMeta, Iterable values) { + throw new AssertionError(); + } + + @Override + public Iterable query(Filter filter, String indexName, NodeState indexMeta, + String indexStorageNodeName, Iterable values) { + NodeState ns = indexMeta.getChildNode(indexStorageNodeName); + nodeNames.add(ns.getString("name")); + return ns.getProperty("paths").getValue(Type.STRINGS); + + } + }; + + MountInfoProvider mip = SimpleMountInfoProvider.newBuilder() + .mount("foo", "/a", "/b") + .build(); + + NodeBuilder builder = EMPTY_NODE.builder(); + builder.child(":a-index") + .setProperty("name",":a-index") + .setProperty(createProperty("paths", of("/a", "/b"), Type.STRINGS)); + builder.child(":b-index") + .setProperty("name",":b-index") + .setProperty(createProperty("paths", of("/c", "/d"), Type.STRINGS)); + builder.child("foo") + .setProperty("name","foo") + .setProperty(createProperty("paths", of("/e", "/f"), Type.STRINGS)); + + + MultiplexingIndexStoreStrategy store = new MultiplexingIndexStoreStrategy(s, mip); + assertEquals(of("/a", "/b", "/c", "/d"), copyOf(store.query(null, "foo", builder.getNodeState(), null))); + assertEquals(of(":a-index",":b-index"), nodeNames); + } + + + private static class TestStrategy implements ConfigurableStorageStrategy { + + @Override + public Iterable query(Filter filter, String indexName, NodeState indexMeta, + String indexStorageNodeName, Iterable values) { + return null; + } + + @Override + public long count(Filter filter, NodeState root, NodeState indexMeta, + String indexStorageNodeName, Set values, int max) { + return 0; + } + + @Override + public void update(NodeBuilder index, String path, String indexName, + NodeBuilder indexMeta, Set beforeKeys, Set afterKeys) { + + } + + @Override + public boolean exists(NodeBuilder index, String key) { + return false; + } + + @Override + public Iterable query(Filter filter, String indexName, + NodeState indexMeta, Iterable values) { + return null; + } + + @Override + public long count(NodeState root, NodeState indexMeta, Set values, int max) { + return 0; + } + + @Override + public long count(Filter filter, NodeState root, NodeState indexMeta, Set values, int max) { + return 0; + } + } + +} \ No newline at end of file diff --git oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/Jcr.java oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/Jcr.java index 47762c6..092831b 100644 --- oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/Jcr.java +++ oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/Jcr.java @@ -56,6 +56,7 @@ import org.apache.jackrabbit.oak.spi.commit.EditorProvider; import org.apache.jackrabbit.oak.spi.commit.Observer; import org.apache.jackrabbit.oak.spi.commit.PartialConflictHandler; import org.apache.jackrabbit.oak.spi.lifecycle.RepositoryInitializer; +import org.apache.jackrabbit.oak.spi.mount.MountInfoProvider; import org.apache.jackrabbit.oak.spi.query.QueryIndexProvider; import org.apache.jackrabbit.oak.spi.security.SecurityProvider; import org.apache.jackrabbit.oak.spi.state.Clusterable; @@ -102,7 +103,8 @@ public class Jcr { private ContentRepository contentRepository; private Repository repository; - + private MountInfoProvider mountInfoProvider = MountInfoProvider.DEFAULT; + private Clusterable clusterable; public Jcr(Oak oak, boolean initialize) { @@ -124,10 +126,10 @@ public class Jcr { with(new ReferenceEditorProvider()); with(new ReferenceIndexProvider()); - with(new PropertyIndexEditorProvider()); + with(new PropertyIndexEditorProvider().with(mountInfoProvider)); with(new NodeCounterEditorProvider()); - with(new PropertyIndexProvider()); + with(new PropertyIndexProvider().with(mountInfoProvider)); with(new NodeTypeIndexProvider()); with(new OrderedPropertyIndexEditorProvider()); @@ -152,7 +154,7 @@ public class Jcr { this.clusterable = checkNotNull(c); return this; } - + @Nonnull public final Jcr with(@Nonnull RepositoryInitializer initializer) { ensureRepositoryIsNotCreated(); @@ -165,7 +167,7 @@ public class Jcr { oak.withAtomicCounter(); return this; } - + private void ensureRepositoryIsNotCreated() { checkState(repository == null && contentRepository == null, "Repository was already created"); @@ -290,6 +292,13 @@ public class Jcr { return this; } + @Nonnull + public Jcr with(@Nonnull MountInfoProvider mountInfoProvider) { + ensureRepositoryIsNotCreated(); + this.mountInfoProvider = checkNotNull(mountInfoProvider); + return this; + } + private void setUpOak() { // whiteboard if (whiteboard != null) { @@ -359,7 +368,7 @@ public class Jcr { if (defaultWorkspaceName != null) { oak.with(defaultWorkspaceName); } - + if (clusterable != null) { oak.with(clusterable); }