/** * Get the current absolute Oak path (normalized). * * @return the path */ public String currentPath() { return cursor == null ? null : currentRow.getPath(); }
@Override public String getPath() { return pathRow.getPath(); }
/** * Get the current absolute Oak path (normalized). * * @return the path */ public String currentPath() { return cursor == null ? null : currentRow.getPath(); }
/** * Get the current absolute Oak path (normalized). * * @return the path */ public String currentPath() { return cursor == null ? null : currentRow.getPath(); }
@Override public String getPath() { return pathRow.getPath(); }
@Override public String apply(@Nullable IndexRow input) { return input != null ? input.getPath() : null; } });
@Override public String apply(@Nullable IndexRow input) { return input != null ? input.getPath() : null; } });
@Override public String apply(@Nullable IndexRow input) { return input != null ? input.getPath() : null; } });
public String apply(IndexRow input) { return input.getPath(); } }));
@Override public String getPath() { String sub = pathRow.getPath(); if (isVirtualRow()) { return sub; } else if (!"".equals(pathPrefix) && PathUtils.denotesRoot(sub)) { return pathPrefix; } else if (PathUtils.isAbsolute(sub)) { return pathPrefix + sub; } else { return PathUtils.concat(pathPrefix, sub); } }
private void fetchNext() { while (true) { while (!currentCursor.hasNext()) { nextCursor(); if (closed) { return; } } IndexRow c = currentCursor.next(); String p = c.getPath(); if (seen.contains(p)) { continue; } current = c; markSeen(p); return; } }
private void fetchNext() { while (true) { while (!currentCursor.hasNext()) { nextCursor(); if (closed) { return; } } IndexRow c = currentCursor.next(); String p = c.getPath(); if (seen.contains(p)) { continue; } current = c; markSeen(p); return; } }
private static void checkCursor(Cursor cursor, String... matches) { // make sure the index is actually used // and does not traverse assertEquals(Cursors.class.getName() + "$PathCursor", cursor.getClass().getName()); Set<String> expected = Sets.newHashSet(); expected.addAll(Arrays.asList(matches)); Set<String> actual = Sets.newHashSet(); while (cursor.hasNext()) { actual.add(cursor.next().getPath()); } assertEquals(expected, actual); }
@Override public String getPath() { String sub = pathRow.getPath(); if (isVirtualRow()) { return sub; } else if (PathUtils.isAbsolute(sub)) { return plan.getPathPrefix() + sub; } else { return PathUtils.concat(plan.getPathPrefix(), sub); } }
@Override public String getPath() { String sub = pathRow.getPath(); if (isVirtualRow()) { return sub; } else if (PathUtils.isAbsolute(sub)) { return plan.getPathPrefix() + sub; } else { return PathUtils.concat(plan.getPathPrefix(), sub); } }
private static List<String> assertFilter(Filter filter, QueryIndex queryIndex, NodeState indexed, List<String> expected) { Cursor cursor = queryIndex.query(filter, indexed); List<String> paths = newArrayList(); while (cursor.hasNext()) { paths.add(cursor.next().getPath()); } Collections.sort(paths); for (String p : expected) { assertTrue("Expected path " + p + " not found", paths.contains(p)); } assertEquals("Result set size is different \nExpected: " + expected + "\nActual: " + paths, expected.size(), paths.size()); return paths; }
private static List<String> assertFilter(Filter filter, AdvancedQueryIndex queryIndex, NodeState indexed, List<String> expected) { List<IndexPlan> plans = queryIndex.getPlans(filter, null, indexed); Cursor cursor = queryIndex.query(plans.get(0), indexed); List<String> paths = newArrayList(); while (cursor.hasNext()) { paths.add(cursor.next().getPath()); } Collections.sort(paths); for (String p : expected) { assertTrue("Expected path " + p + " not found", paths.contains(p)); } assertEquals("Result set size is different \nExpected: " + expected + "\nActual: " + paths, expected.size(), paths.size()); return paths; }
private static List<String> assertFilter(Filter filter, AdvancedQueryIndex queryIndex, NodeState indexed, List<String> expected, boolean ordered) { if (!ordered) { return assertFilter(filter, queryIndex, indexed, expected); } List<IndexPlan> plans = queryIndex.getPlans(filter, null, indexed); Cursor cursor = queryIndex.query(plans.get(0), indexed); List<String> paths = newArrayList(); while (cursor.hasNext()) { paths.add(cursor.next().getPath()); } for (String p : expected) { assertTrue("Expected path " + p + " not found", paths.contains(p)); } assertEquals("Result set size is different", expected.size(), paths.size()); return paths; }
private void assertQuery(IndexTracker tracker, NodeState indexed, String key, String value){ AdvancedQueryIndex queryIndex = new LucenePropertyIndex(tracker); FilterImpl filter = createFilter(NT_BASE); filter.restrictPath("/", Filter.PathRestriction.EXACT); filter.restrictProperty(key, Operator.EQUAL, PropertyValues.newString(value)); List<IndexPlan> plans = queryIndex.getPlans(filter, null, indexed); Cursor cursor = queryIndex.query(plans.get(0), indexed); assertTrue(cursor.hasNext()); assertEquals("/", cursor.next().getPath()); assertFalse(cursor.hasNext()); }
@Test public void testLucene() throws Exception { NodeBuilder index = builder.child(INDEX_DEFINITIONS_NAME); newLucenePropertyIndexDefinition(index, "lucene", ImmutableSet.of("foo"), null); NodeState before = builder.getNodeState(); builder.setProperty("foo", "bar"); NodeState after = builder.getNodeState(); NodeState indexed = HOOK.processCommit(before, after, CommitInfo.EMPTY); tracker = new IndexTracker(); tracker.update(indexed); AdvancedQueryIndex queryIndex = new LucenePropertyIndex(tracker); FilterImpl filter = createFilter(NT_BASE); filter.restrictPath("/", Filter.PathRestriction.EXACT); filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar")); List<IndexPlan> plans = queryIndex.getPlans(filter, null, builder.getNodeState()); Cursor cursor = queryIndex.query(plans.get(0), indexed); assertTrue(cursor.hasNext()); assertEquals("/", cursor.next().getPath()); assertFalse(cursor.hasNext()); }