Support remote functions

knizhnik · knizhnik · commit 6a8d759ddf9f · 2017-08-03T18:04:24.000+03:00
diff --git a/contrib/mmts/multimaster.c b/contrib/mmts/multimaster.c
@@ -68,6 +68,7 @@
 #include "parser/analyze.h"
 #include "parser/parse_relation.h"
 #include "parser/parse_type.h"
+#include "parser/parse_func.h"
 #include "catalog/pg_class.h"
 #include "catalog/pg_type.h"
 #include "tcop/pquery.h"
@@ -157,6 +158,7 @@ static void	  MtmInitializeSequence(int64* start, int64* step);
 static void*  MtmCreateSavepointContext(void);
 static void	  MtmRestoreSavepointContext(void* ctx);
 static void	  MtmReleaseSavepointContext(void* ctx);
+static void   MtmSetRemoteFunction(char const* list, void* extra);
 
 static void MtmCheckClusterLock(void);
 static void MtmCheckSlots(void);
@@ -183,6 +185,7 @@ MtmConnectionInfo* MtmConnections;
 
 HTAB* MtmXid2State;
 HTAB* MtmGid2State;
+static HTAB* MtmRemoteFunctions;
 static HTAB* MtmLocalTables;
 
 static bool MtmIsRecoverySession;
@@ -254,6 +257,7 @@ bool  MtmVolksWagenMode; /* Pretend to be normal postgres. This means skip some
 TransactionId  MtmUtilityProcessedInXid;
 
 static char* MtmConnStrs;
+static char* MtmRemoteFunctionsList;
 static char* MtmClusterName;
 static int	 MtmQueueSize;
 static int	 MtmWorkers;
@@ -2567,7 +2571,7 @@ MtmCreateLocalTableMap(void)
 		"MtmLocalTables",
 		MULTIMASTER_MAX_LOCAL_TABLES, MULTIMASTER_MAX_LOCAL_TABLES,
 		&info,
-		HASH_ELEM
+		HASH_ELEM | HASH_BLOBS
 	);
 	return htab;
 }
@@ -2761,6 +2765,48 @@ MtmShmemStartup(void)
 	MtmInitialize();
 }
 
+static void MtmSetRemoteFunction(char const* list, void* extra)
+{
+	if (MtmRemoteFunctions) {
+		hash_destroy(MtmRemoteFunctions);
+		MtmRemoteFunctions = NULL;
+	}
+}
+
+static void MtmInitializeRemoteFunctionsMap()
+{
+	HASHCTL info;
+	char* p, *q;
+	int n_funcs = 1;
+	FuncCandidateList clist;
+
+	for (p = MtmRemoteFunctionsList; (q = strchr(p, ',')) != NULL; p = q + 1, n_funcs++);
+
+	Assert(MtmRemoteFunctions == NULL);
+
+	memset(&info, 0, sizeof(info));
+	info.entrysize = info.keysize = sizeof(Oid);
+	info.hcxt = TopMemoryContext;
+	MtmRemoteFunctions = hash_create("MtmRemoteFunctions", n_funcs, &info,
+									 HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
+
+	p = pstrdup(MtmRemoteFunctionsList);
+	do {
+		q = strchr(p, ',');
+		if (q != NULL) {
+			*q++ = '\0';
+		}
+		clist = FuncnameGetCandidates(stringToQualifiedNameList(p), -1, NIL, false, false, true);
+		if (clist == NULL) {
+			MTM_ELOG(ERROR, "Failed to lookup function %s", p);
+		} else if (clist->next != NULL) {
+			MTM_ELOG(ERROR, "Ambigious function %s", p);
+		}
+		hash_search(MtmRemoteFunctions, &clist->oid, HASH_ENTER, NULL);
+		p = q;
+	} while (p != NULL);
+}
+
 /*
  * Parse node connection string.
  * This function is called at cluster startup and while adding new cluster node
@@ -3377,6 +3423,19 @@ _PG_init(void)
 		NULL		 /* GucShowHook show_hook */
 	);
 
+	DefineCustomStringVariable(
+		"multimaster.remote_functions",
+		"List of fnuction names which should be executed remotely at all multimaster nodes instead of executing them at master and replicating result of their work",
+		NULL,
+		&MtmRemoteFunctionsList,
+		"lo_create,lo_unlink",
+		PGC_USERSET, /* context */
+		0,			 /* flags */
+		NULL,		 /* GucStringCheckHook check_hook */
+		MtmSetRemoteFunction,		 /* GucStringAssignHook assign_hook */
+		NULL		 /* GucShowHook show_hook */
+	);
+
 	DefineCustomStringVariable(
 		"multimaster.cluster_name",
 		"Name of the cluster",
@@ -3867,7 +3926,7 @@ lsn_t MtmGetFlushPosition(int nodeId)
  * Keep track of progress of WAL writer.
  * We need to notify WAL senders at other nodes which logical records
  * are flushed to the disk and so can survive failure. In asynchronous commit mode
- * WAL is flushed by WAL writer. Current flish position can be obtained by GetFlushRecPtr().
+ * WAL is flushed by WAL writer. Current flush position can be obtained by GetFlushRecPtr().
  * So on applying new logical record we insert it in the MtmLsnMapping and compare
  * their poistions in local WAL log with current flush position.
  * The records which are flushed to the disk by WAL writer are removed from the list
@@ -4975,7 +5034,7 @@ char* MtmGucSerialize(void)
 		appendStringInfoString(serialized_gucs, " TO ");
 
 		/* quite a crutch */
-		if (strstr(cur_entry->key, "_mem") != NULL || *(cur_entry->value) == '\0')
+		if (strstr(cur_entry->key, "_mem") != NULL || *(cur_entry->value) == '\0' || strchr(cur_entry->value, ',') != NULL)
 		{
 			appendStringInfoString(serialized_gucs, "'");
 			appendStringInfoString(serialized_gucs, cur_entry->value);
@@ -5006,10 +5065,7 @@ static void MtmProcessDDLCommand(char const* queryString, bool transactional)
 	if (transactional)
 	{
 		char *gucCtx = MtmGucSerialize();
-		if (*gucCtx)
-			queryString = psprintf("RESET SESSION AUTHORIZATION; reset all; %s; %s", gucCtx, queryString);
-		else
-			queryString = psprintf("RESET SESSION AUTHORIZATION; reset all; %s", queryString);
+		queryString = psprintf("RESET SESSION AUTHORIZATION; reset all; %s %s", gucCtx, queryString);
 
 		/* Transactional DDL */
 		MTM_LOG3("Sending DDL: %s", queryString);
@@ -5377,29 +5433,28 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString,
 static void
 MtmExecutorStart(QueryDesc *queryDesc, int eflags)
 {
-	bool ddl_generating_call = false;
-	ListCell   *tlist;
-
-	foreach(tlist, queryDesc->plannedstmt->planTree->targetlist)
+	if (!MtmTx.isReplicated && ActivePortal)
 	{
-		TargetEntry *tle = (TargetEntry *) lfirst(tlist);
+		ListCell   *tlist;
 
-		if (tle->resname && strcmp(tle->resname, "lo_create") == 0)
+		if (!MtmRemoteFunctions)
 		{
-			ddl_generating_call = true;
-			break;
+			MtmInitializeRemoteFunctionsMap();
 		}
 
-		if (tle->resname && strcmp(tle->resname, "lo_unlink") == 0)
+		foreach(tlist, queryDesc->plannedstmt->planTree->targetlist)
 		{
-			ddl_generating_call = true;
-			break;
+			TargetEntry *tle = (TargetEntry *) lfirst(tlist);
+			if (tle->expr && IsA(tle->expr, FuncExpr))
+			{
+				if (hash_search(MtmRemoteFunctions, &((FuncExpr*)tle->expr)->funcid, HASH_FIND, NULL))
+				{
+					MtmProcessDDLCommand(ActivePortal->sourceText, true);
+					break;
+				}
+			}
 		}
 	}
-
-	if (ddl_generating_call && !MtmTx.isReplicated)
-		MtmProcessDDLCommand(ActivePortal->sourceText, true);
-
 	if (PreviousExecutorStartHook != NULL)
 		PreviousExecutorStartHook(queryDesc, eflags);
 	else
diff --git a/contrib/mmts/multimaster.h b/contrib/mmts/multimaster.h
@@ -51,22 +51,22 @@
 		fprintf(stderr, MTM_TAG "%s, %lld, %s, %d\n", tx->gid, (long long)MtmGetSystemTime(), event, MyProcPid)
 #endif
 
-#define MULTIMASTER_NAME                "multimaster"
-#define MULTIMASTER_SCHEMA_NAME         "mtm"
-#define MULTIMASTER_LOCAL_TABLES_TABLE  "local_tables"
-#define MULTIMASTER_SLOT_PATTERN        "mtm_slot_%d"
-#define MULTIMASTER_MIN_PROTO_VERSION   1
-#define MULTIMASTER_MAX_PROTO_VERSION   1
-#define MULTIMASTER_MAX_GID_SIZE        32
-#define MULTIMASTER_MAX_SLOT_NAME_SIZE  16
-#define MULTIMASTER_MAX_CONN_STR_SIZE   128
-#define MULTIMASTER_MAX_HOST_NAME_SIZE  64
-#define MULTIMASTER_MAX_LOCAL_TABLES    256
-#define MULTIMASTER_MAX_CTL_STR_SIZE    256
-#define MULTIMASTER_LOCK_BUF_INIT_SIZE  4096
-#define MULTIMASTER_BROADCAST_SERVICE   "mtm_broadcast"
-#define MULTIMASTER_ADMIN               "mtm_admin"
-#define MULTIMASTER_PRECOMMITTED        "precommitted"
+#define MULTIMASTER_NAME                 "multimaster"
+#define MULTIMASTER_SCHEMA_NAME          "mtm"
+#define MULTIMASTER_LOCAL_TABLES_TABLE   "local_tables"
+#define MULTIMASTER_SLOT_PATTERN         "mtm_slot_%d"
+#define MULTIMASTER_MIN_PROTO_VERSION    1
+#define MULTIMASTER_MAX_PROTO_VERSION    1
+#define MULTIMASTER_MAX_GID_SIZE         32
+#define MULTIMASTER_MAX_SLOT_NAME_SIZE   16
+#define MULTIMASTER_MAX_CONN_STR_SIZE    128
+#define MULTIMASTER_MAX_HOST_NAME_SIZE   64
+#define MULTIMASTER_MAX_LOCAL_TABLES     256
+#define MULTIMASTER_MAX_CTL_STR_SIZE     256
+#define MULTIMASTER_LOCK_BUF_INIT_SIZE   4096
+#define MULTIMASTER_BROADCAST_SERVICE    "mtm_broadcast"
+#define MULTIMASTER_ADMIN                "mtm_admin"
+#define MULTIMASTER_PRECOMMITTED         "precommitted"
 
 #define MULTIMASTER_DEFAULT_ARBITER_PORT 5433
 
diff --git a/contrib/mmts/pglogical_receiver.c b/contrib/mmts/pglogical_receiver.c
@@ -478,8 +478,8 @@ pglogical_receiver_main(Datum main_arg)
 					{
 						int64 now = feGetCurrentTimestamp();
 
-						/* Leave is feedback is not sent properly */
 						MtmUpdateLsnMapping(nodeId, walEnd);
+						/* Leave if feedback is not sent properly */
 						if (!sendFeedback(conn, now, nodeId)) {
 							goto OnError;
 						}
@@ -628,7 +628,6 @@ pglogical_receiver_main(Datum main_arg)
 				{
 					int64 now = feGetCurrentTimestamp();
 
-					/* Leave is feedback is not sent properly */
 					MtmUpdateLsnMapping(nodeId, INVALID_LSN);
 					sendFeedback(conn, now, nodeId);
 				}
@@ -724,4 +723,3 @@ void MtmStartReceivers(void)
 		}
 	}
 }
-
diff --git a/contrib/mmts/pglogical_relid_map.c b/contrib/mmts/pglogical_relid_map.c
@@ -20,29 +20,19 @@ static void
 pglogical_relid_map_init(void)
 {
 	HASHCTL	ctl;
-	int hash_flags = HASH_ELEM;
-
 	Assert(relid_map == NULL);
 
 	MemSet(&ctl, 0, sizeof(ctl));
 	ctl.keysize = sizeof(Oid);
 	ctl.entrysize = sizeof(PGLRelidMapEntry);
-
-#if PG_VERSION_NUM >= 90500
-	hash_flags |= HASH_BLOBS;
-#else
-	ctl.hash = tag_hash;
-	hash_flags |= HASH_FUNCTION;
-#endif
-
-	relid_map = hash_create("pglogical_relid_map", PGL_INIT_RELID_MAP_SIZE, &ctl, hash_flags);
+	relid_map = hash_create("pglogical_relid_map", PGL_INIT_RELID_MAP_SIZE, &ctl, HASH_ELEM | HASH_BLOBS);
 
 	Assert(relid_map != NULL);
 }
 
 Oid pglogical_relid_map_get(Oid relid)
 {
-	if (relid_map != NULL) { 
+	if (relid_map != NULL) {
 		PGLRelidMapEntry* entry = (PGLRelidMapEntry*)hash_search(relid_map, &relid, HASH_FIND, NULL);
 		return entry ? entry->local_relid : InvalidOid;
 	}
@@ -51,23 +41,23 @@ Oid pglogical_relid_map_get(Oid relid)
 
 bool pglogical_relid_map_put(Oid remote_relid, Oid local_relid)
 {
-	bool found;	
+	bool found;
     PGLRelidMapEntry* entry;
-    if (relid_map == NULL) { 
+    if (relid_map == NULL) {
         pglogical_relid_map_init();
     }
     entry = hash_search(relid_map, &remote_relid, HASH_ENTER, &found);
   	if (found) {
 	    entry->local_relid = local_relid;
-		return false;	    
+		return false;
     }
     entry->local_relid = local_relid;
 	return true;
 }
 
 void pglogical_relid_map_reset(void)
 {
-	if (relid_map != NULL) { 
+	if (relid_map != NULL) {
 		hash_destroy(relid_map);
 		relid_map = NULL;
 	}

Original file line number	Diff line number	Diff line change
`@@ -478,8 +478,8 @@ pglogical_receiver_main(Datum main_arg)`
`478`	`478`	`{`
`479`	`479`	`int64 now = feGetCurrentTimestamp();`
`480`	`480`
`481`		`- /* Leave is feedback is not sent properly */`
`482`	`481`	`MtmUpdateLsnMapping(nodeId, walEnd);`
	`482`	`+ /* Leave if feedback is not sent properly */`
`483`	`483`	`if (!sendFeedback(conn, now, nodeId)) {`
`484`	`484`	`goto OnError;`
`485`	`485`	`}`
`@@ -628,7 +628,6 @@ pglogical_receiver_main(Datum main_arg)`
`628`	`628`	`{`
`629`	`629`	`int64 now = feGetCurrentTimestamp();`
`630`	`630`
`631`		`- /* Leave is feedback is not sent properly */`
`632`	`631`	`MtmUpdateLsnMapping(nodeId, INVALID_LSN);`
`633`	`632`	`sendFeedback(conn, now, nodeId);`
`634`	`633`	`}`
`@@ -724,4 +723,3 @@ void MtmStartReceivers(void)`
`724`	`723`	`}`
`725`	`724`	`}`
`726`	`725`	`}`
`727`		`-`
Original file line number	Diff line number	Diff line change
`@@ -20,29 +20,19 @@ static void`
`20`	`20`	`pglogical_relid_map_init(void)`
`21`	`21`	`{`
`22`	`22`	`HASHCTL ctl;`
`23`		`- int hash_flags = HASH_ELEM;`
`24`		`-`
`25`	`23`	`Assert(relid_map == NULL);`
`26`	`24`
`27`	`25`	`MemSet(&ctl, 0, sizeof(ctl));`
`28`	`26`	`ctl.keysize = sizeof(Oid);`
`29`	`27`	`ctl.entrysize = sizeof(PGLRelidMapEntry);`
`30`		`-`
`31`		`-#if PG_VERSION_NUM >= 90500`
`32`		`- hash_flags \|= HASH_BLOBS;`
`33`		`-#else`
`34`		`- ctl.hash = tag_hash;`
`35`		`- hash_flags \|= HASH_FUNCTION;`
`36`		`-#endif`
`37`		`-`
`38`		`- relid_map = hash_create("pglogical_relid_map", PGL_INIT_RELID_MAP_SIZE, &ctl, hash_flags);`
	`28`	`+ relid_map = hash_create("pglogical_relid_map", PGL_INIT_RELID_MAP_SIZE, &ctl, HASH_ELEM \| HASH_BLOBS);`
`39`	`29`
`40`	`30`	`Assert(relid_map != NULL);`
`41`	`31`	`}`
`42`	`32`
`43`	`33`	`Oid pglogical_relid_map_get(Oid relid)`
`44`	`34`	`{`
`45`		`- if (relid_map != NULL) {`
	`35`	`+ if (relid_map != NULL) {`
`46`	`36`	`PGLRelidMapEntry* entry = (PGLRelidMapEntry*)hash_search(relid_map, &relid, HASH_FIND, NULL);`
`47`	`37`	`return entry ? entry->local_relid : InvalidOid;`
`48`	`38`	`}`
`@@ -51,23 +41,23 @@ Oid pglogical_relid_map_get(Oid relid)`
`51`	`41`
`52`	`42`	`bool pglogical_relid_map_put(Oid remote_relid, Oid local_relid)`
`53`	`43`	`{`
`54`		`- bool found;`
	`44`	`+ bool found;`
`55`	`45`	`PGLRelidMapEntry* entry;`
`56`		`- if (relid_map == NULL) {`
	`46`	`+ if (relid_map == NULL) {`
`57`	`47`	`pglogical_relid_map_init();`
`58`	`48`	`}`
`59`	`49`	`entry = hash_search(relid_map, &remote_relid, HASH_ENTER, &found);`
`60`	`50`	`if (found) {`
`61`	`51`	`entry->local_relid = local_relid;`
`62`		`- return false;`
	`52`	`+ return false;`
`63`	`53`	`}`
`64`	`54`	`entry->local_relid = local_relid;`
`65`	`55`	`return true;`
`66`	`56`	`}`
`67`	`57`
`68`	`58`	`void pglogical_relid_map_reset(void)`
`69`	`59`	`{`
`70`		`- if (relid_map != NULL) {`
	`60`	`+ if (relid_map != NULL) {`
`71`	`61`	`hash_destroy(relid_map);`
`72`	`62`	`relid_map = NULL;`
`73`	`63`	`}`