diff --git oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/Aggregate.java oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/Aggregate.java
index fa5728b..5d3baf7 100644
--- oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/Aggregate.java
+++ oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/Aggregate.java
@@ -19,6 +19,7 @@
 
 package org.apache.jackrabbit.oak.plugins.index.lucene;
 
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
@@ -33,6 +34,7 @@ import com.google.common.collect.Lists;
 import org.apache.jackrabbit.oak.api.PropertyState;
 import org.apache.jackrabbit.oak.commons.PathUtils;
 import org.apache.jackrabbit.oak.plugins.index.lucene.util.ConfigUtil;
+import org.apache.jackrabbit.oak.plugins.memory.MemoryChildNodeEntry;
 import org.apache.jackrabbit.oak.spi.state.ChildNodeEntry;
 import org.apache.jackrabbit.oak.spi.state.NodeState;
 
@@ -125,7 +127,34 @@ class Aggregate {
 
     private static void collectAggregates(NodeState nodeState, List<Matcher> matchers,
                                           ResultCollector collector) {
-        for (ChildNodeEntry cne : nodeState.getChildNodeEntries()) {
+        if (hasPatternMatcher(matchers)){
+            collectAggregatesForPatternMatchers(nodeState, matchers, collector);
+        } else {
+            collectAggregatesForDirectMatchers(nodeState, matchers, collector);
+        }
+    }
+
+    private static void collectAggregatesForDirectMatchers(NodeState nodeState, List<Matcher> matchers,
+                                          ResultCollector collector) {
+        List<ChildNodeEntry> entries = Lists.newArrayList();
+        for (Matcher m : matchers){
+            String nodeName = m.getNodeName();
+            NodeState child = nodeState.getChildNode(nodeName);
+            if (child.exists()){
+                entries.add(new MemoryChildNodeEntry(nodeName, child));
+            }
+        }
+        matchChildren(matchers, collector, entries);
+    }
+
+    private static void collectAggregatesForPatternMatchers(NodeState nodeState, List<Matcher> matchers,
+                                          ResultCollector collector) {
+        matchChildren(matchers, collector, nodeState.getChildNodeEntries());
+    }
+
+    private static void matchChildren(List<Matcher> matchers, ResultCollector collector,
+                                      Iterable<? extends ChildNodeEntry> children) {
+        for (ChildNodeEntry cne : children) {
             List<Matcher> nextSet = newArrayListWithCapacity(matchers.size());
             for (Matcher m : matchers) {
                 Matcher result = m.match(cne.getName(), cne.getNodeState());
@@ -143,6 +172,15 @@ class Aggregate {
         }
     }
 
+    private static boolean hasPatternMatcher(List<Matcher> matchers){
+        for (Matcher m : matchers){
+            if (m.isPatternBased()){
+                return true;
+            }
+        }
+        return false;
+    }
+
     private List<Matcher> createMatchers() {
         List<Matcher> matchers = newArrayListWithCapacity(includes.size());
         for (Include include : includes) {
@@ -217,6 +255,17 @@ class Aggregate {
         public Aggregate getAggregate(NodeState matchedNodeState) {
             return null;
         }
+
+        public boolean isPattern(int depth){
+            return MATCH_ALL.equals(elements[depth]);
+
+        }
+
+        public String getElementNameIfNotAPattern(int depth) {
+            checkArgument(!isPattern(depth),
+                    "Element at %s is pattern instead of specific name in %s", depth, Arrays.toString(elements));
+            return elements[depth];
+        }
     }
 
     public static class NodeInclude extends Include<NodeInclude> {
@@ -410,12 +459,12 @@ class Aggregate {
         }
     }
 
-    public static interface AggregateRoot {
+    public interface AggregateRoot {
         void markDirty();
     }
 
     public static class Matcher {
-        public static enum Status {CONTINUE, MATCH_FOUND, FAIL}
+        public enum Status {CONTINUE, MATCH_FOUND, FAIL}
 
         private static class RootState {
             final AggregateRoot root;
@@ -492,6 +541,14 @@ class Aggregate {
             this.aggregateStack = ImmutableList.copyOf(paths);
         }
 
+        public boolean isPatternBased() {
+            return currentInclude.isPattern(depth);
+        }
+
+        public String getNodeName() {
+            return currentInclude.getElementNameIfNotAPattern(depth);
+        }
+
         public Matcher match(String name, NodeState nodeState) {
             boolean result = currentInclude.match(name, nodeState, depth);
             if (result){
diff --git oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/AggregateTest.java oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/AggregateTest.java
index 40040ca..67c5131 100644
--- oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/AggregateTest.java
+++ oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/AggregateTest.java
@@ -98,7 +98,6 @@ public class AggregateTest {
         assertThat(col.getNodePaths(), hasItems("a"));
     }
 
-    @Ignore("OAK-5448")
     @Test
     public void noOfChildNodeRead() throws Exception{
         Aggregate ag = new Aggregate("nt:base", of(ni("a")));