@Override public Iterable<String> query(Filter filter, String indexName, NodeState indexMeta, Iterable<String> values) { return strategy.query(filter, indexName, indexMeta, values); }
@Override public Iterable<String> query(Filter filter, String indexName, NodeState indexMeta, Iterable<String> values) { return strategy.query(filter, indexName, indexMeta, values); }
@Override public Iterable<String> query(Filter filter, String indexName, NodeState indexMeta, Iterable<String> values) { return strategy.query(filter, indexName, indexMeta, values); }
private String getPathByUuid(String uuid) { if (newReferencableNodes.containsKey(uuid)) { return newReferencableNodes.get(uuid); } for (IndexStoreStrategy store : uuidStores) { for (String path : store.query(Filter.EMPTY_FILTER, null, uuidDefinition, of(uuid))) { return path; } } return null; }
/** * From a set of keys, get the first that has multiple entries, if any. * * @param keys the keys * @param indexMeta the index configuration * @return the first duplicate, or null if none was found */ private String getFirstDuplicate(Set<String> keys, NodeState indexMeta) { for (String key : keys) { long count = 0; for (IndexStoreStrategy s : getStrategies(true)) { count += s.count(root, indexMeta, singleton(key), 2); if (count > 1) { Iterator<String> it = s.query(null, null, indexMeta, singleton(key)).iterator(); if (it.hasNext()) { return key + ": " + it.next(); } return key; } } } return null; }
/** * From a set of keys, get the first that has multiple entries, if any. * * @param keys the keys * @param indexMeta the index configuration * @return the first duplicate, or null if none was found */ private String getFirstDuplicate(Set<String> keys, NodeState indexMeta) { for (String key : keys) { long count = 0; for (IndexStoreStrategy s : getStrategies(true)) { count += s.count(root, indexMeta, singleton(key), 2); if (count > 1) { Iterator<String> it = s.query(null, null, indexMeta, singleton(key)).iterator(); if (it.hasNext()) { return key + ": " + it.next(); } return key; } } } return null; }
Cursor execute() { QueryLimits settings = filter.getQueryLimits(); List<Iterable<String>> iterables = Lists.newArrayList(); for (IndexStoreStrategy s : strategies) { iterables.add(s.query(filter, name, definition, values)); } Cursor cursor = Cursors.newPathCursor(Iterables.concat(iterables), settings); if (depth > 1) { cursor = Cursors.newAncestorCursor(cursor, depth - 1, settings); } return cursor; }
public Iterable<String> query(Filter filter, String propertyName, PropertyValue value) { NodeState indexMeta = getIndexNode(root, propertyName, filter); if (indexMeta == null) { throw new IllegalArgumentException("No index for " + propertyName); } List<Iterable<String>> iterables = Lists.newArrayList(); ValuePattern pattern = new ValuePattern(indexMeta); for (IndexStoreStrategy s : getStrategies(indexMeta)) { iterables.add(s.query(filter, propertyName, indexMeta, encode(value, pattern))); } return Iterables.concat(iterables); }
public Iterable<String> query(Filter filter, String propertyName, PropertyValue value) { NodeState indexMeta = getIndexNode(root, propertyName, filter); if (indexMeta == null) { throw new IllegalArgumentException("No index for " + propertyName); } List<Iterable<String>> iterables = Lists.newArrayList(); ValuePattern pattern = new ValuePattern(indexMeta); for (IndexStoreStrategy s : getStrategies(indexMeta)) { iterables.add(s.query(filter, propertyName, indexMeta, encode(value, pattern))); } return Iterables.concat(iterables); }
/** * From a set of keys, get the first that has multiple entries, if any. * * @param keys the keys * @param indexMeta the index configuration * @return the first duplicate, or null if none was found */ private String getFirstDuplicate(Set<String> keys, NodeState indexMeta) { for (String key : keys) { long count = 0; for (IndexStoreStrategy s : getStrategies(true)) { count += s.count(root, indexMeta, singleton(key), 2); if (count > 1) { Iterator<String> it = s.query(null, null, indexMeta, singleton(key)).iterator(); if (it.hasNext()) { return key + ": " + it.next(); } return key; } } } return null; }
Cursor execute() { if (deprecated) { LOG.warn("This index is deprecated: {}; it is used for query {}. " + "Please change the query or the index definitions.", name, filter); } QueryLimits settings = filter.getQueryLimits(); List<Iterable<String>> iterables = Lists.newArrayList(); for (IndexStoreStrategy s : strategies) { iterables.add(s.query(filter, name, definition, values)); } Cursor cursor = Cursors.newPathCursor(Iterables.concat(iterables), settings); if (depth > 1) { cursor = Cursors.newAncestorCursor(cursor, depth - 1, settings); } return cursor; }
Cursor execute() { if (deprecated) { LOG.warn("This index is deprecated: {}; it is used for query {}. " + "Please change the query or the index definitions.", name, filter); } QueryLimits settings = filter.getQueryLimits(); List<Iterable<String>> iterables = Lists.newArrayList(); for (IndexStoreStrategy s : strategies) { iterables.add(s.query(filter, name, definition, values)); } Cursor cursor = Cursors.newPathCursor(Iterables.concat(iterables), settings); if (depth > 1) { cursor = Cursors.newAncestorCursor(cursor, depth - 1, settings); } return cursor; }
public Iterable<String> query(Filter filter, String propertyName, PropertyValue value) { NodeState indexMeta = getIndexNode(root, propertyName, filter); if (indexMeta == null) { throw new IllegalArgumentException("No index for " + propertyName); } List<Iterable<String>> iterables = Lists.newArrayList(); ValuePattern pattern = new ValuePattern(indexMeta); for (IndexStoreStrategy s : getStrategies(indexMeta)) { iterables.add(s.query(filter, propertyName, indexMeta, encode(value, pattern))); } return Iterables.concat(iterables); }
private Cursor lookup(NodeState root, String uuid, final String name, String index, Filter filter) { NodeState indexRoot = root.getChildNode(INDEX_DEFINITIONS_NAME) .getChildNode(NAME); if (!indexRoot.exists()) { return newPathCursor(new ArrayList<String>(), filter.getQueryLimits()); } List<Iterable<String>> iterables = Lists.newArrayList(); for (IndexStoreStrategy s : getStrategies(indexRoot, mountInfoProvider, index)) { iterables.add(s.query(filter, index + "(" + uuid + ")", indexRoot, ImmutableSet.of(uuid))); } Iterable<String> paths = Iterables.concat(iterables); if (!"*".equals(name)) { paths = filter(paths, new Predicate<String>() { @Override public boolean apply(String path) { return name.equals(getName(path)); } }); } paths = transform(paths, new Function<String, String>() { @Override public String apply(String path) { return getParentPath(path); } }); return newPathCursor(paths, filter.getQueryLimits()); }
private Cursor lookup(NodeState root, String uuid, final String name, String index, Filter filter) { NodeState indexRoot = root.getChildNode(INDEX_DEFINITIONS_NAME) .getChildNode(NAME); if (!indexRoot.exists()) { return newPathCursor(new ArrayList<String>(), filter.getQueryLimits()); } List<Iterable<String>> iterables = Lists.newArrayList(); for (IndexStoreStrategy s : getStrategies(indexRoot, mountInfoProvider, index)) { iterables.add(s.query(filter, index + "(" + uuid + ")", indexRoot, ImmutableSet.of(uuid))); } Iterable<String> paths = Iterables.concat(iterables); if (!"*".equals(name)) { paths = filter(paths, new Predicate<String>() { @Override public boolean apply(String path) { return name.equals(getName(path)); } }); } paths = transform(paths, new Function<String, String>() { @Override public String apply(String path) { return getParentPath(path); } }); return newPathCursor(paths, filter.getQueryLimits()); }
private Cursor lookup(NodeState root, String uuid, final String name, String index, Filter filter) { NodeState indexRoot = root.getChildNode(INDEX_DEFINITIONS_NAME) .getChildNode(NAME); if (!indexRoot.exists()) { return newPathCursor(new ArrayList<String>(), filter.getQueryLimits()); } List<Iterable<String>> iterables = Lists.newArrayList(); for (IndexStoreStrategy s : getStrategies(indexRoot, mountInfoProvider, index)) { iterables.add(s.query(filter, index + "(" + uuid + ")", indexRoot, ImmutableSet.of(uuid))); } Iterable<String> paths = Iterables.concat(iterables); if (!"*".equals(name)) { paths = filter(paths, new Predicate<String>() { @Override public boolean apply(String path) { return name.equals(getName(path)); } }); } paths = transform(paths, new Function<String, String>() { @Override public String apply(String path) { return getParentPath(path); } }); return newPathCursor(paths, filter.getQueryLimits()); }
@Test public void nonRootStorage() throws Exception{ IndexStoreStrategy store = new ContentMirrorStoreStrategy(INDEX_CONTENT_NODE_NAME, "/content", false); NodeState root = EMPTY_NODE; NodeBuilder builder = root.builder(); Supplier<NodeBuilder> index = () -> builder; for (String path : asList("a", "a/c", "b")) { store.update(index, path, null, null, EMPTY, KEY); } FilterImpl filter = FilterImpl.newTestInstance(); filter.restrictPath("/content", Filter.PathRestriction.ALL_CHILDREN); NodeBuilder indexMeta = EMPTY_NODE.builder(); indexMeta.setChildNode(INDEX_CONTENT_NODE_NAME, builder.getNodeState()); Iterable<String> paths = store.query(filter, null, indexMeta.getNodeState(), KEY); assertThat(copyOf(paths), containsInAnyOrder("a", "a/c", "b")); FilterImpl filter2 = FilterImpl.newTestInstance(); filter2.restrictPath("/content/a", Filter.PathRestriction.ALL_CHILDREN); paths = store.query(filter2, null, indexMeta.getNodeState(), KEY); assertThat(copyOf(paths), containsInAnyOrder("a", "a/c")); store = new ContentMirrorStoreStrategy(INDEX_CONTENT_NODE_NAME, "/content", true); paths = store.query(filter, null, indexMeta.getNodeState(), KEY); assertThat(copyOf(paths), containsInAnyOrder("/content/a", "/content/a/c", "/content/b")); paths = store.query(filter2, null, indexMeta.getNodeState(), KEY); assertThat(copyOf(paths), containsInAnyOrder("/content/a", "/content/a/c")); }