@Override public long getEstimatedEntryCount() { long totalEntries = 0; for (IndexPlan p : basePlans.values()) { if (p != null) { totalEntries += p.getEstimatedEntryCount(); } } return totalEntries; }
@Override public long getEstimatedEntryCount() { long totalEntries = 0; for (IndexPlan p : basePlans.values()) { if (p != null) { totalEntries += p.getEstimatedEntryCount(); } } return totalEntries; }
@Override public long getEstimatedEntryCount() { long totalEntries = 0; for (IndexPlan p : basePlans.values()) { if (p != null) { totalEntries += p.getEstimatedEntryCount(); } } return totalEntries; }
@Test public void syncIndex_NotUsedWithFulltext() throws Exception{ IndexDefinitionBuilder defnb = new IndexDefinitionBuilder(); defnb.indexRule("nt:base").property("foo").propertyIndex().sync(); defnb.indexRule("nt:base").property("bar").analyzed(); 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")); FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, ImmutableList.of(new OrderEntry("bar", Type.LONG, OrderEntry.Order.ASCENDING))); QueryIndex.IndexPlan plan = planner.getPlan(); assertNotNull(plan); assertEquals(documentsPerValue(100), plan.getEstimatedEntryCount()); PropertyIndexResult hr = pr(plan).getPropertyIndexResult(); assertNull(hr); }
@Test public void syncIndex_NotUsedWithSort() throws Exception{ IndexDefinitionBuilder defnb = new IndexDefinitionBuilder(); defnb.indexRule("nt:base").property("foo").propertyIndex().sync(); defnb.indexRule("nt:base").property("bar").propertyIndex().ordered(); 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")); FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, ImmutableList.of(new OrderEntry("bar", Type.LONG, OrderEntry.Order.ASCENDING))); QueryIndex.IndexPlan plan = planner.getPlan(); assertNotNull(plan); assertEquals(documentsPerValue(100), plan.getEstimatedEntryCount()); PropertyIndexResult hr = pr(plan).getPropertyIndexResult(); assertNull(hr); }
@Test public void propertyIndexCost() throws Exception{ NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async"); long numofDocs = IndexDefinition.DEFAULT_ENTRY_COUNT + 1000; 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")); 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 //less than numOfDoc then that would be preferred assertEquals(idxDefn.getEntryCount(), plan.getEstimatedEntryCount()); assertEquals(1.0, plan.getCostPerExecution(), 0); assertEquals(1.0, plan.getCostPerEntry(), 0); }
@Test public void syncIndex_nonUnique() throws Exception{ IndexDefinitionBuilder defnb = new IndexDefinitionBuilder(); defnb.indexRule("nt:base").property("foo").propertyIndex().sync(); 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")); FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList()); QueryIndex.IndexPlan plan = planner.getPlan(); assertNotNull(plan); assertEquals(documentsPerValue(100), plan.getEstimatedEntryCount()); PropertyIndexResult hr = pr(plan).getPropertyIndexResult(); assertNotNull(hr); assertEquals("foo", hr.propertyName); assertEquals("foo", hr.pr.propertyName); }
@Test public void syncIndex_uniqueAndRelative() throws Exception{ IndexDefinitionBuilder defnb = new IndexDefinitionBuilder(); defnb.indexRule("nt:base").property("foo").propertyIndex().unique(); 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")); FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList()); QueryIndex.IndexPlan plan = planner.getPlan(); assertNotNull(plan); assertEquals(1, plan.getEstimatedEntryCount()); PropertyIndexResult hr = pr(plan).getPropertyIndexResult(); assertNotNull(hr); assertEquals("foo", hr.propertyName); assertEquals("jcr:content/foo", hr.pr.propertyName); }
@Test public void syncIndex_uniqueIndex() throws Exception{ IndexDefinitionBuilder defnb = new IndexDefinitionBuilder(); defnb.indexRule("nt:base").property("foo").propertyIndex().unique(); 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")); FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList()); QueryIndex.IndexPlan plan = planner.getPlan(); assertNotNull(plan); assertEquals(1, plan.getEstimatedEntryCount()); PropertyIndexResult hr = pr(plan).getPropertyIndexResult(); assertNotNull(hr); assertEquals("foo", hr.propertyName); assertEquals("foo", hr.pr.propertyName); }
@Test public void propertyIndexCost2() throws Exception{ NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async"); defn.setProperty(FulltextIndexConstants.COST_PER_ENTRY, 2.0); defn.setProperty(FulltextIndexConstants.COST_PER_EXECUTION, 3.0); long numofDocs = IndexDefinition.DEFAULT_ENTRY_COUNT - 100; LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"), numofDocs); FilterImpl filter = createFilter("nt:base"); filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar")); FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList()); QueryIndex.IndexPlan plan = planner.getPlan(); assertEquals(documentsPerValue(numofDocs), plan.getEstimatedEntryCount()); assertEquals(3.0, plan.getCostPerExecution(), 0); assertEquals(2.0, plan.getCostPerEntry(), 0); assertNotNull(plan); }
@Override public double getCostPerEntry() { // calculate the weigted average double costPerEntry = 0; long totalEntries = getEstimatedEntryCount(); if (totalEntries == 0) { return 0; } for (IndexPlan p : basePlans.values()) { if (p != null) { costPerEntry += p.getCostPerEntry() * p.getEstimatedEntryCount() / totalEntries; } } return costPerEntry; }
@Override public double getCostPerEntry() { // calculate the weigted average double costPerEntry = 0; long totalEntries = getEstimatedEntryCount(); if (totalEntries == 0) { return 0; } for (IndexPlan p : basePlans.values()) { if (p != null) { costPerEntry += p.getCostPerEntry() * p.getEstimatedEntryCount() / totalEntries; } } return costPerEntry; }
@Test public void fulltextIndexCost() throws Exception{ NodeBuilder index = builder.child(INDEX_DEFINITIONS_NAME); NodeBuilder defn = newLuceneIndexDefinition(index, "lucene", of(TYPENAME_STRING)); TestUtil.useV2(defn); long numofDocs = IndexDefinition.DEFAULT_ENTRY_COUNT + 1000; LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"), numofDocs); FilterImpl filter = createFilter("nt:base"); filter.setFullTextConstraint(FullTextParser.parse(".", "mountain")); FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList()); QueryIndex.IndexPlan plan = planner.getPlan(); assertNotNull(plan); assertEquals(numofDocs, plan.getEstimatedEntryCount()); }
@Override public double getCostPerEntry() { // calculate the weigted average double costPerEntry = 0; long totalEntries = getEstimatedEntryCount(); if (totalEntries == 0) { return 0; } for (IndexPlan p : basePlans.values()) { if (p != null) { costPerEntry += p.getCostPerEntry() * p.getEstimatedEntryCount() / totalEntries; } } return costPerEntry; }
@Test public void copy() throws Exception{ Filter f = new FilterImpl(null, "SELECT * FROM [nt:file]", new QueryEngineSettings()); IndexPlan.Builder b = new IndexPlan.Builder(); IndexPlan plan1 = b.setEstimatedEntryCount(10).setFilter(f).setDelayed(true).build(); IndexPlan plan2 = plan1.copy(); plan2.setFilter(new FilterImpl(null, "SELECT * FROM [oak:Unstructured]", new QueryEngineSettings())); assertEquals(plan1.getEstimatedEntryCount(), 10); assertEquals(plan2.getEstimatedEntryCount(), 10); assertTrue(plan1.isDelayed()); assertTrue(plan2.isDelayed()); assertEquals(plan1.getFilter().getQueryStatement(), "SELECT * FROM [nt:file]"); assertEquals(plan2.getFilter().getQueryStatement(), "SELECT * FROM [oak:Unstructured]"); }
@Test public void noRestrictionWithTwoSortableFields() throws Exception{ NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo", "bar"), "async"); defn.setProperty(createProperty(ORDERED_PROP_NAMES, of("foo", "bar"), STRINGS)); 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()); assertEquals(definition.getCostPerEntry()/3, planner.getPlan().getCostPerEntry(), 0.0001); }
@Test public void noRestrictionWithSingleSortableField() throws Exception{ NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async"); defn.setProperty(createProperty(ORDERED_PROP_NAMES, of("foo"), STRINGS)); 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()); assertEquals(definition.getCostPerEntry()/2, planner.getPlan().getCostPerEntry(), 0.0001); }
@Test public void propertyIndexCostActualOverriddenByEntryCount() throws Exception{ NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async"); long entryCount = IndexDefinition.DEFAULT_ENTRY_COUNT - 100; defn.setProperty(IndexConstants.ENTRY_COUNT_PROPERTY_NAME, entryCount); long numofDocs = IndexDefinition.DEFAULT_ENTRY_COUNT + 100; LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"), numofDocs); FilterImpl filter = createFilter("nt:base"); filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar")); FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList()); QueryIndex.IndexPlan plan = planner.getPlan(); assertEquals(entryCount, plan.getEstimatedEntryCount()); }
@Test public void propertyIndexCostActualByDefault() throws Exception{ NodeBuilder defn = newLucenePropertyIndexDefinition(builder, "test", of("foo"), "async"); long numofDocs = IndexDefinition.DEFAULT_ENTRY_COUNT + 100; LuceneIndexNode node = createIndexNode(new LuceneIndexDefinition(root, defn.getNodeState(), "/foo"), numofDocs); FilterImpl filter = createFilter("nt:base"); filter.restrictProperty("foo", Operator.EQUAL, PropertyValues.newString("bar")); FulltextIndexPlanner planner = new FulltextIndexPlanner(node, "/foo", filter, Collections.<OrderEntry>emptyList()); QueryIndex.IndexPlan plan = planner.getPlan(); assertEquals(documentsPerValue(numofDocs), plan.getEstimatedEntryCount()); }
@Test public void builder() { IndexPlan.Builder b = new IndexPlan.Builder(); IndexPlan plan = b.setEstimatedEntryCount(10).build(); assertEquals(10, plan.getEstimatedEntryCount()); b.setEstimatedEntryCount(20); assertEquals(10, plan.getEstimatedEntryCount()); }