final AtomicBoolean dirtyFlag = new AtomicBoolean(); final AtomicBoolean facetFlag = new AtomicBoolean(); indexingRule.getAggregate().collectAggregates(state, new Aggregate.ResultCollector() { @Override public void onResult(Aggregate.NodeIncludeResult result) {
if (ft != null && !indexingRule.isFulltextEnabled()){ return null; return getNativeFunctionPlanBuilder(indexingRule.getBaseNodeType()); for (PropertyDefinition functionIndex : indexingRule.getFunctionRestrictions()) { for (PropertyRestriction pr : filter.getPropertyRestrictions()) { String f = functionIndex.function; boolean ntBaseRule = NT_BASE.equals(indexingRule.getNodeTypeName()); Map<String, PropertyDefinition> relativePropDefns = new HashMap<>(); if (indexingRule.propertyIndexEnabled) { PropertyDefinition facetPropDef = indexingRule.getConfig(facetProp); if (facetPropDef == null || !facetPropDef.facet) { log.warn("{} not backed by index. Opting out", value); PropertyDefinition pd = indexingRule.getConfig(pr.propertyName);
!indexingRule.getNodeScopeAnalyzedProps().isEmpty()) { BooleanQuery in = new BooleanQuery(); for (PropertyDefinition pd : indexingRule.getNodeScopeAnalyzedProps()) { Query q = tokenToQuery(text, FieldNames.createAnalyzedFieldName(pd.name), analyzer); q.setBoost(pd.boost);
if (nodeScopedCondition.get() && !indexingRule.isNodeFullTextIndexed()){ return false; if (!rule.isNodeFullTextIndexed()) { return false; PropertyDefinition pd = rule.getConfig(propertyName); if (pd == null){ return false;
String pname, PropertyDefinition pd) { boolean includeTypeForFullText = indexingRule.includePropertyType(property.getType().tag());
PropertyDefinition pd = indexingRule.getConfig(pname); if (indexingRule.isNodeNameIndexed()){ addNodeNameField(document, name); dirty = true; if(!indexingRule.indexesAllNodesOfMatchingType() && !dirty){ return null; if (indexingRule.isFulltextEnabled()) { indexFulltextValue(document, name);
if (!ruleAggNode.includePropertyType(type)) { continue; } else if (!indexingRule.includePropertyType(type)){ continue; PropertyDefinition pdForRootNode = indexingRule.getConfig(propertyPath); if (pdForRootNode != null && (!pdForRootNode.index || pdForRootNode.excludeFromAggregate)) { continue; PropertyDefinition pd = null; if (ruleAggNode != null){ pd = ruleAggNode.getConfig(pname);
if (filter.getSupertypes().contains(rule.getNodeTypeName())){ IndexDefinition.IndexingRule matchingRule = definition.getApplicableIndexingRule(rule.getNodeTypeName()); if (matchingRule == null && rule.getNodeTypeName().equals(filter.getNodeType())){ if (rule.getNodeTypeName().equals(JcrConstants.NT_BASE)){ return rule;
final List<String> allNames = getAllNodeTypes(ntReg); for (Tree ruleEntry : ruleTree.getChildren()) { IndexingRule rule = new IndexingRule(ruleEntry.getName(), indexRules.getChildNode(ruleEntry.getName())); definedIndexRules.add(rule); log.trace("Found rule '{}' for NodeType '{}'", rule, rule.getNodeTypeName()); ntNames = Collections.singletonList(rule.getNodeTypeName()); if (ntReg.isNodeType(ntName, rule.getNodeTypeName())) { List<IndexingRule> perNtConfig = nt2rules.get(ntName); if (perNtConfig == null) { perNtConfig.add(new IndexingRule(rule, ntName));
!indexingRule.getNodeScopeAnalyzedProps().isEmpty()) { BooleanQuery in = new BooleanQuery(); for (PropertyDefinition pd : indexingRule.getNodeScopeAnalyzedProps()) { Query q = tokenToQuery(text, FieldNames.createAnalyzedFieldName(pd.name), analyzer); q.setBoost(pd.boost);
@Test public void nonIndexPropShouldHaveAllOtherConfigDisabled() throws Exception{ NodeBuilder rules = builder.child(INDEX_RULES); rules.child("nt:folder"); TestUtil.child(rules, "nt:folder/properties/prop1") .setProperty(PROP_NAME, "foo") .setProperty(FulltextIndexConstants.PROP_INDEX, false) .setProperty(FulltextIndexConstants.PROP_USE_IN_SUGGEST, true) .setProperty(FulltextIndexConstants.PROP_USE_IN_SPELLCHECK, true) .setProperty(FulltextIndexConstants.PROP_NULL_CHECK_ENABLED, true) .setProperty(FulltextIndexConstants.PROP_NOT_NULL_CHECK_ENABLED, true) .setProperty(FulltextIndexConstants.PROP_USE_IN_EXCERPT, true) .setProperty(FulltextIndexConstants.PROP_NODE_SCOPE_INDEX, true) .setProperty(FulltextIndexConstants.PROP_ORDERED, true) .setProperty(FulltextIndexConstants.PROP_ANALYZED, true); IndexDefinition defn = new IndexDefinition(root, builder.getNodeState(), "/foo"); IndexingRule rule = defn.getApplicableIndexingRule(asState(newNode("nt:folder"))); assertNotNull(rule); PropertyDefinition pd = rule.getConfig("foo"); //Assert that all other config is false if the index=false for any property assertFalse(pd.index); assertFalse(pd.nodeScopeIndex); assertFalse(pd.useInSuggest); assertFalse(pd.useInSpellcheck); assertFalse(pd.nullCheckEnabled); assertFalse(pd.notNullCheckEnabled); assertFalse(pd.stored); assertFalse(pd.ordered); assertFalse(pd.analyzed); }
/** * Creates a new indexing rule base on an existing one, but for a * different node type name. * * @param original the existing rule. * @param nodeTypeName the node type name for the rule. */ IndexingRule(IndexingRule original, String nodeTypeName) { this.nodeTypeName = nodeTypeName; this.baseNodeType = original.getNodeTypeName(); this.propConfigs = original.propConfigs; this.namePatterns = original.namePatterns; this.boost = original.boost; this.inherited = original.inherited; this.propertyTypes = original.propertyTypes; this.propertyIndexEnabled = original.propertyIndexEnabled; this.propAggregate = original.propAggregate; this.nullCheckEnabledProperties = original.nullCheckEnabledProperties; this.notNullCheckEnabledProperties = original.notNullCheckEnabledProperties; this.functionRestrictions = original.functionRestrictions; this.nodeScopeAnalyzedProps = original.nodeScopeAnalyzedProps; this.aggregate = combine(propAggregate, nodeTypeName); this.fulltextEnabled = aggregate.hasNodeAggregates() || original.fulltextEnabled; this.nodeFullTextIndexed = aggregate.hasNodeAggregates() || original.nodeFullTextIndexed; this.indexesAllNodesOfMatchingType = areAlMatchingNodeByTypeIndexed(); this.nodeNameIndexed = original.nodeNameIndexed; this.syncProps = original.syncProps; this.similarityProperties = original.similarityProperties; }
private static boolean isExcludedProperty(PropertyRestriction pr, IndexingRule rule) { String name = pr.propertyName; if (name.contains("/")) { // lucene cannot handle child-level property restrictions return true; } PropertyDefinition pd = rule.getConfig(name); // check name if(pd == null || !pd.index){ return true; } // check type Integer type = null; if (pr.first != null) { type = pr.first.getType().tag(); } else if (pr.last != null) { type = pr.last.getType().tag(); } else if (pr.list != null && !pr.list.isEmpty()) { type = pr.list.get(0).getType().tag(); } if (type != null) { if (!includePropertyType(type, rule)) { return true; } } return false; }
private static boolean isExcludedProperty(PropertyRestriction pr, IndexingRule rule) { String name = pr.propertyName; if (name.contains("/")) { // lucene cannot handle child-level property restrictions return true; } PropertyDefinition pd = rule.getConfig(name); // check name if(pd == null || !pd.index){ return true; } // check type Integer type = null; if (pr.first != null) { type = pr.first.getType().tag(); } else if (pr.last != null) { type = pr.last.getType().tag(); } else if (pr.list != null && !pr.list.isEmpty()) { type = pr.list.get(0).getType().tag(); } if (type != null) { if (!includePropertyType(type, rule)) { return true; } } return false; }
@Test public void nonIndexPropShouldHaveAllOtherConfigDisabled() throws Exception{ NodeBuilder rules = builder.child(INDEX_RULES); rules.child("nt:folder"); TestUtil.child(rules, "nt:folder/properties/prop1") .setProperty(PROP_NAME, "foo") .setProperty(FulltextIndexConstants.PROP_INDEX, false) .setProperty(FulltextIndexConstants.PROP_USE_IN_SUGGEST, true) .setProperty(FulltextIndexConstants.PROP_USE_IN_SPELLCHECK, true) .setProperty(FulltextIndexConstants.PROP_NULL_CHECK_ENABLED, true) .setProperty(FulltextIndexConstants.PROP_NOT_NULL_CHECK_ENABLED, true) .setProperty(FulltextIndexConstants.PROP_USE_IN_EXCERPT, true) .setProperty(FulltextIndexConstants.PROP_NODE_SCOPE_INDEX, true) .setProperty(FulltextIndexConstants.PROP_ORDERED, true) .setProperty(FulltextIndexConstants.PROP_ANALYZED, true); LuceneIndexDefinition defn = new LuceneIndexDefinition(root, builder.getNodeState(), "/foo"); IndexingRule rule = defn.getApplicableIndexingRule(asState(newNode("nt:folder"))); assertNotNull(rule); PropertyDefinition pd = rule.getConfig("foo"); //Assert that all other config is false if the index=false for any property assertFalse(pd.index); assertFalse(pd.nodeScopeIndex); assertFalse(pd.useInSuggest); assertFalse(pd.useInSpellcheck); assertFalse(pd.nullCheckEnabled); assertFalse(pd.notNullCheckEnabled); assertFalse(pd.stored); assertFalse(pd.ordered); assertFalse(pd.analyzed); }
private List<OrderEntry> createSortOrder(IndexDefinition.IndexingRule rule) { if (sortOrder == null) { return Collections.emptyList(); } List<OrderEntry> orderEntries = newArrayListWithCapacity(sortOrder.size()); for (OrderEntry o : sortOrder) { PropertyDefinition pd = rule.getConfig(o.getPropertyName()); if (pd != null && pd.ordered && o.getPropertyType() != null && !o.getPropertyType().isArray()) { orderEntries.add(o); // can manage any order desc/asc result.sortedProperties.add(pd); } else if (o.getPropertyName().equals(IndexDefinition.NATIVE_SORT_ORDER.getPropertyName())) { // Supports jcr:score descending natively orderEntries.add(IndexDefinition.NATIVE_SORT_ORDER); } for (PropertyDefinition functionIndex : rule.getFunctionRestrictions()) { if (o.getPropertyName().equals(functionIndex.function)) { // can manage any order desc/asc orderEntries.add(o); result.sortedProperties.add(functionIndex); } } } //TODO Should we return order entries only when all order clauses are satisfied return orderEntries; }
@Test public void indexRuleWithPropertyOrdering() throws Exception{ NodeBuilder rules = builder.child(INDEX_RULES); rules.child("nt:folder"); TestUtil.child(rules, "nt:folder/properties/prop1") .setProperty(PROP_NAME, "foo.*") .setProperty(FulltextIndexConstants.PROP_IS_REGEX, true) .setProperty(FulltextIndexConstants.FIELD_BOOST, 3.0); TestUtil.child(rules, "nt:folder/properties/prop2") .setProperty(PROP_NAME, ".*") .setProperty(FulltextIndexConstants.PROP_IS_REGEX, true) .setProperty(FulltextIndexConstants.FIELD_BOOST, 4.0); rules.child("nt:folder").child(PROP_NODE).setProperty(OAK_CHILD_ORDER, ImmutableList.of("prop2", "prop1"), NAMES); LuceneIndexDefinition defn = new LuceneIndexDefinition(root, builder.getNodeState(), "/foo"); IndexingRule rule1 = defn.getApplicableIndexingRule(asState(newNode("nt:folder"))); assertNotNull(rule1); assertTrue(rule1.isIndexed("prop1")); assertTrue(rule1.isIndexed("fooProp")); assertEquals(4.0f, rule1.getConfig("bazProp2").boost, 0); //As prop2 is ordered before prop1 its regEx is evaluated first //hence even with a specific regex of foo.* the defn used is from .* assertEquals(4.0f, rule1.getConfig("fooProp").boost, 0); //Order it correctly to get expected result rules.child("nt:folder").child(PROP_NODE).setProperty(OAK_CHILD_ORDER, ImmutableList.of("prop1", "prop2"), NAMES); defn = new LuceneIndexDefinition(root, builder.getNodeState(), "/foo"); rule1 = defn.getApplicableIndexingRule(asState(newNode("nt:folder"))); assertEquals(3.0f, rule1.getConfig("fooProp").boost, 0); }
@Test public void indexRuleWithPropertyOrdering() throws Exception{ NodeBuilder rules = builder.child(INDEX_RULES); rules.child("nt:folder"); TestUtil.child(rules, "nt:folder/properties/prop1") .setProperty(PROP_NAME, "foo.*") .setProperty(FulltextIndexConstants.PROP_IS_REGEX, true) .setProperty(FulltextIndexConstants.FIELD_BOOST, 3.0); TestUtil.child(rules, "nt:folder/properties/prop2") .setProperty(PROP_NAME, ".*") .setProperty(FulltextIndexConstants.PROP_IS_REGEX, true) .setProperty(FulltextIndexConstants.FIELD_BOOST, 4.0); rules.child("nt:folder").child(PROP_NODE).setProperty(OAK_CHILD_ORDER, ImmutableList.of("prop2", "prop1"), NAMES); IndexDefinition defn = new IndexDefinition(root, builder.getNodeState(), "/foo"); IndexingRule rule1 = defn.getApplicableIndexingRule(asState(newNode("nt:folder"))); assertNotNull(rule1); assertTrue(rule1.isIndexed("prop1")); assertTrue(rule1.isIndexed("fooProp")); assertEquals(4.0f, rule1.getConfig("bazProp2").boost, 0); //As prop2 is ordered before prop1 its regEx is evaluated first //hence even with a specific regex of foo.* the defn used is from .* assertEquals(4.0f, rule1.getConfig("fooProp").boost, 0); //Order it correctly to get expected result rules.child("nt:folder").child(PROP_NODE).setProperty(OAK_CHILD_ORDER, ImmutableList.of("prop1", "prop2"), NAMES); defn = new IndexDefinition(root, builder.getNodeState(), "/foo"); rule1 = defn.getApplicableIndexingRule(asState(newNode("nt:folder"))); assertEquals(3.0f, rule1.getConfig("fooProp").boost, 0); }
private void propertyUpdated(PropertyState before, PropertyState after) { PropertyUpdateCallback callback = context.getPropertyUpdateCallback(); //Avoid further work if no callback is present if (callback == null) { return; } String propertyName = before != null ? before.getName() : after.getName(); if (isIndexable()) { PropertyDefinition pd = indexingRule.getConfig(propertyName); if (pd != null) { callback.propertyUpdated(getPath(), propertyName, pd, before, after); } } for (Matcher m : matcherState.matched) { if (m.aggregatesProperty(propertyName)) { Aggregate.Include i = m.getCurrentInclude(); if (i instanceof Aggregate.PropertyInclude) { PropertyDefinition pd = ((Aggregate.PropertyInclude) i).getPropertyDefinition(); String propertyRelativePath = PathUtils.concat(m.getMatchedPath(), propertyName); callback.propertyUpdated(m.getRootPath(), propertyRelativePath, pd, before, after); } } } }
@Test public void regexAllProps() { IndexDefinitionBuilder builder = new IndexDefinitionBuilder(); builder.indexRule("nt:base").property("p"); builder.indexRule("nt:base").property("all", FulltextIndexConstants.REGEX_ALL_PROPS, true); IndexDefinition def = IndexDefinition.newBuilder(root, builder.build(), "/foo").build(); IndexingRule rule = def.getApplicableIndexingRule(root); assertNotNull(rule); PropertyDefinition pd = rule.getConfig("p"); assertNotNull(pd); assertFalse(pd.isRegexp); assertFalse(pd.relative); assertEquals(0, pd.ancestors.length); pd = rule.getConfig("all"); assertNotNull(pd); assertTrue(pd.isRegexp); assertFalse(pd.relative); assertEquals(0, pd.ancestors.length); assertThat(rule.getAggregate().getIncludes(), is(empty())); assertFalse(rule.getAggregate().hasNodeAggregates()); List<Aggregate.Matcher> matchers = rule.getAggregate() .createMatchers(new TestRoot("/")); assertThat(matchers, is(empty())); assertThat(def.getRelativeNodeNames(), is(empty())); }