diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c
index 2328b92..9c15bc9 100644
--- a/src/backend/catalog/index.c
+++ b/src/backend/catalog/index.c
@@ -41,6 +41,7 @@
 #include "catalog/pg_collation.h"
 #include "catalog/pg_constraint.h"
 #include "catalog/pg_constraint_fn.h"
+#include "catalog/pg_depend.h"
 #include "catalog/pg_operator.h"
 #include "catalog/pg_opclass.h"
 #include "catalog/pg_tablespace.h"
@@ -849,17 +850,33 @@ index_create(Relation heapRelation,
 	 * we fail further down, it's the smgr's responsibility to remove the disk
 	 * file again.)
 	 */
-	indexRelation = heap_create(indexRelationName,
-								namespaceId,
-								tableSpaceId,
-								indexRelationId,
-								relFileNode,
-								indexTupDesc,
-								RELKIND_INDEX,
-								relpersistence,
-								shared_relation,
-								mapped_relation,
-								allow_system_table_mods);
+	if (heapRelation->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
+		indexRelation = heap_create(indexRelationName,
+									namespaceId,
+									tableSpaceId,
+									indexRelationId,
+									relFileNode,
+									indexTupDesc,
+									RELKIND_INDEX,
+									relpersistence,
+									shared_relation,
+									mapped_relation,
+									allow_system_table_mods);
+	else
+		indexRelation =
+			RelationBuildLocalRelation(indexRelationName,
+									   namespaceId,
+									   indexTupDesc,
+									   indexRelationId,
+									   (OidIsValid(relFileNode)) ?
+										relFileNode : indexRelationId,
+									   (tableSpaceId == MyDatabaseTableSpace) ?
+										InvalidOid : tableSpaceId,
+									   shared_relation,
+									   mapped_relation,
+									   relpersistence,
+									   RELKIND_INDEX);
+
 
 	Assert(indexRelationId == RelationGetRelid(indexRelation));
 
@@ -1549,10 +1566,14 @@ index_drop(Oid indexId, bool concurrent)
 		TransferPredicateLocksToHeapRelation(userIndexRelation);
 	}
 
-	/*
-	 * Schedule physical removal of the files
-	 */
-	RelationDropStorage(userIndexRelation);
+	if (userHeapRelation->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
+	{
+
+		/*
+		 * Schedule physical removal of the files
+		 */
+		RelationDropStorage(userIndexRelation);
+	}
 
 	/*
 	 * Close and flush the index's relcache entry, to ensure relcache doesn't
@@ -3294,6 +3315,111 @@ IndexGetRelation(Oid indexId, bool missing_ok)
 }
 
 /*
+ * Find all leaf indexes included into local index with 'indexId' oid and lock
+ * all dependent indexes and respective relations.
+ *
+ * Search is performed in pg_depend table since all indexes belonging to child
+ * tables depends on index from parent table.
+ *
+ *	indexId: the oid of local index whose leaf indexes need to find
+ *	result: list of result leaf indexes
+ *	depRel: already opened pg_depend relation
+ *	indexLockmode: lockmode for indexes' locks
+ *	heapLockmode: lockmode for relations' locks
+ */
+static void
+findDepedentLeafIndexes(Oid indexId, List **result, Relation depRel,
+						LOCKMODE indexLockmode, LOCKMODE heapLockmode)
+{
+	ScanKeyData 		key[3];
+	int					nkeys;
+	SysScanDesc 		scan;
+	HeapTuple			tup;
+	List			   *localSubIndexIds = NIL;
+	ListCell		   *lc;
+
+	ScanKeyInit(&key[0],
+				Anum_pg_depend_refclassid,
+				BTEqualStrategyNumber, F_OIDEQ,
+				ObjectIdGetDatum(RelationRelationId));
+	ScanKeyInit(&key[1],
+				Anum_pg_depend_refobjid,
+				BTEqualStrategyNumber, F_OIDEQ,
+				ObjectIdGetDatum(indexId));
+	nkeys = 2;
+
+	scan = systable_beginscan(depRel, DependReferenceIndexId, true,
+							  NULL, nkeys, key);
+
+	while (HeapTupleIsValid(tup = systable_getnext(scan)))
+	{
+		Form_pg_depend 	foundDep = (Form_pg_depend) GETSTRUCT(tup);
+		Relation		index,
+						heap;
+
+		if (foundDep->classid != RelationRelationId)
+			continue;
+
+		/* Open and lock child index */
+		index = relation_open(foundDep->objid, indexLockmode);
+
+		/* Open and lock relation */
+		heap = relation_open(IndexGetRelation(index->rd_id, false), heapLockmode);
+
+		if (index->rd_rel->relkind == RELKIND_INDEX)
+			*result = lappend_oid(*result, index->rd_id);
+		else if (heap->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+			localSubIndexIds = lappend_oid(localSubIndexIds, index->rd_id);
+
+		relation_close(heap, NoLock);
+		relation_close(index, NoLock);
+	}
+
+	systable_endscan(scan);
+
+	/* Iterate thorugh local subindexes to extract their leaf indexes */
+	foreach(lc, localSubIndexIds)
+	{
+		findDepedentLeafIndexes(lfirst_oid(lc), result, depRel, indexLockmode,
+								heapLockmode);
+	}
+}
+
+/*
+ * Reindex all real indexes included into local index with 'parent_index_id' oid
+ */
+static void
+reindex_local_index(Oid parent_index_id, bool skip_constraint_checks,
+					char persistence, int options)
+{
+	List	   *leaf_indexes = NIL;
+	ListCell   *lc;
+	Relation 	deprel;
+
+	/*
+	 * We open pg_depend just once and passing the Relation pointer down to all
+	 * the recursive searching of leaf indexes steps.
+	 */
+	deprel = heap_open(DependRelationId, AccessShareLock);
+
+	/*
+	 * Extract all leaf indexes, and lock all indexes belonging with parent
+	 * local index using AccessExclusive lock and corresponding relations using
+	 * Share lock
+	 */
+	findDepedentLeafIndexes(parent_index_id, &leaf_indexes, deprel,
+							AccessExclusiveLock, ShareLock);
+
+	foreach(lc, leaf_indexes)
+	{
+		reindex_index(lfirst_oid(lc), skip_constraint_checks, persistence,
+					  options);
+	}
+
+	heap_close(deprel, AccessShareLock);
+}
+
+/*
  * reindex_index - This routine is used to recreate a single index
  */
 void
@@ -3332,6 +3458,19 @@ reindex_index(Oid indexId, bool skip_constraint_checks, char persistence,
 			   errmsg("cannot reindex temporary tables of other sessions")));
 
 	/*
+	 * Reindex local index belonging to partitioned table
+	 */
+	if (heapRelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+	{
+		index_close(iRel, NoLock);
+		heap_close(heapRelation, NoLock);
+
+		reindex_local_index(indexId, skipped_constraint, persistence, options);
+
+		return;
+	}
+
+	/*
 	 * Also check for active uses of the index in the current transaction; we
 	 * don't want to reindex underneath an open indexscan.
 	 */
diff --git a/src/backend/commands/indexcmds.c b/src/backend/commands/indexcmds.c
index 4861799..af96bdb 100644
--- a/src/backend/commands/indexcmds.c
+++ b/src/backend/commands/indexcmds.c
@@ -23,7 +23,9 @@
 #include "catalog/catalog.h"
 #include "catalog/index.h"
 #include "catalog/indexing.h"
+#include "catalog/partition.h"
 #include "catalog/pg_am.h"
+#include "catalog/pg_inherits_fn.h"
 #include "catalog/pg_opclass.h"
 #include "catalog/pg_opfamily.h"
 #include "catalog/pg_tablespace.h"
@@ -283,6 +285,30 @@ CheckIndexCompatible(Oid oldId,
 	return ret;
 }
 
+#define PUSH_REL_PARTITION_OIDS(rel, part_oids, rel_index_oid, \
+								parent_index_oids) \
+		do\
+		{\
+			if (RelationGetPartitionDesc((rel)))\
+			{\
+				int		i;\
+				for (i = 0; i < (rel)->rd_partdesc->nparts; ++i)\
+				{\
+					(part_oids) = lcons_oid((rel)->rd_partdesc->oids[i],\
+							(part_oids));\
+					(parent_index_oids) = lcons_oid((rel_index_oid),\
+							(parent_index_oids));\
+				}\
+			}\
+		} while(0)
+
+#define POP_REL_PARTITION_OIDS(part_oids, parent_index_oids) \
+		do\
+		{\
+			(part_oids) = list_delete_first((part_oids));\
+			(parent_index_oids) = list_delete_first((parent_index_oids));\
+		} while(0)
+
 /*
  * DefineIndex
  *		Creates a new index.
@@ -372,7 +398,8 @@ DefineIndex(Oid relationId,
 	namespaceId = RelationGetNamespace(rel);
 
 	if (rel->rd_rel->relkind != RELKIND_RELATION &&
-		rel->rd_rel->relkind != RELKIND_MATVIEW)
+		rel->rd_rel->relkind != RELKIND_MATVIEW &&
+		rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
 	{
 		if (rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
 
@@ -384,11 +411,6 @@ DefineIndex(Oid relationId,
 					(errcode(ERRCODE_WRONG_OBJECT_TYPE),
 					 errmsg("cannot create index on foreign table \"%s\"",
 							RelationGetRelationName(rel))));
-		else if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
-			ereport(ERROR,
-					(errcode(ERRCODE_WRONG_OBJECT_TYPE),
-					 errmsg("cannot create index on partitioned table \"%s\"",
-							RelationGetRelationName(rel))));
 		else
 			ereport(ERROR,
 					(errcode(ERRCODE_WRONG_OBJECT_TYPE),
@@ -396,6 +418,12 @@ DefineIndex(Oid relationId,
 							RelationGetRelationName(rel))));
 	}
 
+	if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE && stmt->concurrent)
+		ereport(ERROR,
+				(errcode(ERRCODE_WRONG_OBJECT_TYPE),
+				 errmsg("cannot create local index on partitioned table \"%s\" concurrently",
+					 RelationGetRelationName(rel))));
+
 	/*
 	 * Don't try to CREATE INDEX on temp tables of other backends.
 	 */
@@ -660,7 +688,8 @@ DefineIndex(Oid relationId,
 					 coloptions, reloptions, stmt->primary,
 					 stmt->isconstraint, stmt->deferrable, stmt->initdeferred,
 					 allowSystemTableMods,
-					 skip_build || stmt->concurrent,
+					 skip_build || stmt->concurrent ||
+						rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE,
 					 stmt->concurrent, !check_rights,
 					 stmt->if_not_exists);
 
@@ -677,8 +706,89 @@ DefineIndex(Oid relationId,
 		CreateComments(indexRelationId, RelationRelationId, 0,
 					   stmt->idxcomment);
 
+	/*
+	 * Create local index on partitioned table that comes down to creating of
+	 * indexes on child relations using depth-first traversal
+	 */
+	if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+	{
+
+		List   *part_oids = NIL,			/* stack for concerned partion oids */
+			   *parent_index_oids = NIL;	/* stack for corresponding parent
+											   index oids */
+
+		Assert(!stmt->concurrent);
+
+		/*
+		 * Initially push child oids of current relation and related
+		 * parent index oids
+		 */
+		PUSH_REL_PARTITION_OIDS(rel, part_oids, indexRelationId,
+				parent_index_oids);
+
+		while (list_length(part_oids) > 0)
+		{
+			Relation	childrel;
+			Oid			parent_index_oid,
+						child_index_oid;
+			ObjectAddress	index_address,
+							parent_index_address;
+			char	   *child_index_name;
+
+			/* Extract top child relation and related parent index oid from stacks */
+			childrel = relation_open(linitial_oid(part_oids), lockmode);
+			parent_index_oid = linitial_oid(parent_index_oids);
+
+			/* Choose name for child index */
+			child_index_name =
+				ChooseIndexName(RelationGetRelationName(childrel),
+						namespaceId, indexColNames,
+						stmt->excludeOpNames, stmt->primary,
+						stmt->isconstraint);
+
+			/* Create index for child node */
+			child_index_oid =
+				index_create(childrel, child_index_name, InvalidOid,
+						InvalidOid, indexInfo, indexColNames,
+						accessMethodId, tablespaceId,
+						collationObjectId, classObjectId,
+						coloptions, reloptions, stmt->primary,
+						stmt->isconstraint, stmt->deferrable,
+						stmt->initdeferred, allowSystemTableMods,
+						skip_build || childrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE,
+						stmt->concurrent, !check_rights,
+						stmt->if_not_exists);
+
+			/* Pop current reloid and related parent index oid from stacks */
+			POP_REL_PARTITION_OIDS(part_oids, parent_index_oids);
+
+			/*
+			 * Push new childs of current child relation and
+			 * related parent indexes to stacks
+			 */
+			PUSH_REL_PARTITION_OIDS(childrel, part_oids, child_index_oid,
+					parent_index_oids);
+
+			/* Release relcache entry from childrel */
+			relation_close(childrel, NoLock);
+
+			/*
+			 * Add entry to pg_depend to specify dependancy child index
+			 * from parent one
+			 */
+			ObjectAddressSet(index_address, RelationRelationId,
+					child_index_oid);
+			ObjectAddressSet(parent_index_address, RelationRelationId,
+					parent_index_oid);
+			recordDependencyOn(&index_address, &parent_index_address,
+					DEPENDENCY_NORMAL);
+		}
+	}
+
+
 	if (!stmt->concurrent)
 	{
+
 		/* Close the heap and we're done, in the non-concurrent case */
 		heap_close(rel, NoLock);
 		return address;
