You are viewing a plain text version of this content. The canonical link for it is here.
Posted to oak-commits@jackrabbit.apache.org by to...@apache.org on 2018/09/25 12:24:18 UTC
svn commit: r1841926 [7/14] - in /jackrabbit/oak/trunk:
oak-benchmarks/src/main/java/org/apache/jackrabbit/oak/benchmark/
oak-benchmarks/src/main/java/org/apache/jackrabbit/oak/benchmark/util/
oak-benchmarks/src/main/java/org/apache/jackrabbit/oak/scal...
Modified: jackrabbit/oak/trunk/oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/IndexPlannerTest.java
URL: http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/IndexPlannerTest.java?rev=1841926&r1=1841925&r2=1841926&view=diff
==============================================================================
--- jackrabbit/oak/trunk/oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/IndexPlannerTest.java (original)
+++ jackrabbit/oak/trunk/oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/IndexPlannerTest.java Tue Sep 25 12:24:15 2018
@@ -26,17 +26,16 @@ import static org.apache.jackrabbit.oak.
import static org.apache.jackrabbit.oak.api.Type.STRINGS;
import static org.apache.jackrabbit.oak.plugins.index.IndexConstants.DECLARING_NODE_TYPES;
import static org.apache.jackrabbit.oak.plugins.index.IndexConstants.INDEX_DEFINITIONS_NAME;
-import static org.apache.jackrabbit.oak.plugins.index.lucene.IndexStatistics.SYNTHETICALLY_FALLIABLE_FIELD;
-import static org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexConstants.EVALUATE_PATH_RESTRICTION;
-import static org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexConstants.INDEX_DATA_CHILD_NAME;
-import static org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexConstants.INDEX_RULES;
-import static org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexConstants.ORDERED_PROP_NAMES;
-import static org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexConstants.PROP_FUNCTION;
+import static org.apache.jackrabbit.oak.plugins.index.search.FulltextIndexConstants.EVALUATE_PATH_RESTRICTION;
+import static org.apache.jackrabbit.oak.plugins.index.search.FulltextIndexConstants.INDEX_DATA_CHILD_NAME;
+import static org.apache.jackrabbit.oak.plugins.index.search.FulltextIndexConstants.INDEX_RULES;
+import static org.apache.jackrabbit.oak.plugins.index.search.FulltextIndexConstants.ORDERED_PROP_NAMES;
+import static org.apache.jackrabbit.oak.plugins.index.search.FulltextIndexConstants.PROP_FUNCTION;
import static org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexConstants.VERSION;
+import static org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexStatistics.SYNTHETICALLY_FALLIABLE_FIELD;
import static org.apache.jackrabbit.oak.plugins.index.lucene.TestUtil.NT_TEST;
import static org.apache.jackrabbit.oak.plugins.index.lucene.TestUtil.child;
import static org.apache.jackrabbit.oak.plugins.index.lucene.TestUtil.registerTestNodeType;
-import static org.apache.jackrabbit.oak.plugins.index.lucene.util.FunctionIndexProcessor.*;
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;
@@ -61,11 +60,16 @@ import org.apache.jackrabbit.oak.api.Tre
import org.apache.jackrabbit.oak.api.Type;
import org.apache.jackrabbit.oak.commons.PathUtils;
import org.apache.jackrabbit.oak.plugins.index.IndexConstants;
-import org.apache.jackrabbit.oak.plugins.index.lucene.IndexPlanner.PropertyIndexResult;
import org.apache.jackrabbit.oak.plugins.index.lucene.reader.DefaultIndexReader;
import org.apache.jackrabbit.oak.plugins.index.lucene.reader.LuceneIndexReader;
import org.apache.jackrabbit.oak.plugins.index.lucene.reader.LuceneIndexReaderFactory;
import org.apache.jackrabbit.oak.plugins.index.lucene.util.IndexDefinitionBuilder;
+import org.apache.jackrabbit.oak.plugins.index.search.FulltextIndexConstants;
+import org.apache.jackrabbit.oak.plugins.index.search.IndexDefinition;
+import org.apache.jackrabbit.oak.plugins.index.search.spi.query.FulltextIndex;
+import org.apache.jackrabbit.oak.plugins.index.search.spi.query.FulltextIndexPlanner;
+import org.apache.jackrabbit.oak.plugins.index.search.spi.query.FulltextIndexPlanner.PropertyIndexResult;
+import org.apache.jackrabbit.oak.plugins.index.search.util.FunctionIndexProcessor;
import org.apache.jackrabbit.oak.plugins.memory.PropertyValues;
import org.apache.jackrabbit.oak.query.NodeStateNodeTypeInfoProvider;
import org.apache.jackrabbit.oak.query.QueryEngineSettings;
@@ -103,16 +107,16 @@ public class IndexPlannerTest {
@After
public void cleanup(){
- IndexPlanner.setUseActualEntryCount(true);
+ FulltextIndexPlanner.setUseActualEntryCount(true);
}
@Test
public void planForSortField() throws Exception{
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
defn.setProperty(createProperty(ORDERED_PROP_NAMES, of("foo"), STRINGS));
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", createFilter("nt:base"),
- ImmutableList.of(new OrderEntry("foo", Type.LONG, OrderEntry.Order.ASCENDING)));
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"));
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", createFilter("nt:base"),
+ ImmutableList.of(new OrderEntry("foo", Type.LONG, OrderEntry.Order.ASCENDING)));
assertNotNull(planner.getPlan());
assertTrue(pr(planner.getPlan()).isUniquePathsRequired());
}
@@ -120,19 +124,19 @@ public class IndexPlannerTest {
@Test
public void noPlanForSortOnlyByScore() throws Exception{
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", createFilter("nt:file"),
- ImmutableList.of(new OrderEntry("jcr:score", Type.LONG, OrderEntry.Order.ASCENDING)));
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"));
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", createFilter("nt:file"),
+ ImmutableList.of(new OrderEntry("jcr:score", Type.LONG, OrderEntry.Order.ASCENDING)));
assertNull(planner.getPlan());
}
@Test
public void fullTextQueryNonFulltextIndex() throws Exception{
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo"));
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"));
FilterImpl filter = createFilter("nt:base");
filter.setFullTextConstraint(FullTextParser.parse(".", "mountain"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
assertNull(planner.getPlan());
}
@@ -140,15 +144,15 @@ public class IndexPlannerTest {
public void noApplicableRule() throws Exception{
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
defn.setProperty(createProperty(IndexConstants.DECLARING_NODE_TYPES, of("nt:folder"), STRINGS));
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo"));
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"));
FilterImpl filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
assertNull(planner.getPlan());
filter = createFilter("nt:folder");
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar"));
- planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
assertNotNull(planner.getPlan());
}
@@ -158,29 +162,29 @@ public class IndexPlannerTest {
//as nt:folder extends nt:hierarchyNode we should get a plan
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
defn.setProperty(createProperty(IndexConstants.DECLARING_NODE_TYPES, of("nt:hierarchyNode"), STRINGS));
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo"));
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"));
FilterImpl filter = createFilter("nt:folder");
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
assertNotNull(planner.getPlan());
}
@Test
public void noMatchingProperty() throws Exception{
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo"));
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"));
FilterImpl filter = createFilter("nt:base");
filter.restrictProperty("bar", Operator.EQUAL, PropertyValues.newString("bar"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
assertNull(planner.getPlan());
}
@Test
public void matchingProperty() throws Exception{
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo"));
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"));
FilterImpl filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
assertNotNull(plan);
assertNotNull(pr(plan));
@@ -190,27 +194,27 @@ public class IndexPlannerTest {
@Test
public void purePropertyIndexAndPathRestriction() throws Exception{
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
- defn.setProperty(LuceneIndexConstants.EVALUATE_PATH_RESTRICTION, true);
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo"));
+ defn.setProperty(FulltextIndexConstants.EVALUATE_PATH_RESTRICTION, true);
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"));
FilterImpl filter = createFilter("nt:base");
filter.restrictPath("/content", Filter.PathRestriction.ALL_CHILDREN);
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
assertNull(planner.getPlan());
}
@Test
public void fulltextIndexAndPathRestriction() throws Exception{
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
- defn.setProperty(LuceneIndexConstants.EVALUATE_PATH_RESTRICTION, true);
+ defn.setProperty(FulltextIndexConstants.EVALUATE_PATH_RESTRICTION, true);
- defn = IndexDefinition.updateDefinition(defn.getNodeState().builder());
+ defn = LuceneIndexDefinition.updateDefinition(defn.getNodeState().builder());
NodeBuilder foob = getNode(defn, "indexRules/nt:base/properties/foo");
- foob.setProperty(LuceneIndexConstants.PROP_NODE_SCOPE_INDEX, true);
+ foob.setProperty(FulltextIndexConstants.PROP_NODE_SCOPE_INDEX, true);
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo"));
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"));
FilterImpl filter = createFilter("nt:base");
filter.restrictPath("/content", Filter.PathRestriction.ALL_CHILDREN);
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
//For case when a full text property is present then path restriction can be
//evaluated
@@ -220,16 +224,16 @@ public class IndexPlannerTest {
@Test
public void fulltextIndexAndNodeTypeRestriction() throws Exception{
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
- defn.setProperty(LuceneIndexConstants.EVALUATE_PATH_RESTRICTION, true);
+ defn.setProperty(FulltextIndexConstants.EVALUATE_PATH_RESTRICTION, true);
defn.setProperty(IndexConstants.DECLARING_NODE_TYPES, of("nt:file"), NAMES);
- defn = IndexDefinition.updateDefinition(defn.getNodeState().builder());
+ defn = LuceneIndexDefinition.updateDefinition(defn.getNodeState().builder());
NodeBuilder foob = getNode(defn, "indexRules/nt:file/properties/foo");
- foob.setProperty(LuceneIndexConstants.PROP_NODE_SCOPE_INDEX, true);
+ foob.setProperty(FulltextIndexConstants.PROP_NODE_SCOPE_INDEX, true);
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(),"/foo"));
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(),"/foo"));
FilterImpl filter = createFilter("nt:file");
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
//For case when a full text property is present then path restriction can be
//evaluated
@@ -240,15 +244,15 @@ public class IndexPlannerTest {
public void pureNodeTypeWithEvaluatePathRestrictionEnabled() throws Exception{
NodeBuilder index = builder.child(INDEX_DEFINITIONS_NAME);
NodeBuilder defn = newLuceneIndexDefinition(index, "lucene",
- of(TYPENAME_STRING));
- defn.setProperty(LuceneIndexConstants.EVALUATE_PATH_RESTRICTION, true);
+ of(TYPENAME_STRING));
+ defn.setProperty(FulltextIndexConstants.EVALUATE_PATH_RESTRICTION, true);
TestUtil.useV2(defn);
FilterImpl filter = createFilter("nt:file");
filter.restrictPath("/", Filter.PathRestriction.ALL_CHILDREN);
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"));
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
// /jcr:root//element(*, nt:file)
//For queries like above Fulltext index should not return a plan
@@ -258,12 +262,12 @@ public class IndexPlannerTest {
@Test
public void purePropertyIndexAndNodeTypeRestriction() throws Exception{
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
- defn.setProperty(LuceneIndexConstants.EVALUATE_PATH_RESTRICTION, true);
+ defn.setProperty(FulltextIndexConstants.EVALUATE_PATH_RESTRICTION, true);
defn.setProperty(IndexConstants.DECLARING_NODE_TYPES, of("nt:file"), NAMES);
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo"));
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"));
FilterImpl filter = createFilter("nt:file");
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
assertNull(planner.getPlan());
}
@@ -271,15 +275,15 @@ public class IndexPlannerTest {
@Test
public void purePropertyIndexAndNodeTypeRestriction2() throws Exception{
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
- defn.setProperty(LuceneIndexConstants.EVALUATE_PATH_RESTRICTION, true);
+ defn.setProperty(FulltextIndexConstants.EVALUATE_PATH_RESTRICTION, true);
- defn = IndexDefinition.updateDefinition(defn.getNodeState().builder());
+ defn = LuceneIndexDefinition.updateDefinition(defn.getNodeState().builder());
NodeBuilder foob = getNode(defn, "indexRules/nt:base/properties/foo");
- foob.setProperty(LuceneIndexConstants.PROP_NODE_SCOPE_INDEX, true);
+ foob.setProperty(FulltextIndexConstants.PROP_NODE_SCOPE_INDEX, true);
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo"));
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"));
FilterImpl filter = createFilter("nt:file");
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
//No plan should be result for a index with just a rule for nt:base
assertNull(planner.getPlan());
@@ -288,16 +292,16 @@ public class IndexPlannerTest {
@Test
public void purePropertyIndexAndNodeTypeRestriction3() throws Exception{
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
- defn.setProperty(LuceneIndexConstants.EVALUATE_PATH_RESTRICTION, true);
+ defn.setProperty(FulltextIndexConstants.EVALUATE_PATH_RESTRICTION, true);
defn.setProperty(IndexConstants.DECLARING_NODE_TYPES, of("nt:file"), NAMES);
- defn = IndexDefinition.updateDefinition(defn.getNodeState().builder());
+ defn = LuceneIndexDefinition.updateDefinition(defn.getNodeState().builder());
NodeBuilder foob = getNode(defn, "indexRules/nt:file/properties/foo");
- foob.setProperty(LuceneIndexConstants.PROP_NODE_SCOPE_INDEX, true);
+ foob.setProperty(FulltextIndexConstants.PROP_NODE_SCOPE_INDEX, true);
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo"));
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"));
FilterImpl filter = createFilter("nt:file");
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
assertNotNull(plan);
@@ -309,15 +313,15 @@ public class IndexPlannerTest {
public void worksWithIndexFormatV2Onwards() throws Exception{
NodeBuilder index = builder.child(INDEX_DEFINITIONS_NAME);
NodeBuilder nb = newLuceneIndexDefinition(index, "lucene",
- of(TYPENAME_STRING));
- //Dummy data node to ensure that IndexDefinition does not consider it
+ of(TYPENAME_STRING));
+ //Dummy data node to ensure that LuceneIndexDefinition does not consider it
//as a fresh indexing case
nb.child(INDEX_DATA_CHILD_NAME);
- IndexNode node = createIndexNode(new IndexDefinition(root, nb.getNodeState(), "/foo"));
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, nb.getNodeState(), "/foo"));
FilterImpl filter = createFilter("nt:base");
filter.setFullTextConstraint(FullTextParser.parse(".", "mountain"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
assertNull(planner.getPlan());
}
@@ -326,12 +330,12 @@ public class IndexPlannerTest {
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
long numofDocs = IndexDefinition.DEFAULT_ENTRY_COUNT + 1000;
- IndexPlanner.setUseActualEntryCount(false);
- IndexDefinition idxDefn = new IndexDefinition(root, defn.getNodeState(), "/foo");
- IndexNode node = createIndexNode(idxDefn, numofDocs);
+ FulltextIndexPlanner.setUseActualEntryCount(false);
+ LuceneIndexDefinition idxDefn = new LuceneIndexDefinition(root, defn.getNodeState(), "/foo");
+ LuceneIndexNode node = createIndexNode(idxDefn, numofDocs);
FilterImpl filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
//For propertyIndex if entry count (default to IndexDefinition.DEFAULT_ENTRY_COUNT) is
@@ -344,14 +348,14 @@ public class IndexPlannerTest {
@Test
public void propertyIndexCost2() throws Exception{
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
- defn.setProperty(LuceneIndexConstants.COST_PER_ENTRY, 2.0);
- defn.setProperty(LuceneIndexConstants.COST_PER_EXECUTION, 3.0);
+ defn.setProperty(FulltextIndexConstants.COST_PER_ENTRY, 2.0);
+ defn.setProperty(FulltextIndexConstants.COST_PER_EXECUTION, 3.0);
long numofDocs = IndexDefinition.DEFAULT_ENTRY_COUNT - 100;
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo"), numofDocs);
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"), numofDocs);
FilterImpl filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
assertEquals(documentsPerValue(numofDocs), plan.getEstimatedEntryCount());
@@ -368,10 +372,10 @@ public class IndexPlannerTest {
long numofDocs = IndexDefinition.DEFAULT_ENTRY_COUNT + 100;
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo"), numofDocs);
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"), numofDocs);
FilterImpl filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
assertEquals(entryCount, plan.getEstimatedEntryCount());
@@ -383,10 +387,10 @@ public class IndexPlannerTest {
long numofDocs = IndexDefinition.DEFAULT_ENTRY_COUNT + 100;
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo"), numofDocs);
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"), numofDocs);
FilterImpl filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
assertEquals(documentsPerValue(numofDocs), plan.getEstimatedEntryCount());
@@ -396,14 +400,14 @@ public class IndexPlannerTest {
public void fulltextIndexCost() throws Exception{
NodeBuilder index = builder.child(INDEX_DEFINITIONS_NAME);
NodeBuilder defn = newLuceneIndexDefinition(index, "lucene",
- of(TYPENAME_STRING));
+ of(TYPENAME_STRING));
TestUtil.useV2(defn);
long numofDocs = IndexDefinition.DEFAULT_ENTRY_COUNT + 1000;
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo"), numofDocs);
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"), numofDocs);
FilterImpl filter = createFilter("nt:base");
filter.setFullTextConstraint(FullTextParser.parse(".", "mountain"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
assertNotNull(plan);
@@ -414,10 +418,10 @@ public class IndexPlannerTest {
public void nullPropertyCheck() throws Exception{
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo"));
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"));
FilterImpl filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.EQUAL, null);
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
assertNull("For null checks no plan should be returned", plan);
}
@@ -428,21 +432,21 @@ public class IndexPlannerTest {
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
NodeBuilder rules = defn.child(INDEX_RULES);
TestUtil.child(rules, "oak:TestNode/properties/prop2")
- .setProperty(LuceneIndexConstants.PROP_NAME, "foo")
- .setProperty(LuceneIndexConstants.PROP_NULL_CHECK_ENABLED, true)
- .setProperty(LuceneIndexConstants.PROP_PROPERTY_INDEX, true);
+ .setProperty(FulltextIndexConstants.PROP_NAME, "foo")
+ .setProperty(FulltextIndexConstants.PROP_NULL_CHECK_ENABLED, true)
+ .setProperty(FulltextIndexConstants.PROP_PROPERTY_INDEX, true);
- IndexDefinition idxDefn = new IndexDefinition(root, builder.getNodeState().getChildNode("test"), "/foo");
- IndexNode node = createIndexNode(idxDefn);
+ LuceneIndexDefinition idxDefn = new LuceneIndexDefinition(root, builder.getNodeState().getChildNode("test"), "/foo");
+ LuceneIndexNode node = createIndexNode(idxDefn);
FilterImpl filter = createFilter(NT_TEST);
filter.restrictProperty("foo", Operator.EQUAL, null);
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
assertNotNull("For null checks plan should be returned with nullCheckEnabled", plan);
- IndexPlanner.PlanResult pr =
- (IndexPlanner.PlanResult) plan.getAttribute(LucenePropertyIndex.ATTR_PLAN_RESULT);
+ FulltextIndexPlanner.PlanResult pr =
+ (FulltextIndexPlanner.PlanResult) plan.getAttribute(FulltextIndex.ATTR_PLAN_RESULT);
assertNotNull(pr.getPropDefn(filter.getPropertyRestriction("foo")));
}
@@ -450,12 +454,12 @@ public class IndexPlannerTest {
public void noPathRestHasQueryPath() throws Exception{
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
defn.setProperty(createProperty(IndexConstants.QUERY_PATHS, of("/test/a"), Type.STRINGS));
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo"));
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"));
FilterImpl filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar"));
filter.restrictPath("/test2", Filter.PathRestriction.ALL_CHILDREN);
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
assertNull(planner.getPlan());
}
@@ -463,40 +467,40 @@ public class IndexPlannerTest {
public void hasPathRestHasMatchingQueryPaths() throws Exception{
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
defn.setProperty(createProperty(IndexConstants.QUERY_PATHS, of("/test/a", "/test/b"), Type.STRINGS));
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo"));
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"));
FilterImpl filter = createFilter("nt:base");
filter.restrictPath("/test/a", Filter.PathRestriction.ALL_CHILDREN);
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
assertNotNull(planner.getPlan());
}
@Test
public void hasPathRestHasNoExplicitQueryPaths() throws Exception{
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo"));
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"));
FilterImpl filter = createFilter("nt:base");
filter.restrictPath("/test2", Filter.PathRestriction.ALL_CHILDREN);
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
assertNotNull(planner.getPlan());
}
@Test
public void noPlanForFulltextQueryAndOnlyAnalyzedProperties() throws Exception{
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
- defn.setProperty(LuceneIndexConstants.EVALUATE_PATH_RESTRICTION, true);
+ defn.setProperty(FulltextIndexConstants.EVALUATE_PATH_RESTRICTION, true);
- defn = IndexDefinition.updateDefinition(defn.getNodeState().builder());
+ defn = LuceneIndexDefinition.updateDefinition(defn.getNodeState().builder());
NodeBuilder foob = getNode(defn, "indexRules/nt:base/properties/foo");
- foob.setProperty(LuceneIndexConstants.PROP_ANALYZED, true);
+ foob.setProperty(FulltextIndexConstants.PROP_ANALYZED, true);
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo"));
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"));
FilterImpl filter = createFilter("nt:base");
filter.setFullTextConstraint(FullTextParser.parse(".", "mountain"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
assertNull(plan);
@@ -505,17 +509,17 @@ public class IndexPlannerTest {
@Test
public void noPlanForNodeTypeQueryAndOnlyAnalyzedProperties() throws Exception{
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
- defn.setProperty(LuceneIndexConstants.EVALUATE_PATH_RESTRICTION, true);
+ defn.setProperty(FulltextIndexConstants.EVALUATE_PATH_RESTRICTION, true);
defn.setProperty(IndexConstants.DECLARING_NODE_TYPES, of("nt:file"), NAMES);
- defn = IndexDefinition.updateDefinition(defn.getNodeState().builder());
+ defn = LuceneIndexDefinition.updateDefinition(defn.getNodeState().builder());
NodeBuilder foob = getNode(defn, "indexRules/nt:file/properties/foo");
- foob.setProperty(LuceneIndexConstants.PROP_ANALYZED, true);
+ foob.setProperty(FulltextIndexConstants.PROP_ANALYZED, true);
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo"));
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"));
FilterImpl filter = createFilter("nt:file");
filter.restrictPath("/foo", Filter.PathRestriction.ALL_CHILDREN);
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
assertNull(plan);
@@ -527,25 +531,25 @@ public class IndexPlannerTest {
defnb.indexRule("nt:base").property("foo").propertyIndex();
defnb.indexRule("nt:base").property("bar").propertyIndex().weight(0);
- IndexDefinition defn = new IndexDefinition(root, defnb.build(), "/foo");
- IndexNode node = createIndexNode(defn);
+ LuceneIndexDefinition defn = new LuceneIndexDefinition(root, defnb.build(), "/foo");
+ LuceneIndexNode node = createIndexNode(defn);
FilterImpl filter = createFilter("nt:base");
filter.restrictProperty("bar", Operator.EQUAL, PropertyValues.newString("a"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
//Even though foo is indexed it would not be considered for a query involving just foo
assertNull(planner.getPlan());
filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("a"));
- planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan1 = planner.getPlan();
assertNotNull(plan1);
filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("a"));
filter.restrictProperty("bar", Operator.EQUAL, PropertyValues.newString("a"));
- planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan2 = planner.getPlan();
assertNotNull(plan2);
@@ -569,7 +573,7 @@ public class IndexPlannerTest {
boolean enableSpellcheckIndex = false;
boolean queryForSugggestion = true;
- IndexNode node = createSuggestionOrSpellcheckIndex(indexNodeType, enableSuggestionIndex, enableSpellcheckIndex);
+ LuceneIndexNode node = createSuggestionOrSpellcheckIndex(indexNodeType, enableSuggestionIndex, enableSpellcheckIndex);
QueryIndex.IndexPlan plan = getSuggestOrSpellcheckIndexPlan(node, queryNodeType, queryForSugggestion);
assertNull(plan);
@@ -584,7 +588,7 @@ public class IndexPlannerTest {
boolean enableSpellcheckIndex = false;
boolean queryForSugggestion = false;
- IndexNode node = createSuggestionOrSpellcheckIndex(indexNodeType, enableSuggestionIndex, enableSpellcheckIndex);
+ LuceneIndexNode node = createSuggestionOrSpellcheckIndex(indexNodeType, enableSuggestionIndex, enableSpellcheckIndex);
QueryIndex.IndexPlan plan = getSuggestOrSpellcheckIndexPlan(node, queryNodeType, queryForSugggestion);
assertNull(plan);
@@ -599,7 +603,7 @@ public class IndexPlannerTest {
boolean enableSpellcheckIndex = false;
boolean queryForSugggestion = true;
- IndexNode node = createSuggestionOrSpellcheckIndex(indexNodeType, enableSuggestionIndex, enableSpellcheckIndex);
+ LuceneIndexNode node = createSuggestionOrSpellcheckIndex(indexNodeType, enableSuggestionIndex, enableSpellcheckIndex);
QueryIndex.IndexPlan plan = getSuggestOrSpellcheckIndexPlan(node, queryNodeType, queryForSugggestion);
assertNotNull(plan);
@@ -615,7 +619,7 @@ public class IndexPlannerTest {
boolean enableSpellcheckIndex = true;
boolean queryForSugggestion = false;
- IndexNode node = createSuggestionOrSpellcheckIndex(indexNodeType, enableSuggestionIndex, enableSpellcheckIndex);
+ LuceneIndexNode node = createSuggestionOrSpellcheckIndex(indexNodeType, enableSuggestionIndex, enableSpellcheckIndex);
QueryIndex.IndexPlan plan = getSuggestOrSpellcheckIndexPlan(node, queryNodeType, queryForSugggestion);
assertNotNull(plan);
@@ -631,7 +635,7 @@ public class IndexPlannerTest {
boolean enableSpellcheckIndex = false;
boolean queryForSugggestion = true;
- IndexNode node = createSuggestionOrSpellcheckIndex(indexNodeType, enableSuggestionIndex, enableSpellcheckIndex);
+ LuceneIndexNode node = createSuggestionOrSpellcheckIndex(indexNodeType, enableSuggestionIndex, enableSpellcheckIndex);
QueryIndex.IndexPlan plan = getSuggestOrSpellcheckIndexPlan(node, queryNodeType, queryForSugggestion);
assertNull(plan);
@@ -646,7 +650,7 @@ public class IndexPlannerTest {
boolean enableSpellcheckIndex = true;
boolean queryForSugggestion = false;
- IndexNode node = createSuggestionOrSpellcheckIndex(indexNodeType, enableSuggestionIndex, enableSpellcheckIndex);
+ LuceneIndexNode node = createSuggestionOrSpellcheckIndex(indexNodeType, enableSuggestionIndex, enableSpellcheckIndex);
QueryIndex.IndexPlan plan = getSuggestOrSpellcheckIndexPlan(node, queryNodeType, queryForSugggestion);
assertNull(plan);
@@ -656,11 +660,11 @@ public class IndexPlannerTest {
public void fullTextQuery_RelativePath1() throws Exception{
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
- defn = IndexDefinition.updateDefinition(defn.getNodeState().builder());
+ defn = LuceneIndexDefinition.updateDefinition(defn.getNodeState().builder());
NodeBuilder foob = getNode(defn, "indexRules/nt:base/properties/foo");
- foob.setProperty(LuceneIndexConstants.PROP_ANALYZED, true);
+ foob.setProperty(FulltextIndexConstants.PROP_ANALYZED, true);
- IndexPlanner planner = createPlannerForFulltext(defn.getNodeState(), FullTextParser.parse("bar", "mountain"));
+ FulltextIndexPlanner planner = createPlannerForFulltext(defn.getNodeState(), FullTextParser.parse("bar", "mountain"));
//No plan for unindex property
assertNull(planner.getPlan());
@@ -671,15 +675,15 @@ public class IndexPlannerTest {
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("allProps"), "async");
//Index all props and then perform fulltext
- defn = IndexDefinition.updateDefinition(defn.getNodeState().builder());
+ defn = LuceneIndexDefinition.updateDefinition(defn.getNodeState().builder());
NodeBuilder foob = getNode(defn, "indexRules/nt:base/properties/allProps");
- foob.setProperty(LuceneIndexConstants.PROP_NAME, LuceneIndexConstants.REGEX_ALL_PROPS);
- foob.setProperty(LuceneIndexConstants.PROP_ANALYZED, true);
- foob.setProperty(LuceneIndexConstants.PROP_IS_REGEX, true);
+ foob.setProperty(FulltextIndexConstants.PROP_NAME, FulltextIndexConstants.REGEX_ALL_PROPS);
+ foob.setProperty(FulltextIndexConstants.PROP_ANALYZED, true);
+ foob.setProperty(FulltextIndexConstants.PROP_IS_REGEX, true);
FullTextExpression exp = FullTextParser.parse("bar", "mountain OR valley");
exp = new FullTextContains("bar", "mountain OR valley", exp);
- IndexPlanner planner = createPlannerForFulltext(defn.getNodeState(), exp);
+ FulltextIndexPlanner planner = createPlannerForFulltext(defn.getNodeState(), exp);
//No plan for unindex property
assertNotNull(planner.getPlan());
@@ -690,17 +694,17 @@ public class IndexPlannerTest {
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("allProps"), "async");
//Index all props and then perform fulltext
- defn = IndexDefinition.updateDefinition(defn.getNodeState().builder());
+ defn = LuceneIndexDefinition.updateDefinition(defn.getNodeState().builder());
NodeBuilder foob = getNode(defn, "indexRules/nt:base/properties/allProps");
- foob.setProperty(LuceneIndexConstants.PROP_NAME, LuceneIndexConstants.REGEX_ALL_PROPS);
- foob.setProperty(LuceneIndexConstants.PROP_ANALYZED, true);
- foob.setProperty(LuceneIndexConstants.PROP_NODE_SCOPE_INDEX, true);
- foob.setProperty(LuceneIndexConstants.PROP_IS_REGEX, true);
+ foob.setProperty(FulltextIndexConstants.PROP_NAME, FulltextIndexConstants.REGEX_ALL_PROPS);
+ foob.setProperty(FulltextIndexConstants.PROP_ANALYZED, true);
+ foob.setProperty(FulltextIndexConstants.PROP_NODE_SCOPE_INDEX, true);
+ foob.setProperty(FulltextIndexConstants.PROP_IS_REGEX, true);
//where contains('jcr:content/*', 'mountain OR valley') can be evaluated by index
//on nt:base by evaluating on '.' and then checking if node name is 'jcr:content'
- IndexPlanner planner = createPlannerForFulltext(defn.getNodeState(),
- FullTextParser.parse("jcr:content/*", "mountain OR valley"));
+ FulltextIndexPlanner planner = createPlannerForFulltext(defn.getNodeState(),
+ FullTextParser.parse("jcr:content/*", "mountain OR valley"));
//No plan for unindex property
assertNotNull(planner.getPlan());
@@ -711,15 +715,15 @@ public class IndexPlannerTest {
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("allProps"), "async");
//Index all props and then perform fulltext
- defn = IndexDefinition.updateDefinition(defn.getNodeState().builder());
- NodeBuilder agg = defn.child(LuceneIndexConstants.AGGREGATES).child("nt:base").child("include0");
- agg.setProperty(LuceneIndexConstants.AGG_PATH, "jcr:content");
- agg.setProperty(LuceneIndexConstants.AGG_RELATIVE_NODE, true);
+ defn = LuceneIndexDefinition.updateDefinition(defn.getNodeState().builder());
+ NodeBuilder agg = defn.child(FulltextIndexConstants.AGGREGATES).child("nt:base").child("include0");
+ agg.setProperty(FulltextIndexConstants.AGG_PATH, "jcr:content");
+ agg.setProperty(FulltextIndexConstants.AGG_RELATIVE_NODE, true);
//where contains('jcr:content/*', 'mountain OR valley') can be evaluated by index
//on nt:base by evaluating on '.' and then checking if node name is 'jcr:content'
- IndexPlanner planner = createPlannerForFulltext(defn.getNodeState(),
- FullTextParser.parse("jcr:content/*", "mountain OR valley"));
+ FulltextIndexPlanner planner = createPlannerForFulltext(defn.getNodeState(),
+ FullTextParser.parse("jcr:content/*", "mountain OR valley"));
//No plan for unindex property
assertNotNull(planner.getPlan());
@@ -730,15 +734,15 @@ public class IndexPlannerTest {
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
//Index all props and then perform fulltext
- defn = IndexDefinition.updateDefinition(defn.getNodeState().builder());
+ defn = LuceneIndexDefinition.updateDefinition(defn.getNodeState().builder());
NodeBuilder foob = getNode(defn, "indexRules/nt:base/properties/foo");
- foob.setProperty(LuceneIndexConstants.PROP_NAME, "foo");
- foob.setProperty(LuceneIndexConstants.PROP_ANALYZED, true);
+ foob.setProperty(FulltextIndexConstants.PROP_NAME, "foo");
+ foob.setProperty(FulltextIndexConstants.PROP_ANALYZED, true);
//where contains('jcr:content/*', 'mountain OR valley') can be evaluated by index
//on nt:base by evaluating on '.' and then checking if node name is 'jcr:content'
- IndexPlanner planner = createPlannerForFulltext(defn.getNodeState(),
- FullTextParser.parse("jcr:content/*", "mountain OR valley"));
+ FulltextIndexPlanner planner = createPlannerForFulltext(defn.getNodeState(),
+ FullTextParser.parse("jcr:content/*", "mountain OR valley"));
//No plan for unindex property
assertNull(planner.getPlan());
@@ -749,18 +753,18 @@ public class IndexPlannerTest {
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo", "bar"), "async");
//Index all props and then perform fulltext
- defn = IndexDefinition.updateDefinition(defn.getNodeState().builder());
+ defn = LuceneIndexDefinition.updateDefinition(defn.getNodeState().builder());
NodeBuilder foob = getNode(defn, "indexRules/nt:base/properties/foo");
- foob.setProperty(LuceneIndexConstants.PROP_NAME, "foo");
+ foob.setProperty(FulltextIndexConstants.PROP_NAME, "foo");
NodeBuilder barb = getNode(defn, "indexRules/nt:base/properties/bar");
- barb.setProperty(LuceneIndexConstants.PROP_NAME, "bar");
- barb.setProperty(LuceneIndexConstants.PROP_ANALYZED, true);
+ barb.setProperty(FulltextIndexConstants.PROP_NAME, "bar");
+ barb.setProperty(FulltextIndexConstants.PROP_ANALYZED, true);
//where contains('jcr:content/*', 'mountain OR valley') can be evaluated by index
//on nt:base by evaluating on '.' and then checking if node name is 'jcr:content'
- IndexPlanner planner = createPlannerForFulltext(defn.getNodeState(),
- FullTextParser.parse("foo", "mountain OR valley"));
+ FulltextIndexPlanner planner = createPlannerForFulltext(defn.getNodeState(),
+ FullTextParser.parse("foo", "mountain OR valley"));
//No plan for unindex property
assertNull(planner.getPlan());
@@ -771,14 +775,14 @@ public class IndexPlannerTest {
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo", "bar"), "async");
//Index all props and then perform fulltext
- defn = IndexDefinition.updateDefinition(defn.getNodeState().builder());
+ defn = LuceneIndexDefinition.updateDefinition(defn.getNodeState().builder());
NodeBuilder foob = getNode(defn, "indexRules/nt:base/properties/foo");
- foob.setProperty(LuceneIndexConstants.PROP_NAME, "foo");
- foob.setProperty(LuceneIndexConstants.PROP_ANALYZED, true);
+ foob.setProperty(FulltextIndexConstants.PROP_NAME, "foo");
+ foob.setProperty(FulltextIndexConstants.PROP_ANALYZED, true);
NodeBuilder barb = getNode(defn, "indexRules/nt:base/properties/bar");
- barb.setProperty(LuceneIndexConstants.PROP_NAME, "bar");
- barb.setProperty(LuceneIndexConstants.PROP_ANALYZED, true);
+ barb.setProperty(FulltextIndexConstants.PROP_NAME, "bar");
+ barb.setProperty(FulltextIndexConstants.PROP_ANALYZED, true);
//where contains('jcr:content/bar', 'mountain OR valley') and contains('jcr:content/foo', 'mountain OR valley')
@@ -788,7 +792,7 @@ public class IndexPlannerTest {
FullTextExpression fooExp = FullTextParser.parse("jcr:content/bar", "mountain OR valley");
FullTextExpression barExp = FullTextParser.parse("jcr:content/foo", "mountain OR valley");
FullTextExpression exp = new FullTextAnd(Arrays.asList(fooExp, barExp));
- IndexPlanner planner = createPlannerForFulltext(defn.getNodeState(),exp);
+ FulltextIndexPlanner planner = createPlannerForFulltext(defn.getNodeState(),exp);
//No plan for unindex property
assertNotNull(planner.getPlan());
@@ -799,19 +803,19 @@ public class IndexPlannerTest {
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo", "bar"), "async");
//Index all props and then perform fulltext
- defn = IndexDefinition.updateDefinition(defn.getNodeState().builder());
+ defn = LuceneIndexDefinition.updateDefinition(defn.getNodeState().builder());
NodeBuilder foob = getNode(defn, "indexRules/nt:base/properties/foo");
- foob.setProperty(LuceneIndexConstants.PROP_NAME, "foo");
- foob.setProperty(LuceneIndexConstants.PROP_ANALYZED, true);
+ foob.setProperty(FulltextIndexConstants.PROP_NAME, "foo");
+ foob.setProperty(FulltextIndexConstants.PROP_ANALYZED, true);
NodeBuilder barb = getNode(defn, "indexRules/nt:base/properties/bar");
- barb.setProperty(LuceneIndexConstants.PROP_NAME, "bar");
- barb.setProperty(LuceneIndexConstants.PROP_ANALYZED, true);
+ barb.setProperty(FulltextIndexConstants.PROP_NAME, "bar");
+ barb.setProperty(FulltextIndexConstants.PROP_ANALYZED, true);
FullTextExpression fooExp = FullTextParser.parse("metadata/bar", "mountain OR valley");
FullTextExpression barExp = FullTextParser.parse("jcr:content/foo", "mountain OR valley");
FullTextExpression exp = new FullTextAnd(Arrays.asList(fooExp, barExp));
- IndexPlanner planner = createPlannerForFulltext(defn.getNodeState(),exp);
+ FulltextIndexPlanner planner = createPlannerForFulltext(defn.getNodeState(),exp);
//No plan for unindex property
assertNull(planner.getPlan());
@@ -821,22 +825,22 @@ public class IndexPlannerTest {
public void valuePattern_Equals() throws Exception{
IndexDefinitionBuilder defnb = new IndexDefinitionBuilder();
defnb.indexRule("nt:base")
- .property("foo")
- .propertyIndex()
- .valueExcludedPrefixes("/jobs");
+ .property("foo")
+ .propertyIndex()
+ .valueExcludedPrefixes("/jobs");
- IndexDefinition defn = new IndexDefinition(root, defnb.build(), "/foo");
- IndexNode node = createIndexNode(defn);
+ LuceneIndexDefinition defn = new LuceneIndexDefinition(root, defnb.build(), "/foo");
+ LuceneIndexNode node = createIndexNode(defn);
FilterImpl filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("/bar"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
assertNotNull(planner.getPlan());
filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("/jobs/a"));
- planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
assertNull(planner.getPlan());
}
@@ -844,25 +848,25 @@ public class IndexPlannerTest {
public void valuePattern_StartsWith() throws Exception{
IndexDefinitionBuilder defnb = new IndexDefinitionBuilder();
defnb.indexRule("nt:base")
- .property("foo")
- .propertyIndex()
- .valueExcludedPrefixes("/jobs");
+ .property("foo")
+ .propertyIndex()
+ .valueExcludedPrefixes("/jobs");
- IndexDefinition defn = new IndexDefinition(root, defnb.build(), "/foo");
- IndexNode node = createIndexNode(defn);
+ LuceneIndexDefinition defn = new LuceneIndexDefinition(root, defnb.build(), "/foo");
+ LuceneIndexNode node = createIndexNode(defn);
FilterImpl filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.GREATER_OR_EQUAL, PropertyValues.newString("/bar"));
filter.restrictProperty("foo", Operator.LESS_OR_EQUAL, PropertyValues.newString("/bar0"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
assertNotNull(planner.getPlan());
filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.GREATER_OR_EQUAL, PropertyValues.newString("/jobs"));
filter.restrictProperty("foo", Operator.LESS_OR_EQUAL, PropertyValues.newString("/jobs0"));
- planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
assertNull(planner.getPlan());
}
@@ -872,18 +876,18 @@ public class IndexPlannerTest {
defnb.indexRule("nt:base").property("foo").propertyIndex();
defnb.indexRule("nt:base").property("jcr:content/bar").propertyIndex();
- IndexDefinition defn = new IndexDefinition(root, defnb.build(), "/foo");
- IndexNode node = createIndexNode(defn);
+ LuceneIndexDefinition defn = new LuceneIndexDefinition(root, defnb.build(), "/foo");
+ LuceneIndexNode node = createIndexNode(defn);
FilterImpl filter = createFilter("nt:base");
filter.restrictProperty("jcr:content/foo", Operator.EQUAL, PropertyValues.newString("/bar"));
filter.restrictProperty("bar", Operator.EQUAL, PropertyValues.newString("/bar"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
assertNotNull(plan);
- IndexPlanner.PlanResult pr = pr(plan);
+ FulltextIndexPlanner.PlanResult pr = pr(plan);
assertTrue(pr.isPathTransformed());
assertEquals("/a/b", pr.transformPath("/a/b/jcr:content"));
assertNull(pr.transformPath("/a/b/c"));
@@ -901,13 +905,13 @@ public class IndexPlannerTest {
IndexDefinitionBuilder defnb = new IndexDefinitionBuilder();
defnb.indexRule("nt:unstructured").property("foo").propertyIndex();
- IndexDefinition defn = new IndexDefinition(root, defnb.build(), "/foo");
- IndexNode node = createIndexNode(defn);
+ LuceneIndexDefinition defn = new LuceneIndexDefinition(root, defnb.build(), "/foo");
+ LuceneIndexNode node = createIndexNode(defn);
FilterImpl filter = createFilter("nt:unstructured");
filter.restrictProperty("jcr:content/foo", Operator.EQUAL, PropertyValues.newString("/bar"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
//Should not return a plan for index rule other than nt:base
@@ -920,17 +924,17 @@ public class IndexPlannerTest {
defnb.indexRule("nt:base").property("foo").propertyIndex();
defnb.aggregateRule("nt:base").include("*");
- IndexDefinition defn = new IndexDefinition(root, defnb.build(), "/foo");
- IndexNode node = createIndexNode(defn);
+ LuceneIndexDefinition defn = new LuceneIndexDefinition(root, defnb.build(), "/foo");
+ LuceneIndexNode node = createIndexNode(defn);
FilterImpl filter = createFilter("nt:base");
filter.restrictProperty("jcr:content/foo", Operator.EQUAL, PropertyValues.newString("/bar"));
FullTextExpression ft = FullTextParser.parse("jcr:content/*", "mountain OR valley");
filter.setFullTextConstraint(ft);
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
- IndexPlanner.PlanResult pr = pr(plan);
+ FulltextIndexPlanner.PlanResult pr = pr(plan);
assertFalse(pr.hasProperty("jcr:content/foo"));
}
@@ -941,19 +945,19 @@ public class IndexPlannerTest {
defnb.indexRule("nt:base").property("bar").propertyIndex();
defnb.indexRule("nt:base").property("baz").propertyIndex();
- IndexDefinition defn = new IndexDefinition(root, defnb.build(), "/foo");
- IndexNode node = createIndexNode(defn);
+ LuceneIndexDefinition defn = new LuceneIndexDefinition(root, defnb.build(), "/foo");
+ LuceneIndexNode node = createIndexNode(defn);
FilterImpl filter = createFilter("nt:base");
filter.restrictProperty("jcr:content/foo", Operator.EQUAL, PropertyValues.newString("/bar"));
filter.restrictProperty("jcr:content/bar", Operator.EQUAL, PropertyValues.newString("/bar"));
filter.restrictProperty("metadata/baz", Operator.EQUAL, PropertyValues.newString("/bar"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
assertNotNull(plan);
- IndexPlanner.PlanResult pr = pr(plan);
+ FulltextIndexPlanner.PlanResult pr = pr(plan);
assertTrue(pr.hasProperty("jcr:content/foo"));
assertTrue(pr.hasProperty("jcr:content/bar"));
assertFalse(pr.hasProperty("metadata/baz"));
@@ -966,17 +970,17 @@ public class IndexPlannerTest {
// Evaluates path restriction
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async")
- .setProperty(EVALUATE_PATH_RESTRICTION, true);
- IndexNode node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ .setProperty(EVALUATE_PATH_RESTRICTION, true);
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"));
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
assertTrue(plan.getSupportsPathRestriction());
// Doesn't evaluate path restriction
defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async")
- .setProperty(EVALUATE_PATH_RESTRICTION, false);
- node = createIndexNode(new IndexDefinition(root, defn.getNodeState(), "/foo1"));
- planner = new IndexPlanner(node, "/foo1", filter, Collections.<OrderEntry>emptyList());
+ .setProperty(EVALUATE_PATH_RESTRICTION, false);
+ node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo1"));
+ planner = new FulltextIndexPlanner(node, "/foo1", filter, Collections.<OrderEntry>emptyList());
plan = planner.getPlan();
assertFalse(plan.getSupportsPathRestriction());
}
@@ -989,13 +993,13 @@ public class IndexPlannerTest {
IndexDefinitionBuilder defnb = new IndexDefinitionBuilder();
defnb.indexRule("nt:base").property("foo").propertyIndex().unique();
- IndexDefinition defn = new IndexDefinition(root, defnb.build(), "/foo");
- IndexNode node = createIndexNode(defn, 100);
+ LuceneIndexDefinition defn = new LuceneIndexDefinition(root, defnb.build(), "/foo");
+ LuceneIndexNode node = createIndexNode(defn, 100);
FilterImpl filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
assertNotNull(plan);
@@ -1012,13 +1016,13 @@ public class IndexPlannerTest {
IndexDefinitionBuilder defnb = new IndexDefinitionBuilder();
defnb.indexRule("nt:base").property("foo").propertyIndex().unique();
- IndexDefinition defn = new IndexDefinition(root, defnb.build(), "/foo");
- IndexNode node = createIndexNode(defn);
+ LuceneIndexDefinition defn = new LuceneIndexDefinition(root, defnb.build(), "/foo");
+ LuceneIndexNode node = createIndexNode(defn);
FilterImpl filter = createFilter("nt:base");
filter.restrictProperty("jcr:content/foo", Operator.EQUAL, PropertyValues.newString("bar"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
assertNotNull(plan);
@@ -1035,13 +1039,13 @@ public class IndexPlannerTest {
IndexDefinitionBuilder defnb = new IndexDefinitionBuilder();
defnb.indexRule("nt:base").property("foo").propertyIndex().sync();
- IndexDefinition defn = new IndexDefinition(root, defnb.build(), "/foo");
- IndexNode node = createIndexNode(defn, 100);
+ LuceneIndexDefinition defn = new LuceneIndexDefinition(root, defnb.build(), "/foo");
+ LuceneIndexNode node = createIndexNode(defn, 100);
FilterImpl filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
assertNotNull(plan);
@@ -1062,14 +1066,14 @@ public class IndexPlannerTest {
defnb.indexRule("nt:base").property("foo").propertyIndex().unique();
defnb.indexRule("nt:base").property("bar").propertyIndex().sync();
- IndexDefinition defn = new IndexDefinition(root, defnb.build(), "/foo");
- IndexNode node = createIndexNode(defn, 100);
+ LuceneIndexDefinition defn = new LuceneIndexDefinition(root, defnb.build(), "/foo");
+ LuceneIndexNode node = createIndexNode(defn, 100);
FilterImpl filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar"));
filter.restrictProperty("bar", Operator.EQUAL, PropertyValues.newString("foo"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
assertNotNull(plan);
@@ -1087,14 +1091,14 @@ public class IndexPlannerTest {
defnb.indexRule("nt:base").property("foo").propertyIndex().sync();
defnb.indexRule("nt:base").property("bar").propertyIndex().ordered();
- IndexDefinition defn = new IndexDefinition(root, defnb.build(), "/foo");
- IndexNode node = createIndexNode(defn, 100);
+ LuceneIndexDefinition defn = new LuceneIndexDefinition(root, defnb.build(), "/foo");
+ LuceneIndexNode node = createIndexNode(defn, 100);
FilterImpl filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter,
- ImmutableList.of(new OrderEntry("bar", Type.LONG, OrderEntry.Order.ASCENDING)));
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter,
+ ImmutableList.of(new OrderEntry("bar", Type.LONG, OrderEntry.Order.ASCENDING)));
QueryIndex.IndexPlan plan = planner.getPlan();
assertNotNull(plan);
@@ -1110,15 +1114,15 @@ public class IndexPlannerTest {
defnb.indexRule("nt:base").property("foo").propertyIndex().sync();
defnb.indexRule("nt:base").property("bar").analyzed();
- IndexDefinition defn = new IndexDefinition(root, defnb.build(), "/foo");
- IndexNode node = createIndexNode(defn, 100);
+ LuceneIndexDefinition defn = new LuceneIndexDefinition(root, defnb.build(), "/foo");
+ LuceneIndexNode node = createIndexNode(defn, 100);
FilterImpl filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar"));
filter.setFullTextConstraint(FullTextParser.parse("bar", "mountain"));
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter,
- ImmutableList.of(new OrderEntry("bar", Type.LONG, OrderEntry.Order.ASCENDING)));
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter,
+ ImmutableList.of(new OrderEntry("bar", Type.LONG, OrderEntry.Order.ASCENDING)));
QueryIndex.IndexPlan plan = planner.getPlan();
assertNotNull(plan);
@@ -1131,16 +1135,16 @@ public class IndexPlannerTest {
//~----------------------------------------< nodetype >
String testNodeTypeDefn = "[oak:TestMixA]\n" +
- " mixin\n" +
- "\n" +
- "[oak:TestSuperType]\n" +
- "- * (UNDEFINED) multiple\n" +
- "\n" +
- "[oak:TestTypeA] > oak:TestSuperType\n" +
- "- * (UNDEFINED) multiple\n" +
- "\n" +
- "[oak:TestTypeB] > oak:TestSuperType, oak:TestMixA\n" +
- "- * (UNDEFINED) multiple";
+ " mixin\n" +
+ "\n" +
+ "[oak:TestSuperType]\n" +
+ "- * (UNDEFINED) multiple\n" +
+ "\n" +
+ "[oak:TestTypeA] > oak:TestSuperType\n" +
+ "- * (UNDEFINED) multiple\n" +
+ "\n" +
+ "[oak:TestTypeB] > oak:TestSuperType, oak:TestMixA\n" +
+ "- * (UNDEFINED) multiple";
@Test
public void nodetype_primaryType() throws Exception{
@@ -1151,22 +1155,22 @@ public class IndexPlannerTest {
defnb.nodeTypeIndex();
defnb.indexRule("oak:TestSuperType");
- IndexDefinition defn = new IndexDefinition(root, defnb.build(), "/foo");
- IndexNode node = createIndexNode(defn);
+ LuceneIndexDefinition defn = new LuceneIndexDefinition(root, defnb.build(), "/foo");
+ LuceneIndexNode node = createIndexNode(defn);
FilterImpl filter = createFilter("oak:TestSuperType");
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
assertNotNull(plan);
- IndexPlanner.PlanResult r = pr(plan);
+ FulltextIndexPlanner.PlanResult r = pr(plan);
assertTrue(r.evaluateNodeTypeRestriction());
//As oak:TestSuperType is parent of oak:TestTypeA the child nodetypes should
//also be indexed
filter = createFilter("oak:TestTypeA");
- planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
plan = planner.getPlan();
assertNotNull(plan);
@@ -1183,16 +1187,16 @@ public class IndexPlannerTest {
defnb.nodeTypeIndex();
defnb.indexRule("oak:TestMixA");
- IndexDefinition defn = new IndexDefinition(root, defnb.build(), "/foo");
- IndexNode node = createIndexNode(defn);
+ LuceneIndexDefinition defn = new LuceneIndexDefinition(root, defnb.build(), "/foo");
+ LuceneIndexNode node = createIndexNode(defn);
FilterImpl filter = createFilter("oak:TestMixA");
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
assertNotNull(plan);
- IndexPlanner.PlanResult r = pr(plan);
+ FulltextIndexPlanner.PlanResult r = pr(plan);
assertTrue(r.evaluateNodeTypeRestriction());
}
@@ -1205,52 +1209,52 @@ public class IndexPlannerTest {
defnb.nodeTypeIndex();
defnb.indexRule("oak:TestSuperType").sync();
- IndexDefinition defn = new IndexDefinition(root, defnb.build(), "/foo");
- IndexNode node = createIndexNode(defn);
+ LuceneIndexDefinition defn = new LuceneIndexDefinition(root, defnb.build(), "/foo");
+ LuceneIndexNode node = createIndexNode(defn);
FilterImpl filter = createFilter("oak:TestSuperType");
- IndexPlanner planner = new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
assertNotNull(plan);
- IndexPlanner.PlanResult r = pr(plan);
+ FulltextIndexPlanner.PlanResult r = pr(plan);
assertTrue(r.evaluateNodeTypeRestriction());
assertTrue(r.evaluateSyncNodeTypeRestriction());
}
- private IndexPlanner createPlannerForFulltext(NodeState defn, FullTextExpression exp) throws IOException {
- IndexNode node = createIndexNode(new IndexDefinition(root, defn, "/foo"));
+ private FulltextIndexPlanner createPlannerForFulltext(NodeState defn, FullTextExpression exp) throws IOException {
+ LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn, "/foo"));
FilterImpl filter = createFilter("nt:base");
filter.setFullTextConstraint(exp);
- return new IndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
+ return new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList());
}
- private IndexNode createSuggestionOrSpellcheckIndex(String nodeType,
- boolean enableSuggestion,
- boolean enableSpellcheck) throws Exception {
+ private LuceneIndexNode createSuggestionOrSpellcheckIndex(String nodeType,
+ boolean enableSuggestion,
+ boolean enableSpellcheck) throws Exception {
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
defn.setProperty(DECLARING_NODE_TYPES, nodeType);
- defn = IndexDefinition.updateDefinition(defn.getNodeState().builder());
+ defn = LuceneIndexDefinition.updateDefinition(defn.getNodeState().builder());
NodeBuilder foob = getNode(defn, "indexRules/" + nodeType + "/properties/foo");
- foob.setProperty(LuceneIndexConstants.PROP_ANALYZED, true);
+ foob.setProperty(FulltextIndexConstants.PROP_ANALYZED, true);
if (enableSuggestion) {
- foob.setProperty(LuceneIndexConstants.PROP_USE_IN_SUGGEST, true);
+ foob.setProperty(FulltextIndexConstants.PROP_USE_IN_SUGGEST, true);
} if (enableSpellcheck) {
- foob.setProperty(LuceneIndexConstants.PROP_USE_IN_SPELLCHECK, true);
+ foob.setProperty(FulltextIndexConstants.PROP_USE_IN_SPELLCHECK, true);
}
- IndexDefinition indexDefinition = new IndexDefinition(root, defn.getNodeState(), "/foo");
+ LuceneIndexDefinition indexDefinition = new LuceneIndexDefinition(root, defn.getNodeState(), "/foo");
return createIndexNode(indexDefinition);
}
- private QueryIndex.IndexPlan getSuggestOrSpellcheckIndexPlan(IndexNode indexNode, String nodeType,
+ private QueryIndex.IndexPlan getSuggestOrSpellcheckIndexPlan(LuceneIndexNode indexNode, String nodeType,
boolean forSugggestion) throws Exception {
FilterImpl filter = createFilter(nodeType);
filter.restrictProperty(indexNode.getDefinition().getFunctionName(), Operator.EQUAL,
- PropertyValues.newString((forSugggestion?"suggest":"spellcheck") + "?term=foo"));
- IndexPlanner planner = new IndexPlanner(indexNode, "/foo", filter, Collections.<OrderEntry>emptyList());
+ PropertyValues.newString((forSugggestion?"suggest":"spellcheck") + "?term=foo"));
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(indexNode, "/foo", filter, Collections.<OrderEntry>emptyList());
return planner.getPlan();
}
@@ -1261,11 +1265,11 @@ public class IndexPlannerTest {
public void noRestrictionWithSingleSortableField() throws Exception{
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async");
defn.setProperty(createProperty(ORDERED_PROP_NAMES, of("foo"), STRINGS));
- IndexDefinition definition = new IndexDefinition(root, defn.getNodeState(), "/test");
- IndexNode node = createIndexNode(definition);
- IndexPlanner planner = new IndexPlanner(node, "/test", createFilter("nt:base"),
- ImmutableList.of(new OrderEntry("foo", Type.LONG, OrderEntry.Order.ASCENDING),
- new OrderEntry("bar", Type.LONG, OrderEntry.Order.ASCENDING)));
+ LuceneIndexDefinition definition = new LuceneIndexDefinition(root, defn.getNodeState(), "/test");
+ LuceneIndexNode node = createIndexNode(definition);
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/test", createFilter("nt:base"),
+ ImmutableList.of(new OrderEntry("foo", Type.LONG, OrderEntry.Order.ASCENDING),
+ new OrderEntry("bar", Type.LONG, OrderEntry.Order.ASCENDING)));
assertNotNull(planner.getPlan());
assertEquals(1, planner.getPlan().getEstimatedEntryCount());
@@ -1276,11 +1280,11 @@ public class IndexPlannerTest {
public void noRestrictionWithTwoSortableFields() throws Exception{
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo", "bar"), "async");
defn.setProperty(createProperty(ORDERED_PROP_NAMES, of("foo", "bar"), STRINGS));
- IndexDefinition definition = new IndexDefinition(root, defn.getNodeState(), "/test");
- IndexNode node = createIndexNode(definition);
- IndexPlanner planner = new IndexPlanner(node, "/test", createFilter("nt:base"),
- ImmutableList.of(new OrderEntry("foo", Type.LONG, OrderEntry.Order.ASCENDING),
- new OrderEntry("bar", Type.LONG, OrderEntry.Order.ASCENDING)));
+ LuceneIndexDefinition definition = new LuceneIndexDefinition(root, defn.getNodeState(), "/test");
+ LuceneIndexNode node = createIndexNode(definition);
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/test", createFilter("nt:base"),
+ ImmutableList.of(new OrderEntry("foo", Type.LONG, OrderEntry.Order.ASCENDING),
+ new OrderEntry("bar", Type.LONG, OrderEntry.Order.ASCENDING)));
assertNotNull(planner.getPlan());
assertEquals(1, planner.getPlan().getEstimatedEntryCount());
@@ -1292,16 +1296,16 @@ public class IndexPlannerTest {
NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo", "foo1", "foo2"), "async");
long numOfDocs = IndexDefinition.DEFAULT_ENTRY_COUNT + 1000;
- IndexDefinition idxDefn = new IndexDefinition(root, defn.getNodeState(), "/test");
+ LuceneIndexDefinition idxDefn = new LuceneIndexDefinition(root, defn.getNodeState(), "/test");
Document doc = new Document();
doc.add(new StringField("foo1", "bar1", Field.Store.NO));
Directory sampleDirectory = createSampleDirectory(numOfDocs, doc);
- IndexNode node = createIndexNode(idxDefn, sampleDirectory);
+ LuceneIndexNode node = createIndexNode(idxDefn, sampleDirectory);
// Query on "foo"
FilterImpl filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar"));
- IndexPlanner planner = new IndexPlanner(node, "/test", filter, Collections.emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/test", filter, Collections.emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
assertEquals(documentsPerValue(numOfDocs), plan.getEstimatedEntryCount());
@@ -1311,14 +1315,14 @@ public class IndexPlannerTest {
// Query on "foo" is not null
filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.NOT_EQUAL, null);
- planner = new IndexPlanner(node, "/test", filter, Collections.emptyList());
+ planner = new FulltextIndexPlanner(node, "/test", filter, Collections.emptyList());
plan = planner.getPlan();
assertEquals(numOfDocs, plan.getEstimatedEntryCount());
// Query on "foo" like x
filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.LIKE, PropertyValues.newString("bar%"));
- planner = new IndexPlanner(node, "/test", filter, Collections.emptyList());
+ planner = new FulltextIndexPlanner(node, "/test", filter, Collections.emptyList());
plan = planner.getPlan();
// weight of 3
assertEquals(numOfDocs / 3 + 1, plan.getEstimatedEntryCount());
@@ -1326,7 +1330,7 @@ public class IndexPlannerTest {
// Query on "foo" > x
filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.GREATER_OR_EQUAL, PropertyValues.newString("bar"));
- planner = new IndexPlanner(node, "/test", filter, Collections.emptyList());
+ planner = new FulltextIndexPlanner(node, "/test", filter, Collections.emptyList());
plan = planner.getPlan();
// weight of 3
assertEquals(numOfDocs / 3 + 1, plan.getEstimatedEntryCount());
@@ -1334,7 +1338,7 @@ public class IndexPlannerTest {
// Query on "foo1"
filter = createFilter("nt:base");
filter.restrictProperty("foo1", Operator.EQUAL, PropertyValues.newString("bar1"));
- planner = new IndexPlanner(node, "/test", filter, Collections.emptyList());
+ planner = new FulltextIndexPlanner(node, "/test", filter, Collections.emptyList());
plan = planner.getPlan();
assertEquals(1, plan.getEstimatedEntryCount());
@@ -1345,7 +1349,7 @@ public class IndexPlannerTest {
filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar"));
filter.restrictProperty("foo1", Operator.EQUAL, PropertyValues.newString("bar1"));
- planner = new IndexPlanner(node, "/test", filter, Collections.emptyList());
+ planner = new FulltextIndexPlanner(node, "/test", filter, Collections.emptyList());
plan = planner.getPlan();
assertEquals(1, plan.getEstimatedEntryCount());
@@ -1355,7 +1359,7 @@ public class IndexPlannerTest {
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar"));
filter.restrictProperty("foo1", Operator.EQUAL, PropertyValues.newString("bar1"));
filter.restrictProperty("foo2", Operator.EQUAL, PropertyValues.newString("bar2"));
- planner = new IndexPlanner(node, "/test", filter, Collections.emptyList());
+ planner = new FulltextIndexPlanner(node, "/test", filter, Collections.emptyList());
plan = planner.getPlan();
assertEquals(0, plan.getEstimatedEntryCount());
@@ -1366,9 +1370,9 @@ public class IndexPlannerTest {
String indexPath = "/test";
IndexDefinitionBuilder idxBuilder = new IndexDefinitionBuilder(child(builder, indexPath));
idxBuilder.indexRule("nt:base").property("foo").propertyIndex().weight(500)
- .enclosingRule().property("foo1").propertyIndex().weight(20)
- .enclosingRule().property("foo2").propertyIndex().weight(0)
- .enclosingRule().property("foo3").propertyIndex()
+ .enclosingRule().property("foo1").propertyIndex().weight(20)
+ .enclosingRule().property("foo2").propertyIndex().weight(0)
+ .enclosingRule().property("foo3").propertyIndex()
;
NodeState defn = idxBuilder.build();
@@ -1383,13 +1387,13 @@ public class IndexPlannerTest {
doc.add(new StringField("foo2", "bar2", Field.Store.NO));
docs.add(doc);
Directory sampleDirectory = createSampleDirectory(1000, docs);
- IndexDefinition idxDefn = new IndexDefinition(root, defn, indexPath);
- IndexNode node = createIndexNode(idxDefn, sampleDirectory);
+ LuceneIndexDefinition idxDefn = new LuceneIndexDefinition(root, defn, indexPath);
+ LuceneIndexNode node = createIndexNode(idxDefn, sampleDirectory);
// Query on "foo"
FilterImpl filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar"));
- IndexPlanner planner = new IndexPlanner(node, indexPath, filter, Collections.emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, indexPath, filter, Collections.emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
//scale down 1000 by 500 = 2
@@ -1398,7 +1402,7 @@ public class IndexPlannerTest {
// Query on "foo1"
filter = createFilter("nt:base");
filter.restrictProperty("foo1", Operator.EQUAL, PropertyValues.newString("bar"));
- planner = new IndexPlanner(node, indexPath, filter, Collections.emptyList());
+ planner = new FulltextIndexPlanner(node, indexPath, filter, Collections.emptyList());
plan = planner.getPlan();
//scale down 60 by 20 = 2
@@ -1408,7 +1412,7 @@ public class IndexPlannerTest {
filter = createFilter("nt:base");
filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar"));
filter.restrictProperty("foo1", Operator.EQUAL, PropertyValues.newString("bar"));
- planner = new IndexPlanner(node, indexPath, filter, Collections.emptyList());
+ planner = new FulltextIndexPlanner(node, indexPath, filter, Collections.emptyList());
plan = planner.getPlan();
//min(2, 3)
@@ -1418,7 +1422,7 @@ public class IndexPlannerTest {
filter = createFilter("nt:base");
filter.restrictProperty("foo1", Operator.EQUAL, PropertyValues.newString("bar"));
filter.restrictProperty("foo2", Operator.EQUAL, PropertyValues.newString("bar"));
- planner = new IndexPlanner(node, indexPath, filter, Collections.emptyList());
+ planner = new FulltextIndexPlanner(node, indexPath, filter, Collections.emptyList());
plan = planner.getPlan();
//don't scale down 1 by 0 (foo1 would estimate 3)
@@ -1428,7 +1432,7 @@ public class IndexPlannerTest {
filter = createFilter("nt:base");
filter.restrictProperty("foo1", Operator.EQUAL, PropertyValues.newString("bar"));
filter.restrictProperty("foo3", Operator.EQUAL, PropertyValues.newString("bar"));
- planner = new IndexPlanner(node, indexPath, filter, Collections.emptyList());
+ planner = new FulltextIndexPlanner(node, indexPath, filter, Collections.emptyList());
plan = planner.getPlan();
//min(0, 3)
@@ -1440,7 +1444,7 @@ public class IndexPlannerTest {
String indexPath = "/test";
IndexDefinitionBuilder idxBuilder = new IndexDefinitionBuilder(child(builder, indexPath));
idxBuilder.indexRule("nt:base").property("foo").propertyIndex()
- .enclosingRule().property("bar", "bar.*", true).propertyIndex().weight(20)
+ .enclosingRule().property("bar", "bar.*", true).propertyIndex().weight(20)
;
NodeState defn = idxBuilder.build();
@@ -1457,13 +1461,13 @@ public class IndexPlannerTest {
docs.add(doc);
}
Directory sampleDirectory = createSampleDirectory(1000, docs);
- IndexDefinition idxDefn = new IndexDefinition(root, defn, indexPath);
- IndexNode node = createIndexNode(idxDefn, sampleDirectory);
+ LuceneIndexDefinition idxDefn = new LuceneIndexDefinition(root, defn, indexPath);
+ LuceneIndexNode node = createIndexNode(idxDefn, sampleDirectory);
// Query on and "bar1"
FilterImpl filter = createFilter("nt:base");
filter.restrictProperty("bar1", Operator.EQUAL, PropertyValues.newString("foo1"));
- IndexPlanner planner = new IndexPlanner(node, indexPath, filter, Collections.emptyList());
+ FulltextIndexPlanner planner = new FulltextIndexPlanner(node, indexPath, filter, Collections.emptyList());
QueryIndex.IndexPlan plan = planner.getPlan();
//scale down 60 by 20 = 3
@@ -1473,7 +1477,7 @@ public class IndexPlannerTest {
filter = createFilter("nt:base");
filter.restrictProperty("bar1", Operator.EQUAL, PropertyValues.newString("foo1"));
filter.restrictProperty("bar2", Operator.EQUAL, PropertyValues.newString("foo2"));
- planner = new IndexPlanner(node, indexPath, filter, Collections.emptyList());
+ planner = new FulltextIndexPlanner(node, indexPath, filter, Collections.emptyList());
plan = planner.getPlan();
//min(3, 2)
@@ -1485,7 +1489,7 @@ public class IndexPlannerTest {
String indexPath = "/test";
IndexDefinitionBuilder idxBuilder = new IndexDefinitionBuilder(child(builder, indexPath));
idxBuilder.indexRule("nt:base").property("foo").propertyIndex().weight(Integer.MAX_VALUE/2)
- .enclosingRule().property("foo1").propertyIndex()
+ .enclosingRule().property("foo1").propertyIndex()
;
NodeState defn = idxBuilder.build();
@@ -1497,13 +1501,13 @@ public class IndexPlannerTest {
docs.add(doc);
}
[... 324 lines stripped ...]