diff --git a/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/BenchmarkRunner.java b/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/BenchmarkRunner.java
index 7c2d187..d120847
--- a/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/BenchmarkRunner.java
+++ b/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/BenchmarkRunner.java
@@ -137,6 +137,7 @@ public class BenchmarkRunner {
                         dropDBAfterTest.value(options), cacheSize * MB)
                         };
         Benchmark[] allBenchmarks = new Benchmark[] {
+            new PropertyIndexQueryTest(),
             new OrderedIndexQueryOrderedIndexTest(),
             new OrderedIndexQueryStandardIndexTest(),
             new OrderedIndexQueryNoIndexTest(),
diff --git a/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/PropertyIndexQueryTest.java b/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/PropertyIndexQueryTest.java
new file mode 100644
index 0000000..00ea03c
--- /dev/null
+++ b/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/PropertyIndexQueryTest.java
@@ -0,0 +1,206 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.jackrabbit.oak.benchmark;
+
+import org.apache.jackrabbit.oak.benchmark.util.OakIndexUtils;
+import org.apache.jackrabbit.oak.commons.PathUtils;
+import org.apache.jackrabbit.oak.plugins.index.IndexConstants;
+import org.apache.jackrabbit.oak.plugins.index.property.PropertyIndexEditorProvider;
+import org.apache.jackrabbit.oak.plugins.nodetype.NodeTypeConstants;
+
+import javax.jcr.*;
+import javax.jcr.query.Query;
+import javax.jcr.query.QueryManager;
+import javax.jcr.query.QueryResult;
+import java.util.UUID;
+
+/**
+ * Benchmark the query performance of property=value restriction with path restriction
+ */
+public class PropertyIndexQueryTest extends AbstractTest {
+    /**
+     * number of nodes that has to be added before performing the actual test
+     */
+    static final int PRE_ADDED_NODES = Integer.parseInt(System.getProperty("preAddedNodes", "10000"));
+
+    /**
+     * max depth of randomly created tree
+     */
+    static final int PRE_ADDED_NODES_DEPTH = Integer.parseInt(System.getProperty("preAddedNodesDepth", "5"));
+
+    /**
+     * max num of branches for randomly created tree
+     */
+    static final int PRE_ADDED_NODES_WIDTH = Integer.parseInt(System.getProperty("preAddedNodesWidth", "5"));
+
+    /**
+     * type of the created node
+     */
+    static final String NODE_TYPE = NodeTypeConstants.NT_OAK_UNSTRUCTURED;
+
+    /**
+     * property that will be indexed
+     */
+    static final String INDEXED_PROPERTY = "indexedProperty";
+
+
+    /**
+     * max different values of indexed property
+     */
+    static final int NUM_UNIQUE_INDEXED_VALUES = Integer.parseInt(System.getProperty("numUniqueIndexedValues", "5"));
+
+    /**
+     * size of the batch for saving
+     */
+    static final int BATCH_SAVING_SIZE = Integer
+            .parseInt(System.getProperty("batchSaving", "1024"));
+
+    /**
+     * flags whether batch saving or not. Provide {@code -DbatchSaving=XYZ} where {@code XYZ} is
+     * greater than 0 to enable batch saving otherwise it will save every added nodes.
+     */
+    static final boolean BATCH_SAVING = BATCH_SAVING_SIZE > 0;
+
+    /**
+     * node name below which creating the test data
+     */
+    final String DUMP_NODE = this.getClass().getSimpleName() + TEST_ID;
+
+    /**
+     * session used for operations throughout the test
+     */
+    Session session;
+
+    /**
+     * node under which all the test data will be filled in
+     */
+    Node dump;
+
+    Node index;
+
+    boolean isBatchSaving() {
+        return BATCH_SAVING;
+    }
+
+    Node getRandomParent(Node root) throws RepositoryException {
+        Node parent = root;
+        int depth = (int)Math.floor(Math.random()*PRE_ADDED_NODES_DEPTH) + 1;
+
+        for(int i=0; i<depth; i++) {
+            String parentId = String.valueOf((int)(Math.floor(Math.random()*PRE_ADDED_NODES_WIDTH) + 1));
+            try {
+                parent = parent.getNode(parentId);
+            } catch (PathNotFoundException pne) {
+                parent = parent.addNode(parentId, NODE_TYPE);
+            }
+        }
+
+        return parent;
+    }
+
+    String getRandomPropertyValue() {
+        int uniqueValue = (int)Math.floor(Math.random()*NUM_UNIQUE_INDEXED_VALUES) + 1;
+        return String.valueOf(uniqueValue);
+    }
+
+    /**
+     * insert a {@code numberOfNode} random nodes in the repository with random parent hierarcy
+     * according to {@link #PRE_ADDED_NODES_DEPTH} and {@link #PRE_ADDED_NODES_WIDTH}. The property
+     * value is randomly picked according to {@link #NUM_UNIQUE_INDEXED_VALUES}
+     *
+     * @param numberOfNodes
+     */
+    void insertRandomNodes(int numberOfNodes) {
+        try {
+            for (int i = 0; i < numberOfNodes; i++) {
+                String uuid = UUID.randomUUID().toString();
+                Node parent = getRandomParent(dump);
+                parent.addNode(uuid, NODE_TYPE).setProperty(INDEXED_PROPERTY, getRandomPropertyValue());
+                if (isBatchSaving()) {
+                    if (i % BATCH_SAVING_SIZE == 0) {
+                        session.save();
+                    }
+                } else {
+                    session.save();
+                }
+            }
+            if (isBatchSaving()) {
+                // an extra save to catch any pending operations.
+                session.save();
+            }
+        } catch (RepositoryException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    Node defineStandardPropertyIndex(Session session) throws Exception {
+        Node index = new OakIndexUtils.PropertyIndex().property(INDEXED_PROPERTY).create(session);
+        if (index == null) {
+            throw new RuntimeException(
+                    "Error while creating the index definition. index node is null.");
+        }
+        if (!PropertyIndexEditorProvider.TYPE.equals(index.getProperty(
+                IndexConstants.TYPE_PROPERTY_NAME).getString())) {
+            throw new RuntimeException("The type of the index does not match the expected");
+        }
+        session.save();
+        return index;
+    }
+
+    void defineIndex() throws Exception {
+        index = defineStandardPropertyIndex(session);
+    }
+
+    @Override
+    protected void beforeSuite() throws Exception {
+        session = loginWriter();
+        dump = session.getRootNode().addNode(DUMP_NODE, NODE_TYPE);
+        session.save();
+        defineIndex();
+        insertRandomNodes(PRE_ADDED_NODES);
+    }
+
+    @Override
+    protected void afterSuite() throws Exception {
+        dump.remove();
+        if(index!=null) {
+            index.remove();
+        }
+        session.save();
+        session.logout();
+    }
+
+    String getQuery() throws RepositoryException {
+        String queryValue = getRandomPropertyValue();
+        String queryParent = getRandomParent(dump).getPath();
+        final String QUERY = String.format(
+                "SELECT * FROM [%s] WHERE %s='%s' AND ISDESCENDANTNODE([%s])", NODE_TYPE, INDEXED_PROPERTY, queryValue, queryParent);
+
+        return QUERY;
+    }
+
+    @Override
+    protected void runTest() throws Exception {
+        QueryManager qm = session.getWorkspace().getQueryManager();
+        Query q = qm.createQuery(getQuery(), Query.JCR_SQL2);
+        QueryResult r = q.execute();
+        NodeIterator nodes = r.getNodes();
+        while(nodes.hasNext()) {
+            nodes.next();
+        }
+    }
+}