diff --git a/src/backend/nodes/readfuncs.c b/src/backend/nodes/readfuncs.c
index badb2d8..e0d244e 100644
--- a/src/backend/nodes/readfuncs.c
+++ b/src/backend/nodes/readfuncs.c
@@ -1478,10 +1478,21 @@ _readResult(void)
 {
 	READ_LOCALS(Result);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check Result Node")));
+
+
 	ReadCommonPlan((Plan *) local_node);
 
 	READ_NODE_FIELD(resconstantqual);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Result Node verified")));
+
 	READ_DONE();
 }
 
@@ -1493,6 +1504,11 @@ _readModifyTable(void)
 {
 	READ_LOCALS(ModifyTable);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check Modify Table Node")));
+
 	ReadCommonPlan((Plan *) local_node);
 
 	READ_ENUM_FIELD(operation, CmdType);
@@ -1513,6 +1529,11 @@ _readModifyTable(void)
 	READ_UINT_FIELD(exclRelRTI);
 	READ_NODE_FIELD(exclRelTlist);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Modify Table verified")));
+
 	READ_DONE();
 }
 
@@ -1524,10 +1545,20 @@ _readAppend(void)
 {
 	READ_LOCALS(Append);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check Append Node")));
+
 	ReadCommonPlan((Plan *) local_node);
 
 	READ_NODE_FIELD(appendplans);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Append Node verified")));
+
 	READ_DONE();
 }
 
@@ -1541,6 +1572,11 @@ _readMergeAppend(void)
 
 	READ_LOCALS(MergeAppend);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check MergeAppend Node")));
+
 	ReadCommonPlan((Plan *) local_node);
 
 	READ_NODE_FIELD(mergeplans);
@@ -1562,6 +1598,11 @@ _readMergeAppend(void)
 	if (local_node->numCols)
 		local_node->nullsFirst = readBoolCols(local_node->numCols);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("MergeAppend Node verified")));
+
 	READ_DONE();
 }
 
@@ -1575,6 +1616,11 @@ _readRecursiveUnion(void)
 
 	READ_LOCALS(RecursiveUnion);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check RecursiveUnion Node")));
+
 	ReadCommonPlan((Plan *) local_node);
 
 	READ_INT_FIELD(wtParam);
@@ -1590,6 +1636,11 @@ _readRecursiveUnion(void)
 
 	READ_LONG_FIELD(numGroups);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("RecursiveUnion Node verified")));
+
 	READ_DONE();
 }
 
@@ -1601,10 +1652,20 @@ _readBitmapAnd(void)
 {
 	READ_LOCALS(BitmapAnd);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check BitmapAnd Node")));
+
 	ReadCommonPlan((Plan *) local_node);
 
 	READ_NODE_FIELD(bitmapplans);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("BitmapAnd Node verified")));
+
 	READ_DONE();
 }
 
@@ -1616,10 +1677,20 @@ _readBitmapOr(void)
 {
 	READ_LOCALS(BitmapOr);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check BitmapOr Node")));
+
 	ReadCommonPlan((Plan *) local_node);
 
 	READ_NODE_FIELD(bitmapplans);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("BitmapOr Node verified")));
+
 	READ_DONE();
 }
 
@@ -1672,8 +1743,18 @@ _readSeqScan(void)
 {
 	READ_LOCALS_NO_FIELDS(SeqScan);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check SeqScan Node")));
+
 	ReadCommonScan((Scan *) local_node);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("SeqScan Node verified")));
+
 	READ_DONE();
 }
 
@@ -1685,10 +1766,20 @@ _readSampleScan(void)
 {
 	READ_LOCALS(SampleScan);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check SampleScan Node")));
+
 	ReadCommonScan((Scan *) local_node);
 
 	READ_NODE_FIELD(tablesample);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("SampleScan Node verfied")));
+
 	READ_DONE();
 }
 
@@ -1700,6 +1791,11 @@ _readIndexScan(void)
 {
 	READ_LOCALS(IndexScan);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check IndexScan Node")));
+
 	ReadCommonScan((Scan *) local_node);
 
 	READ_OID_FIELD(indexid);
@@ -1710,6 +1806,11 @@ _readIndexScan(void)
 	READ_NODE_FIELD(indexorderbyops);
 	READ_ENUM_FIELD(indexorderdir, ScanDirection);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("IndexScan Node verified")));
+
 	READ_DONE();
 }
 
@@ -1721,6 +1822,11 @@ _readIndexOnlyScan(void)
 {
 	READ_LOCALS(IndexOnlyScan);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check IndexOnlyScan Node")));
+
 	ReadCommonScan((Scan *) local_node);
 
 	READ_OID_FIELD(indexid);
@@ -1729,6 +1835,11 @@ _readIndexOnlyScan(void)
 	READ_NODE_FIELD(indextlist);
 	READ_ENUM_FIELD(indexorderdir, ScanDirection);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("IndexOnlyScan Node verified")));
+
 	READ_DONE();
 }
 
@@ -1740,12 +1851,22 @@ _readBitmapIndexScan(void)
 {
 	READ_LOCALS(BitmapIndexScan);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check BitmapIndexScan Node")));
+
 	ReadCommonScan((Scan *) local_node);
 
 	READ_OID_FIELD(indexid);
 	READ_NODE_FIELD(indexqual);
 	READ_NODE_FIELD(indexqualorig);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("BitmapIndexScan Node verified")));
+
 	READ_DONE();
 }
 
@@ -1757,10 +1878,20 @@ _readBitmapHeapScan(void)
 {
 	READ_LOCALS(BitmapHeapScan);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check BitmapHeapScan Node")));
+
 	ReadCommonScan((Scan *) local_node);
 
 	READ_NODE_FIELD(bitmapqualorig);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("BitmapHeapScan Node verified")));
+
 	READ_DONE();
 }
 
@@ -1772,10 +1903,20 @@ _readTidScan(void)
 {
 	READ_LOCALS(TidScan);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check TidScan Node")));
+
 	ReadCommonScan((Scan *) local_node);
 
 	READ_NODE_FIELD(tidquals);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("TidScan Node verified")));
+
 	READ_DONE();
 }
 
@@ -1787,10 +1928,20 @@ _readSubqueryScan(void)
 {
 	READ_LOCALS(SubqueryScan);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check SubqueryScan Node")));
+
 	ReadCommonScan((Scan *) local_node);
 
 	READ_NODE_FIELD(subplan);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("SubqueryScan Node verified")));
+
 	READ_DONE();
 }
 
@@ -1802,11 +1953,21 @@ _readFunctionScan(void)
 {
 	READ_LOCALS(FunctionScan);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check FunctionScan Node")));
+
 	ReadCommonScan((Scan *) local_node);
 
 	READ_NODE_FIELD(functions);
 	READ_BOOL_FIELD(funcordinality);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("FunctionScan Node verified")));
+
 	READ_DONE();
 }
 
@@ -1818,10 +1979,20 @@ _readValuesScan(void)
 {
 	READ_LOCALS(ValuesScan);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check ValuesScan Node")));
+
 	ReadCommonScan((Scan *) local_node);
 
 	READ_NODE_FIELD(values_lists);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("ValuesScan Node verified")));
+
 	READ_DONE();
 }
 
@@ -1833,11 +2004,21 @@ _readCteScan(void)
 {
 	READ_LOCALS(CteScan);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check CteScan Node")));
+
 	ReadCommonScan((Scan *) local_node);
 
 	READ_INT_FIELD(ctePlanId);
 	READ_INT_FIELD(cteParam);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("CteScan Node verified")));
+
 	READ_DONE();
 }
 
@@ -1849,10 +2030,20 @@ _readWorkTableScan(void)
 {
 	READ_LOCALS(WorkTableScan);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check WorkTableScan Node")));
+
 	ReadCommonScan((Scan *) local_node);
 
 	READ_INT_FIELD(wtParam);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("WorkTableScan Node verified")));
+
 	READ_DONE();
 }
 
@@ -1864,6 +2055,11 @@ _readForeignScan(void)
 {
 	READ_LOCALS(ForeignScan);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check ForeignScan Node")));
+
 	ReadCommonScan((Scan *) local_node);
 
 	READ_OID_FIELD(fs_server);
@@ -1873,6 +2069,11 @@ _readForeignScan(void)
 	READ_BITMAPSET_FIELD(fs_relids);
 	READ_BOOL_FIELD(fsSystemCol);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("ForeignScan Node verified")));
+
 	READ_DONE();
 }
 
@@ -1927,10 +2128,20 @@ _readNestLoop(void)
 {
 	READ_LOCALS(NestLoop);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check NestLoop Node")));
+
 	_ReadCommonJoin((Join *) local_node);
 
 	READ_NODE_FIELD(nestParams);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("NestLoop Node verified")));
+
 	READ_DONE();
 }
 
@@ -1945,6 +2156,11 @@ _readMergeJoin(void)
 
 	READ_LOCALS(MergeJoin);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check MergeJoin Node")));
+
 	_ReadCommonJoin((Join *) local_node);
 
 	READ_NODE_FIELD(mergeclauses);
@@ -1967,6 +2183,11 @@ _readMergeJoin(void)
 	if (numCols)
 		local_node->mergeNullsFirst = readBoolCols(numCols);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("MergeJoin Node verified")));
+
 	READ_DONE();
 }
 
@@ -1978,10 +2199,20 @@ _readHashJoin(void)
 {
 	READ_LOCALS(HashJoin);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check HashJoin Node")));
+
 	_ReadCommonJoin((Join *) local_node);
 
 	READ_NODE_FIELD(hashclauses);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("HashJoin Node verified")));
+
 	READ_DONE();
 }
 
@@ -1992,6 +2223,11 @@ static Material *
 _readMaterial(void)
 {
 	READ_LOCALS_NO_FIELDS(Material);
+	
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check Material Node")));
 
 	ReadCommonPlan((Plan *) local_node);
 
@@ -2008,6 +2244,11 @@ _readSort(void)
 
 	READ_LOCALS(Sort);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check Sort Node")));
+
 	ReadCommonPlan((Plan *) local_node);
 
 	READ_INT_FIELD(numCols);
@@ -2028,6 +2269,11 @@ _readSort(void)
 	if (local_node->numCols)
 		local_node->nullsFirst = readBoolCols(local_node->numCols);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Sort Node verified")));
+
 	READ_DONE();
 }
 
@@ -2041,6 +2287,11 @@ _readGroup(void)
 
 	READ_LOCALS(Group);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check Group Node")));
+
 	ReadCommonPlan((Plan *) local_node);
 
 	READ_INT_FIELD(numCols);
@@ -2053,6 +2304,11 @@ _readGroup(void)
 	if (local_node->numCols)
 		local_node->grpOperators = readOidCols(local_node->numCols);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Group Node verified")));
+
 	READ_DONE();
 }
 
@@ -2066,6 +2322,11 @@ _readAgg(void)
 
 	READ_LOCALS(Agg);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check Agg Node")));
+
 	ReadCommonPlan((Plan *) local_node);
 
 	READ_ENUM_FIELD(aggstrategy, AggStrategy);
@@ -2084,6 +2345,11 @@ _readAgg(void)
 	READ_NODE_FIELD(groupingSets);
 	READ_NODE_FIELD(chain);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Agg Node verified")));
+
 	READ_DONE();
 }
 
@@ -2097,6 +2363,11 @@ _readWindowAgg(void)
 
 	READ_LOCALS(WindowAgg);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check WindowAgg Node")));
+
 	ReadCommonPlan((Plan *) local_node);
 
 	READ_UINT_FIELD(winref);
@@ -2124,6 +2395,11 @@ _readWindowAgg(void)
 	READ_NODE_FIELD(startOffset);
 	READ_NODE_FIELD(endOffset);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("WindowAgg Node verified")));
+
 	READ_DONE();
 }
 
@@ -2137,6 +2413,11 @@ _readUnique(void)
 
 	READ_LOCALS(Unique);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check Unique Node")));
+
 	ReadCommonPlan((Plan *) local_node);
 
 	READ_INT_FIELD(numCols);
@@ -2149,6 +2430,11 @@ _readUnique(void)
 	if (local_node->numCols)
 		local_node->uniqOperators = readOidCols(local_node->numCols);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Unique Node verified")));
+
 	READ_DONE();
 }
 
@@ -2160,6 +2446,11 @@ _readHash(void)
 {
 	READ_LOCALS(Hash);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check Hash Node")));
+
 	ReadCommonPlan((Plan *) local_node);
 
 	READ_OID_FIELD(skewTable);
@@ -2168,6 +2459,11 @@ _readHash(void)
 	READ_OID_FIELD(skewColType);
 	READ_INT_FIELD(skewColTypmod);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Hash Node verified")));
+
 	READ_DONE();
 }
 
@@ -2181,6 +2477,11 @@ _readSetOp(void)
 
 	READ_LOCALS(SetOp);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check SetOp Node")));
+
 	ReadCommonPlan((Plan *) local_node);
 
 	READ_ENUM_FIELD(cmd, SetOpCmd);
@@ -2199,6 +2500,11 @@ _readSetOp(void)
 	READ_INT_FIELD(firstFlag);
 	READ_LONG_FIELD(numGroups);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("SetOp Node verified")));
+
 	READ_DONE();
 }
 
@@ -2210,11 +2516,21 @@ _readLockRows(void)
 {
 	READ_LOCALS(LockRows);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check LockRows Node")));
+
 	ReadCommonPlan((Plan *) local_node);
 
 	READ_NODE_FIELD(rowMarks);
 	READ_INT_FIELD(epqParam);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("LockRows Node verified")));
+
 	READ_DONE();
 }
 
@@ -2226,11 +2542,21 @@ _readLimit(void)
 {
 	READ_LOCALS(Limit);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check Limit Node")));
+
 	ReadCommonPlan((Plan *) local_node);
 
 	READ_NODE_FIELD(limitOffset);
 	READ_NODE_FIELD(limitCount);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Limit Node verified")));
+
 	READ_DONE();
 }
 
@@ -2242,9 +2568,19 @@ _readNestLoopParam(void)
 {
 	READ_LOCALS(NestLoopParam);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check NestLoopParam Node")));
+
 	READ_INT_FIELD(paramno);
 	READ_NODE_FIELD(paramval);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("NestLoopParam Node verified")));
+
 	READ_DONE();
 }
 
@@ -2256,6 +2592,11 @@ _readPlanRowMark(void)
 {
 	READ_LOCALS(PlanRowMark);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check PlanRowMark Node")));
+
 	READ_UINT_FIELD(rti);
 	READ_UINT_FIELD(prti);
 	READ_UINT_FIELD(rowmarkId);
@@ -2265,6 +2606,11 @@ _readPlanRowMark(void)
 	READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
 	READ_BOOL_FIELD(isParent);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("PlanRowMark Node verified")));
+
 	READ_DONE();
 }
 
@@ -2276,9 +2622,19 @@ _readPlanInvalItem(void)
 {
 	READ_LOCALS(PlanInvalItem);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check PlanInvalItem Node")));
+
 	READ_INT_FIELD(cacheId);
 	READ_UINT_FIELD(hashValue);
 
+ 	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("PlanInvalItem Node verified")));
+
 	READ_DONE();
 }
 
@@ -2290,6 +2646,11 @@ _readSubPlan(void)
 {
 	READ_LOCALS(SubPlan);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check SubPlan Node")));
+
 	READ_ENUM_FIELD(subLinkType, SubLinkType);
 	READ_NODE_FIELD(testexpr);
 	READ_NODE_FIELD(paramIds);
@@ -2306,6 +2667,11 @@ _readSubPlan(void)
 	READ_FLOAT_FIELD(startup_cost);
 	READ_FLOAT_FIELD(per_call_cost);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("SubPlan Node verified")));
+
 	READ_DONE();
 }
 
@@ -2317,8 +2683,18 @@ _readAlternativeSubPlan(void)
 {
 	READ_LOCALS(AlternativeSubPlan);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("Check AlternativeSubPlan Node")));
+
 	READ_NODE_FIELD(subplans);
 
+	ereport(LOG,
+			(errhidestmt(true),
+			 errhidecontext(true),
+			 errmsg("AlternativeSubPlan Node verified")));
+
 	READ_DONE();
 }
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 06be922..570786c 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -135,6 +135,172 @@ static Plan *build_grouping_chain(PlannerInfo *root,
 					 long numGroups,
 					 Plan *result_plan);
 
+
+/*
+ * fix_node_funcids
+ *		Set the opfuncid (procedure OID) in an OpExpr node,
+ *		for plan tree.
+ *
+ * We need it mainly to fix the opfuncid in nodes of plantree
+ * after reading the planned statement by worker backend.
+ */
+static void
+fix_node_funcids(Plan *node)
+{
+	ListCell   *temp;
+
+	/*
+	 * do nothing when we get to the end of a leaf on tree.
+	 */
+	if (node == NULL)
+		return;
+
+	fix_opfuncids((Node*) node->qual);
+	fix_opfuncids((Node*) node->targetlist);
+
+	switch (nodeTag(node))
+	{
+		case T_Result:
+			fix_opfuncids((Node*) (((Result *) node)->resconstantqual));
+			break;
+		case T_ModifyTable:
+			foreach(temp, (List *) ((ModifyTable *) node)->plans)
+				fix_node_funcids((Plan *) lfirst(temp));
+
+			fix_opfuncids((Node*) (((ModifyTable *) node)->withCheckOptionLists));
+			fix_opfuncids((Node*) (((ModifyTable *) node)->returningLists));
+			/*
+			 * we should fix funcids for fdwPrivLists, but it is not
+			 * clear what kind of expressions it can contain.
+			 */
+			fix_opfuncids((Node*) (((ModifyTable *) node)->onConflictSet));
+			fix_opfuncids((Node*) (((ModifyTable *) node)->onConflictWhere));
+			fix_opfuncids((Node*) (((ModifyTable *) node)->exclRelTlist));
+			break;
+		case T_Append:
+			foreach(temp, (List *) ((Append *) node)->appendplans)
+				fix_node_funcids((Plan *) lfirst(temp));
+			break;
+		case T_MergeAppend:
+			foreach(temp, (List *) ((MergeAppend *) node)->mergeplans)
+				fix_node_funcids((Plan *) lfirst(temp));
+			break;
+		case T_RecursiveUnion:
+			break;
+		case T_BitmapAnd:
+			foreach(temp, (List *) ((BitmapAnd *) node)->bitmapplans)
+				fix_node_funcids((Plan *) lfirst(temp));
+			break;
+		case T_BitmapOr:
+			foreach(temp, (List *) ((BitmapOr *) node)->bitmapplans)
+				fix_node_funcids((Plan *) lfirst(temp));
+			break;
+		case T_Scan:
+			break;
+		case T_SeqScan:
+			break;
+		case T_SampleScan:
+			fix_opfuncids((Node*) (((SampleScan *) node)->tablesample));
+			break;
+		case T_IndexScan:
+			fix_opfuncids((Node*) (((IndexScan *) node)->indexqual));
+			fix_opfuncids((Node*) (((IndexScan *) node)->indexqualorig));
+			fix_opfuncids((Node*) (((IndexScan *) node)->indexorderby));
+			fix_opfuncids((Node*) (((IndexScan *) node)->indexorderbyorig));
+			break;
+		case T_IndexOnlyScan:
+			fix_opfuncids((Node*) (((IndexOnlyScan *) node)->indexqual));
+			fix_opfuncids((Node*) (((IndexOnlyScan *) node)->indexorderby));
+			fix_opfuncids((Node*) (((IndexOnlyScan *) node)->indextlist));
+			break;
+		case T_BitmapIndexScan:
+			fix_opfuncids((Node*) (((BitmapIndexScan *) node)->indexqual));
+			fix_opfuncids((Node*) (((BitmapIndexScan *) node)->indexqualorig));
+			break;
+		case T_BitmapHeapScan:
+			fix_opfuncids((Node*) (((BitmapHeapScan *) node)->bitmapqualorig));
+			break;
+		case T_TidScan:
+			fix_opfuncids((Node*) (((TidScan *) node)->tidquals));
+			break;
+		case T_SubqueryScan:
+			fix_node_funcids((Plan *) ((SubqueryScan *) node)->subplan);
+			break;
+		case T_FunctionScan:
+			fix_opfuncids((Node*) (((FunctionScan *) node)->functions));
+			break;
+		case T_ValuesScan:
+			fix_opfuncids((Node*) (((ValuesScan *) node)->values_lists));
+			break;
+		case T_CteScan:
+			break;
+		case T_WorkTableScan:
+			break;
+		case T_ForeignScan:
+			fix_opfuncids((Node*) (((ForeignScan *) node)->fdw_exprs));
+			/*
+			 * we should fix funcids for fdw_private, but it is not
+			 * clear what kind of expressions it can contain.
+			 */
+			fix_opfuncids((Node*) (((ForeignScan *) node)->fdw_scan_tlist));
+			break;
+		case T_Join:
+			fix_opfuncids((Node*) (((Join *) node)->joinqual));
+			break;
+		case T_NestLoop:
+			fix_opfuncids((Node*) (((NestLoop *) node)->join.joinqual));
+			foreach(temp, (List *) ((NestLoop*) node)->nestParams)
+				fix_opfuncids((Node*) ((NestLoopParam *) lfirst(temp))->paramval);
+			break;
+		case T_MergeJoin:
+			fix_opfuncids((Node*) (((MergeJoin *) node)->join.joinqual));
+			fix_opfuncids((Node*) (((MergeJoin *) node)->mergeclauses));
+			break;
+		case T_HashJoin:
+			fix_opfuncids((Node*) (((HashJoin *) node)->join.joinqual));
+			fix_opfuncids((Node*) (((HashJoin *) node)->hashclauses));
+			break;
+		case T_Material:
+			break;
+		case T_Sort:
+			break;
+		case T_Group:
+			break;
+		case T_Agg:
+			foreach(temp, (List *) ((Agg *) node)->chain)
+				fix_node_funcids((Plan *) lfirst(temp));
+			break;
+		case T_WindowAgg:
+			fix_opfuncids((Node*) (((WindowAgg *) node)->startOffset));
+			fix_opfuncids((Node*) (((WindowAgg *) node)->endOffset));
+			break;
+		case T_Unique:
+			break;
+		case T_Hash:
+			break;
+		case T_SetOp:
+			break;
+		case T_LockRows:
+			break;
+		case T_Limit:
+			fix_opfuncids((Node*) (((Limit *) node)->limitOffset));
+			fix_opfuncids((Node*) (((Limit *) node)->limitCount));
+			break;
+		case T_SubPlan:
+			fix_opfuncids((Node*) ((SubPlan *) node));
+			break;
+		case T_AlternativeSubPlan:
+			fix_opfuncids((Node*) ((AlternativeSubPlan *) node));
+			break;
+		default:
+			elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
+			break;
+	}
+
+	fix_node_funcids(node->lefttree);
+	fix_node_funcids(node->righttree);
+}
+
 /*****************************************************************************
  *
  *	   Query optimizer entry point
@@ -152,12 +318,25 @@ PlannedStmt *
 planner(Query *parse, int cursorOptions, ParamListInfo boundParams)
 {
 	PlannedStmt *result;
+	PlannedStmt *verify_plannedstmt;
+	char		*plannedstmt_str;
+	ListCell   *temp;
 
 	if (planner_hook)
 		result = (*planner_hook) (parse, cursorOptions, boundParams);
 	else
 		result = standard_planner(parse, cursorOptions, boundParams);
-	return result;
+
+	plannedstmt_str = nodeToString(result);
+
+	verify_plannedstmt = (PlannedStmt *) stringToNode(plannedstmt_str);
+
+	fix_node_funcids(verify_plannedstmt->planTree);
+
+	foreach(temp, (List *) verify_plannedstmt->subplans)
+		fix_node_funcids((Plan *) lfirst(temp));
+
+	return verify_plannedstmt;
 }
 
 PlannedStmt *