Support VACCUM ONLY LOCAL and rewrite replicate of functions accessing temporary tables

knizhnik · knizhnik · commit 864f35bb14a9 · 2017-08-09T19:37:40.000+03:00
diff --git a/contrib/mmts/multimaster.c b/contrib/mmts/multimaster.c
@@ -5139,12 +5139,60 @@ void MtmUpdateLockGraph(int nodeId, void const* messageBody, int messageSize)
 	MTM_LOG1("Update deadlock graph for node %d size %d", nodeId, messageSize);
 }
 
+static bool MtmIsTempType(TypeName* typeName)
+{
+	bool isTemp = false;
+
+	if (typeName != NULL)
+	{
+		Type typeTuple = LookupTypeName(NULL, typeName, NULL, false);
+		if (typeTuple != NULL)
+		{
+			Form_pg_type typeStruct = (Form_pg_type) GETSTRUCT(typeTuple);
+		    Oid relid = typeStruct->typrelid;
+		    ReleaseSysCache(typeTuple);
+
+			if (relid != InvalidOid)
+			{
+				HeapTuple classTuple = SearchSysCache1(RELOID, relid);
+				Form_pg_class classStruct = (Form_pg_class) GETSTRUCT(classTuple);
+				if (classStruct->relpersistence == 't')
+					isTemp = true;
+				ReleaseSysCache(classTuple);
+			}
+		}
+	}
+	return isTemp;
+}
+
+static bool MtmFunctionProfileDependsOnTempTable(CreateFunctionStmt* func)
+{
+	ListCell* elem;
+
+	if (MtmIsTempType(func->returnType))
+	{
+		return true;
+	}
+	foreach (elem, func->parameters)
+	{
+		FunctionParameter* param = (FunctionParameter*) lfirst(elem);
+		if (MtmIsTempType(param->argType))
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+
 static void MtmProcessUtility(Node *parsetree, const char *queryString,
 							  ProcessUtilityContext context, ParamListInfo params,
 							  DestReceiver *dest, char *completionTag)
 {
 	bool skipCommand = false;
 	bool executed = false;
+	bool prevMyXactAccessedTempRel;
 
 	MTM_LOG2("%d: Process utility statement tag=%d, context=%d, issubtrans=%d, creating_extension=%d, query=%s",
 			 MyProcPid, nodeTag(parsetree), context, IsSubTransaction(), creating_extension, queryString);
@@ -5226,19 +5274,24 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString,
 			break;
 
 		case T_VacuumStmt:
-		  skipCommand = true;
-		  if (context == PROCESS_UTILITY_TOPLEVEL) {
-			  MtmProcessDDLCommand(queryString, false);
-			  MtmTx.isDistributed = false;
-		  } else if (MtmApplyContext != NULL) {
-			  MemoryContext oldContext = MemoryContextSwitchTo(MtmApplyContext);
-			  Assert(oldContext != MtmApplyContext);
-			  MtmVacuumStmt = (VacuumStmt*)copyObject(parsetree);
-			  MemoryContextSwitchTo(oldContext);
-			  return;
-		  }
-		  break;
-
+		{
+			VacuumStmt* vacuum = (VacuumStmt*)parsetree;
+			skipCommand = true;
+			if ((vacuum->options & VACOPT_LOCAL) == 0 && !MtmVolksWagenMode)
+			{
+				if (context == PROCESS_UTILITY_TOPLEVEL) {
+					MtmProcessDDLCommand(queryString, false);
+					MtmTx.isDistributed = false;
+				} else if (MtmApplyContext != NULL) {
+					MemoryContext oldContext = MemoryContextSwitchTo(MtmApplyContext);
+					Assert(oldContext != MtmApplyContext);
+					MtmVacuumStmt = (VacuumStmt*)copyObject(parsetree);
+					MemoryContextSwitchTo(oldContext);
+					return;
+				}
+			}
+			break;
+		}
 		case T_CreateDomainStmt:
 			/* Detect temp tables access */
 			{
@@ -5403,6 +5456,14 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString,
 					}
 				}
 			}
+		    case T_CreateFunctionStmt:
+		    {
+				if (MtmTx.isReplicated)
+				{
+					// disable functiob body cehck at replica
+					check_function_bodies = false;
+				}
+			}
 			break;
 		}
 
@@ -5420,6 +5481,8 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString,
 	}
 	else MTM_LOG3("Skip utility statement '%s': skip=%d, insideDDL=%d", queryString, skipCommand, MtmDDLStatement != NULL);
 
+	prevMyXactAccessedTempRel = MyXactAccessedTempRel;
+
 	if (PreviousProcessUtilityHook != NULL)
 	{
 		PreviousProcessUtilityHook(parsetree, queryString, context,
@@ -5435,6 +5498,19 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString,
 		MTM_ELOG(ERROR, "Isolation level %s is not supported by multimaster", isoLevelStr[XactIsoLevel]);
 	}
 #endif
+	/* Allow replication of functions operating on temporary tables.
+	 * Even through temporary table doesn't exist at replica, diasabling functoin body check makes it possible to create such function at replica.
+	 * And it can be accessed later at replica if correspondent temporary table will be created.
+	 * But disable replication of functions returning temporary tables: such functions can not be created at replica in any case.
+	 */
+	if (IsA(parsetree, CreateFunctionStmt))
+	{
+		if (MtmFunctionProfileDependsOnTempTable((CreateFunctionStmt*)parsetree))
+		{
+			prevMyXactAccessedTempRel = true;
+		}
+		MyXactAccessedTempRel = prevMyXactAccessedTempRel;
+	}
 	if (MyXactAccessedTempRel)
 	{
 		MTM_LOG1("Xact accessed temp table, stopping replication of statement '%s'", queryString);
diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
@@ -413,7 +413,7 @@ static Node *makeRecursiveViewSelect(char *relname, List *aliases, Node *query);
 
 %type <boolean> opt_autonomous
 %type <boolean> opt_instead
-%type <boolean> opt_unique opt_concurrently opt_verbose opt_full
+%type <boolean> opt_unique opt_concurrently opt_verbose opt_full opt_local
 %type <boolean> opt_freeze opt_default opt_recheck
 %type <defelt>	opt_binary opt_oids copy_delimiter
 
@@ -9650,7 +9650,7 @@ cluster_index_specification:
  *
  *****************************************************************************/
 
-VacuumStmt: VACUUM opt_full opt_freeze opt_verbose
+VacuumStmt: VACUUM opt_full opt_freeze opt_verbose opt_local
 				{
 					VacuumStmt *n = makeNode(VacuumStmt);
 					n->options = VACOPT_VACUUM;
@@ -9660,11 +9660,13 @@ VacuumStmt: VACUUM opt_full opt_freeze opt_verbose
 						n->options |= VACOPT_FREEZE;
 					if ($4)
 						n->options |= VACOPT_VERBOSE;
+					if ($5)
+						n->options |= VACOPT_LOCAL;
 					n->relation = NULL;
 					n->va_cols = NIL;
 					$$ = (Node *)n;
 				}
-			| VACUUM opt_full opt_freeze opt_verbose qualified_name
+			| VACUUM opt_full opt_freeze opt_verbose opt_local qualified_name
 				{
 					VacuumStmt *n = makeNode(VacuumStmt);
 					n->options = VACOPT_VACUUM;
@@ -9674,20 +9676,24 @@ VacuumStmt: VACUUM opt_full opt_freeze opt_verbose
 						n->options |= VACOPT_FREEZE;
 					if ($4)
 						n->options |= VACOPT_VERBOSE;
-					n->relation = $5;
+					if ($5)
+						n->options |= VACOPT_LOCAL;
+					n->relation = $6;
 					n->va_cols = NIL;
 					$$ = (Node *)n;
 				}
-			| VACUUM opt_full opt_freeze opt_verbose AnalyzeStmt
+			| VACUUM opt_full opt_freeze opt_verbose opt_local AnalyzeStmt
 				{
-					VacuumStmt *n = (VacuumStmt *) $5;
+					VacuumStmt *n = (VacuumStmt *) $6;
 					n->options |= VACOPT_VACUUM;
 					if ($2)
 						n->options |= VACOPT_FULL;
 					if ($3)
 						n->options |= VACOPT_FREEZE;
 					if ($4)
 						n->options |= VACOPT_VERBOSE;
+					if ($5)
+						n->options |= VACOPT_LOCAL;
 					$$ = (Node *)n;
 				}
 			| VACUUM '(' vacuum_option_list ')'
@@ -9773,6 +9779,10 @@ opt_freeze: FREEZE									{ $$ = TRUE; }
 			| /*EMPTY*/								{ $$ = FALSE; }
 		;
 
+opt_local: ONLY	LOCAL						        { $$ = TRUE; }
+			| /*EMPTY*/								{ $$ = FALSE; }
+		;
+
 opt_name_list:
 			'(' name_list ')'						{ $$ = $2; }
 			| /*EMPTY*/								{ $$ = NIL; }
diff --git a/src/include/nodes/parsenodes.h b/src/include/nodes/parsenodes.h
@@ -2876,7 +2876,8 @@ typedef enum VacuumOption
 	VACOPT_FULL = 1 << 4,		/* FULL (non-concurrent) vacuum */
 	VACOPT_NOWAIT = 1 << 5,		/* don't wait to get lock (autovacuum only) */
 	VACOPT_SKIPTOAST = 1 << 6,	/* don't process the TOAST table, if any */
-	VACOPT_DISABLE_PAGE_SKIPPING = 1 << 7		/* don't skip any pages */
+	VACOPT_DISABLE_PAGE_SKIPPING = 1 << 7,		/* don't skip any pages */
+	VACOPT_LOCAL = 1 << 8       /* Multimaster: perform vacuum only on local node */
 } VacuumOption;
 
 typedef struct VacuumStmt
