diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index b019bc1..ab95fcc 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -299,6 +299,7 @@ initscan(HeapScanDesc scan, ScanKey key, bool keep_startblock)
 	ItemPointerSetInvalid(&scan->rs_ctup.t_self);
 	scan->rs_cbuf = InvalidBuffer;
 	scan->rs_cblock = InvalidBlockNumber;
+	scan->rs_scanslot = NULL;
 
 	/* page-at-a-time fields are always invalid when not rs_inited */
 
@@ -660,7 +661,8 @@ heapgettup(HeapScanDesc scan,
 
 				if (valid && key != NULL)
 					HeapKeyTest(tuple, RelationGetDescr(scan->rs_rd),
-								nkeys, key, valid);
+							NULL, 0, NULL,
+							nkeys, key, valid);
 
 				if (valid)
 				{
@@ -955,7 +957,9 @@ heapgettup_pagemode(HeapScanDesc scan,
 				bool		valid;
 
 				HeapKeyTest(tuple, RelationGetDescr(scan->rs_rd),
-							nkeys, key, valid);
+						scan->rs_scanslot, scan->rs_cbuf,
+						scan->per_tuple_context,
+						nkeys, key, valid);
 				if (valid)
 				{
 					scan->rs_cindex = lineindex;
@@ -1649,7 +1653,8 @@ heap_parallelscan_initialize(ParallelHeapScanDesc target, Relation relation,
  * ----------------
  */
 HeapScanDesc
-heap_beginscan_parallel(Relation relation, ParallelHeapScanDesc parallel_scan)
+heap_beginscan_parallel(Relation relation, ParallelHeapScanDesc parallel_scan,
+						int nkeys, ScanKey key)
 {
 	Snapshot	snapshot;
 
@@ -1657,7 +1662,7 @@ heap_beginscan_parallel(Relation relation, ParallelHeapScanDesc parallel_scan)
 	snapshot = RestoreSnapshot(parallel_scan->phs_snapshot_data);
 	RegisterSnapshot(snapshot);
 
-	return heap_beginscan_internal(relation, snapshot, 0, NULL, parallel_scan,
+	return heap_beginscan_internal(relation, snapshot, nkeys, key, parallel_scan,
 								   true, true, true, false, false, true);
 }
 
diff --git a/src/backend/executor/execScan.c b/src/backend/executor/execScan.c
index fb0013d..3a12ec4 100644
--- a/src/backend/executor/execScan.c
+++ b/src/backend/executor/execScan.c
@@ -205,7 +205,7 @@ ExecScan(ScanState *node,
 		 * when the qual is nil ... saves only a few cycles, but they add up
 		 * ...
 		 */
-		if (!qual || ExecQual(qual, econtext, false))
+		if (!node->ps.qual || ExecQual(node->ps.qual, econtext, false))
 		{
 			/*
 			 * Found a satisfactory scan tuple.
diff --git a/src/backend/executor/nodeSeqscan.c b/src/backend/executor/nodeSeqscan.c
index 00bf3a5..695958f 100644
--- a/src/backend/executor/nodeSeqscan.c
+++ b/src/backend/executor/nodeSeqscan.c
@@ -30,9 +30,14 @@
 #include "executor/execdebug.h"
 #include "executor/nodeSeqscan.h"
 #include "utils/rel.h"
+#include "optimizer/clauses.h"
+#include "executor/executor.h"
+#include "access/valid.h"
 
 static void InitScanRelation(SeqScanState *node, EState *estate, int eflags);
 static TupleTableSlot *SeqNext(SeqScanState *node);
+static void get_scankey_from_qual(TupleDesc tupDesc, List *qual, PlanState *ps,
+							int *nkeys, ScanKey *rs_keys);
 
 /* ----------------------------------------------------------------
  *						Scan Support
@@ -53,6 +58,9 @@ SeqNext(SeqScanState *node)
 	EState	   *estate;
 	ScanDirection direction;
 	TupleTableSlot *slot;
+	int 		 nkeys = 0;
+	ScanKey		 keys = NULL;
+	bool		valid = false;
 
 	/*
 	 * get information from the estate and scan state
@@ -65,36 +73,76 @@ SeqNext(SeqScanState *node)
 	if (scandesc == NULL)
 	{
 		/*
+		 * Pull out scan key from qual list
+		 */
+		get_scankey_from_qual(RelationGetDescr(node->ss.ss_currentRelation),
+							 node->ss.ps.plan->qual, &node->ss.ps,
+							 &nkeys, &keys);
+
+		/*
 		 * We reach here if the scan is not parallel, or if we're executing a
 		 * scan that was intended to be parallel serially.
 		 */
 		scandesc = heap_beginscan(node->ss.ss_currentRelation,
 								  estate->es_snapshot,
 								  0, NULL);
+
+		node->ss.nkey = nkeys;
+		node->ss.keys = keys;
+
+
 		node->ss.ss_currentScanDesc = scandesc;
 	}
 
-	/*
-	 * get the next tuple from the table
-	 */
-	tuple = heap_getnext(scandesc, direction);
+	for (;;)
+	{
+		/*
+		 * get the next tuple from the table
+		 */
+		tuple = heap_getnext(scandesc, direction);
 
-	/*
-	 * save the tuple and the buffer returned to us by the access methods in
-	 * our scan tuple slot and return the slot.  Note: we pass 'false' because
-	 * tuples returned by heap_getnext() are pointers onto disk pages and were
-	 * not created with palloc() and so should not be pfree()'d.  Note also
-	 * that ExecStoreTuple will increment the refcount of the buffer; the
-	 * refcount will not be dropped until the tuple table slot is cleared.
-	 */
-	if (tuple)
-		ExecStoreTuple(tuple,	/* tuple to store */
-					   slot,	/* slot to store in */
-					   scandesc->rs_cbuf,		/* buffer associated with this
-												 * tuple */
-					   false);	/* don't pfree this pointer */
-	else
-		ExecClearTuple(slot);
+		/*
+		 * save the tuple and the buffer returned to us by the access methods in
+		 * our scan tuple slot and return the slot.  Note: we pass 'false' because
+		 * tuples returned by heap_getnext() are pointers onto disk pages and were
+		 * not created with palloc() and so should not be pfree()'d.  Note also
+		 * that ExecStoreTuple will increment the refcount of the buffer; the
+		 * refcount will not be dropped until the tuple table slot is cleared.
+		 *
+		 * If scandesc have valid scanslot means we would have already stored
+		 * tuple in slot, so no need to do it again.
+		 */
+		if (tuple)
+			ExecStoreTuple(tuple,	/* tuple to store */
+						   slot,	/* slot to store in */
+						   scandesc->rs_cbuf,		/* buffer associated with this
+													 * tuple */
+						   false);	/* don't pfree this pointer */
+		else
+			ExecClearTuple(slot);
+
+		if (tuple)
+		{
+			MemoryContext oldctx;
+
+			oldctx = MemoryContextSwitchTo(node->ss.ps.ps_ExprContext->ecxt_per_tuple_memory);
+			HeapKeyTest(tuple, RelationGetDescr(node->ss.ss_currentRelation),
+					slot, scandesc->rs_cbuf, NULL,
+					node->ss.nkey, node->ss.keys, valid);
+			if (valid != true)
+			{
+				MemoryContextSwitchTo(oldctx);
+				MemoryContextReset(node->ss.ps.ps_ExprContext->ecxt_per_tuple_memory);
+				continue;
+			}
+
+			MemoryContextSwitchTo(oldctx);
+
+			return slot;
+		}
+		else
+			break;
+	}
 
 	return slot;
 }
@@ -317,14 +365,24 @@ ExecSeqScanInitializeDSM(SeqScanState *node,
 {
 	EState	   *estate = node->ss.ps.state;
 	ParallelHeapScanDesc pscan;
+	int					 nkeys = 0;
+	ScanKey				 keys = NULL;
+
+	/*
+	 * Pull out scan key from qual list
+	 */
+	get_scankey_from_qual(RelationGetDescr(node->ss.ss_currentRelation),
+						 node->ss.ps.plan->qual, &node->ss.ps,
+						 &nkeys, &keys);
 
 	pscan = shm_toc_allocate(pcxt->toc, node->pscan_len);
 	heap_parallelscan_initialize(pscan,
 								 node->ss.ss_currentRelation,
 								 estate->es_snapshot);
 	shm_toc_insert(pcxt->toc, node->ss.ps.plan->plan_node_id, pscan);
-	node->ss.ss_currentScanDesc =
-		heap_beginscan_parallel(node->ss.ss_currentRelation, pscan);
+	node->ss.ss_currentScanDesc = heap_beginscan_parallel(
+										node->ss.ss_currentRelation, pscan,
+										nkeys, keys);
 }
 
 /* ----------------------------------------------------------------
@@ -337,8 +395,129 @@ void
 ExecSeqScanInitializeWorker(SeqScanState *node, shm_toc *toc)
 {
 	ParallelHeapScanDesc pscan;
+	int					 nkeys = 0;
+	ScanKey				 keys = NULL;
 
 	pscan = shm_toc_lookup(toc, node->ss.ps.plan->plan_node_id);
-	node->ss.ss_currentScanDesc =
-		heap_beginscan_parallel(node->ss.ss_currentRelation, pscan);
+
+	/*
+	 * Pull out scan key from qual list
+	 */
+	get_scankey_from_qual(RelationGetDescr(node->ss.ss_currentRelation),
+						 node->ss.ps.plan->qual, &node->ss.ps,
+						 &nkeys, &keys);
+
+	node->ss.ss_currentScanDesc = heap_beginscan_parallel(
+										node->ss.ss_currentRelation, pscan,
+										nkeys, keys);
+}
+
+/*
+ * get_scankey_from_qual
+ *
+ * process complete QUAL list and create scankey entry for pushable quals.
+ *
+ * quals which can be pushed down:
+ * 1. qual should be of form VAR op CONST.
+ * 2. VAR should be for datatype with fixed length.
+ */
+static void
+get_scankey_from_qual(TupleDesc tupDesc, List *qual, PlanState *ps,
+					int *nkeys, ScanKey *rs_keys)
+{
+	ListCell   		*l, *l1;
+	Expr 	   		*expr;
+	ListCell   		*prev = NULL;
+	ScanKey			 key;
+	Expr			*leftop;
+	Expr			*rightop;
+	AttrNumber	 	 varattno;
+	Datum		 	 scanvalue;
+
+	/*
+	 * Validate each qual whether this qual can be push down to heap node
+	 * or not, If this can be pushed down then create a ScanKey entry
+	 * and delete it from qual list of PlanState
+	 */
+	forboth(l, qual, l1, ps->qual)
+	{
+		expr = (Expr *) lfirst(l);
+
+		if (!IsA(expr, OpExpr))
+		{
+			prev = l1;
+			continue;
+		}
+
+
+		/* leftop should be the Var, possibly relabeled. */
+		leftop = (Expr *) get_leftop(expr);
+		if (leftop && IsA(leftop, RelabelType))
+			leftop = ((RelabelType *) leftop)->arg;
+
+		Assert(leftop != NULL);
+
+		/* If leftop is not var then continue and check next qual. */
+		if (!(IsA(leftop, Var)))
+		{
+			prev = l1;
+			continue;
+		}
+
+		varattno = ((Var *) leftop)->varattno;
+
+		/*
+		 * We don't want to push down the qual which can have variable
+		 * length data.
+		 */
+		if (varattno <= 0)
+		{
+			prev = l1;
+			continue;
+		}
+
+		rightop = (Expr *) get_rightop(expr);
+		if (rightop && IsA(rightop, RelabelType))
+			rightop = ((RelabelType *) rightop)->arg;
+
+		Assert(rightop != NULL);
+
+		/*
+		 * If right op is not constant then we can not push down this key
+		 * so move to next qual.
+		 */
+		if (!IsA(rightop, Const))
+		{
+			prev = l1;
+			continue;
+		}
+
+		scanvalue = ((Const *) rightop)->constvalue;
+
+		/* If we havn't yet allocated memory for scan keys, then do so. */
+		if (*rs_keys == NULL)
+		{
+			*rs_keys = (ScanKey) palloc(sizeof(ScanKeyData) *
+									list_length(qual));
+			key = *rs_keys;
+		}
+
+		/* Create scan key entry */
+		ScanKeyInit(key,
+				varattno,
+				InvalidStrategy,
+				((OpExpr *) expr)->opfuncid,
+				scanvalue);
+
+		key->sk_collation = ((OpExpr *) expr)->inputcollid;
+
+		key++;
+		(*nkeys)++;
+
+		/*
+		 * We have created scankey for this qual entry so remove it from
+		 * qual list.
+		 */
+		ps->qual = list_delete_cell(ps->qual, l1, prev);
+	}
 }
diff --git a/src/backend/utils/cache/catcache.c b/src/backend/utils/cache/catcache.c
index 6016d19..48e50ce 100644
--- a/src/backend/utils/cache/catcache.c
+++ b/src/backend/utils/cache/catcache.c
@@ -1168,6 +1168,7 @@ SearchCatCache(CatCache *cache,
 		 */
 		HeapKeyTest(&ct->tuple,
 					cache->cc_tupdesc,
+					NULL, 0, NULL,
 					cache->cc_nkeys,
 					cur_skey,
 					res);
@@ -1459,6 +1460,7 @@ SearchCatCacheList(CatCache *cache,
 			continue;
 		HeapKeyTest(&cl->tuple,
 					cache->cc_tupdesc,
+					NULL, 0, NULL,
 					nkeys,
 					cur_skey,
 					res);
diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h
index 0d12bbb..d02f44a 100644
--- a/src/include/access/heapam.h
+++ b/src/include/access/heapam.h
@@ -130,7 +130,9 @@ extern HeapTuple heap_getnext(HeapScanDesc scan, ScanDirection direction);
 extern Size heap_parallelscan_estimate(Snapshot snapshot);
 extern void heap_parallelscan_initialize(ParallelHeapScanDesc target,
 							 Relation relation, Snapshot snapshot);
-extern HeapScanDesc heap_beginscan_parallel(Relation, ParallelHeapScanDesc);
+extern HeapScanDesc heap_beginscan_parallel(Relation relation,
+						ParallelHeapScanDesc parallel_scan, int nkeys,
+						ScanKey key);
 
 extern bool heap_fetch(Relation relation, Snapshot snapshot,
 		   HeapTuple tuple, Buffer *userbuf, bool keep_buf,
diff --git a/src/include/access/relscan.h b/src/include/access/relscan.h
index de98dd6..f237ecd 100644
--- a/src/include/access/relscan.h
+++ b/src/include/access/relscan.h
@@ -20,7 +20,7 @@
 #include "access/itup.h"
 #include "access/tupdesc.h"
 #include "storage/spin.h"
-
+#include "executor/tuptable.h"
 /*
  * Shared state for parallel heap scan.
  *
@@ -70,6 +70,8 @@ typedef struct HeapScanDescData
 	Buffer		rs_cbuf;		/* current buffer in scan, if any */
 	/* NB: if rs_cbuf is not InvalidBuffer, we hold a pin on that buffer */
 	ParallelHeapScanDesc rs_parallel;	/* parallel scan information */
+	TupleTableSlot	*rs_scanslot;
+	MemoryContext	per_tuple_context;
 
 	/* these fields only used in page-at-a-time mode and for bitmap scans */
 	int			rs_cindex;		/* current tuple's index in vistuples */
diff --git a/src/include/access/valid.h b/src/include/access/valid.h
index 30af9df..bdcb390 100644
--- a/src/include/access/valid.h
+++ b/src/include/access/valid.h
@@ -21,15 +21,18 @@
  */
 #define HeapKeyTest(tuple, \
 					tupdesc, \
+					slot, \
+					buf, \
+					context, \
 					nkeys, \
 					keys, \
 					result) \
 do \
 { \
 	/* Use underscores to protect the variables passed in as parameters */ \
-	int			__cur_nkeys = (nkeys); \
-	ScanKey		__cur_keys = (keys); \
- \
+	int				__cur_nkeys = (nkeys); \
+	ScanKey			__cur_keys = (keys); \
+	\
 	(result) = true; /* may change */ \
 	for (; __cur_nkeys--; __cur_keys++) \
 	{ \
@@ -43,10 +46,13 @@ do \
 			break; \
 		} \
  \
-		__atp = heap_getattr((tuple), \
+ 	 	if (!(slot))	\
+			__atp = heap_getattr((tuple), \
 							 __cur_keys->sk_attno, \
 							 (tupdesc), \
 							 &__isnull); \
+		else \
+		    __atp = slot_getattr((slot), __cur_keys->sk_attno, &__isnull); \
  \
 		if (__isnull) \
 		{ \
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index f6f73f3..faad0a1 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -1256,6 +1256,8 @@ typedef struct ScanState
 	Relation	ss_currentRelation;
 	HeapScanDesc ss_currentScanDesc;
 	TupleTableSlot *ss_ScanTupleSlot;
+	int			nkey;
+	ScanKey		keys;
 } ScanState;
 
 /* ----------------