postgres_fdw: Remove duplicate code in DML execution callback functions.

postgresExecForeignInsert(), postgresExecForeignUpdate(), and
postgresExecForeignDelete() are coded almost identically, except that
postgresExecForeignInsert() does not need CTID.  Extract that code into
a separate function and use it in all the three function implementations.

Author: Ashutosh Bapat
Reviewed-By: Michael Paquier
Discussion: https://postgr.es/m/CAFjFpRcz8yoY7cBTYofcrCLwjaDeCcGKyTUivUbRiA57y3v-bw%40mail.gmail.com

diff --git a/contrib/postgres_fdw/postgres_fdw.c b/contrib/postgres_fdw/postgres_fdw.c
index 64efbdff082227b2bdb9b7077de911eb4817663c..685259a00332085dde1e51cb85340e682f063dcf 100644 (file)
--- a/contrib/postgres_fdw/postgres_fdw.c
+++ b/contrib/postgres_fdw/postgres_fdw.c
@@ -391,6 +391,11 @@ static PgFdwModifyState *create_foreign_modify(EState *estate,
                                          List *target_attrs,
                                          bool has_returning,
                                          List *retrieved_attrs);
+static TupleTableSlot *execute_foreign_modify(EState *estate,
+                                          ResultRelInfo *resultRelInfo,
+                                          CmdType operation,
+                                          TupleTableSlot *slot,
+                                          TupleTableSlot *planSlot);
 static void prepare_foreign_modify(PgFdwModifyState *fmstate);
 static const char **convert_prep_stmt_params(PgFdwModifyState *fmstate,
                                                 ItemPointer tupleid,
@@ -1776,58 +1781,8 @@ postgresExecForeignInsert(EState *estate,
                                                  TupleTableSlot *slot,
                                                  TupleTableSlot *planSlot)
 {
-       PgFdwModifyState *fmstate = (PgFdwModifyState *) resultRelInfo->ri_FdwState;
-       const char **p_values;
-       PGresult   *res;
-       int                     n_rows;
-
-       /* Set up the prepared statement on the remote server, if we didn't yet */
-       if (!fmstate->p_name)
-               prepare_foreign_modify(fmstate);
-
-       /* Convert parameters needed by prepared statement to text form */
-       p_values = convert_prep_stmt_params(fmstate, NULL, slot);
-
-       /*
-        * Execute the prepared statement.
-        */
-       if (!PQsendQueryPrepared(fmstate->conn,
-                                                        fmstate->p_name,
-                                                        fmstate->p_nums,
-                                                        p_values,
-                                                        NULL,
-                                                        NULL,
-                                                        0))
-               pgfdw_report_error(ERROR, NULL, fmstate->conn, false, fmstate->query);
-
-       /*
-        * Get the result, and check for success.
-        *
-        * We don't use a PG_TRY block here, so be careful not to throw error
-        * without releasing the PGresult.
-        */
-       res = pgfdw_get_result(fmstate->conn, fmstate->query);
-       if (PQresultStatus(res) !=
-               (fmstate->has_returning ? PGRES_TUPLES_OK : PGRES_COMMAND_OK))
-               pgfdw_report_error(ERROR, res, fmstate->conn, true, fmstate->query);
-
-       /* Check number of rows affected, and fetch RETURNING tuple if any */
-       if (fmstate->has_returning)
-       {
-               n_rows = PQntuples(res);
-               if (n_rows > 0)
-                       store_returning_result(fmstate, slot, res);
-       }
-       else
-               n_rows = atoi(PQcmdTuples(res));
-
-       /* And clean up */
-       PQclear(res);
-
-       MemoryContextReset(fmstate->temp_cxt);
-
-       /* Return NULL if nothing was inserted on the remote end */
-       return (n_rows > 0) ? slot : NULL;
+       return execute_foreign_modify(estate, resultRelInfo, CMD_INSERT,
+                                                                 slot, planSlot);
 }
 
 /*
@@ -1840,70 +1795,8 @@ postgresExecForeignUpdate(EState *estate,
                                                  TupleTableSlot *slot,
                                                  TupleTableSlot *planSlot)
 {
-       PgFdwModifyState *fmstate = (PgFdwModifyState *) resultRelInfo->ri_FdwState;
-       Datum           datum;
-       bool            isNull;
-       const char **p_values;
-       PGresult   *res;
-       int                     n_rows;
-
-       /* Set up the prepared statement on the remote server, if we didn't yet */
-       if (!fmstate->p_name)
-               prepare_foreign_modify(fmstate);
-
-       /* Get the ctid that was passed up as a resjunk column */
-       datum = ExecGetJunkAttribute(planSlot,
-                                                                fmstate->ctidAttno,
-                                                                &isNull);
-       /* shouldn't ever get a null result... */
-       if (isNull)
-               elog(ERROR, "ctid is NULL");
-
-       /* Convert parameters needed by prepared statement to text form */
-       p_values = convert_prep_stmt_params(fmstate,
-                                                                               (ItemPointer) DatumGetPointer(datum),
-                                                                               slot);
-
-       /*
-        * Execute the prepared statement.
-        */
-       if (!PQsendQueryPrepared(fmstate->conn,
-                                                        fmstate->p_name,
-                                                        fmstate->p_nums,
-                                                        p_values,
-                                                        NULL,
-                                                        NULL,
-                                                        0))
-               pgfdw_report_error(ERROR, NULL, fmstate->conn, false, fmstate->query);
-
-       /*
-        * Get the result, and check for success.
-        *
-        * We don't use a PG_TRY block here, so be careful not to throw error
-        * without releasing the PGresult.
-        */
-       res = pgfdw_get_result(fmstate->conn, fmstate->query);
-       if (PQresultStatus(res) !=
-               (fmstate->has_returning ? PGRES_TUPLES_OK : PGRES_COMMAND_OK))
-               pgfdw_report_error(ERROR, res, fmstate->conn, true, fmstate->query);
-
-       /* Check number of rows affected, and fetch RETURNING tuple if any */
-       if (fmstate->has_returning)
-       {
-               n_rows = PQntuples(res);
-               if (n_rows > 0)
-                       store_returning_result(fmstate, slot, res);
-       }
-       else
-               n_rows = atoi(PQcmdTuples(res));
-
-       /* And clean up */
-       PQclear(res);
-
-       MemoryContextReset(fmstate->temp_cxt);
-
-       /* Return NULL if nothing was updated on the remote end */
-       return (n_rows > 0) ? slot : NULL;
+       return execute_foreign_modify(estate, resultRelInfo, CMD_UPDATE,
+                                                                 slot, planSlot);
 }
 
 /*
@@ -1916,70 +1809,8 @@ postgresExecForeignDelete(EState *estate,
                                                  TupleTableSlot *slot,
                                                  TupleTableSlot *planSlot)
 {
-       PgFdwModifyState *fmstate = (PgFdwModifyState *) resultRelInfo->ri_FdwState;
-       Datum           datum;
-       bool            isNull;
-       const char **p_values;
-       PGresult   *res;
-       int                     n_rows;
-
-       /* Set up the prepared statement on the remote server, if we didn't yet */
-       if (!fmstate->p_name)
-               prepare_foreign_modify(fmstate);
-
-       /* Get the ctid that was passed up as a resjunk column */
-       datum = ExecGetJunkAttribute(planSlot,
-                                                                fmstate->ctidAttno,
-                                                                &isNull);
-       /* shouldn't ever get a null result... */
-       if (isNull)
-               elog(ERROR, "ctid is NULL");
-
-       /* Convert parameters needed by prepared statement to text form */
-       p_values = convert_prep_stmt_params(fmstate,
-                                                                               (ItemPointer) DatumGetPointer(datum),
-                                                                               NULL);
-
-       /*
-        * Execute the prepared statement.
-        */
-       if (!PQsendQueryPrepared(fmstate->conn,
-                                                        fmstate->p_name,
-                                                        fmstate->p_nums,
-                                                        p_values,
-                                                        NULL,
-                                                        NULL,
-                                                        0))
-               pgfdw_report_error(ERROR, NULL, fmstate->conn, false, fmstate->query);
-
-       /*
-        * Get the result, and check for success.
-        *
-        * We don't use a PG_TRY block here, so be careful not to throw error
-        * without releasing the PGresult.
-        */
-       res = pgfdw_get_result(fmstate->conn, fmstate->query);
-       if (PQresultStatus(res) !=
-               (fmstate->has_returning ? PGRES_TUPLES_OK : PGRES_COMMAND_OK))
-               pgfdw_report_error(ERROR, res, fmstate->conn, true, fmstate->query);
-
-       /* Check number of rows affected, and fetch RETURNING tuple if any */
-       if (fmstate->has_returning)
-       {
-               n_rows = PQntuples(res);
-               if (n_rows > 0)
-                       store_returning_result(fmstate, slot, res);
-       }
-       else
-               n_rows = atoi(PQcmdTuples(res));
-
-       /* And clean up */
-       PQclear(res);
-
-       MemoryContextReset(fmstate->temp_cxt);
-
-       /* Return NULL if nothing was deleted on the remote end */
-       return (n_rows > 0) ? slot : NULL;
+       return execute_foreign_modify(estate, resultRelInfo, CMD_DELETE,
+                                                                 slot, planSlot);
 }
 
 /*
@@ -3425,6 +3256,98 @@ create_foreign_modify(EState *estate,
        return fmstate;
 }
 
+/*
+ * execute_foreign_modify
+ *             Perform foreign-table modification as required, and fetch RETURNING
+ *             result if any.  (This is the shared guts of postgresExecForeignInsert,
+ *             postgresExecForeignUpdate, and postgresExecForeignDelete.)
+ */
+static TupleTableSlot *
+execute_foreign_modify(EState *estate,
+                                          ResultRelInfo *resultRelInfo,
+                                          CmdType operation,
+                                          TupleTableSlot *slot,
+                                          TupleTableSlot *planSlot)
+{
+       PgFdwModifyState *fmstate = (PgFdwModifyState *) resultRelInfo->ri_FdwState;
+       ItemPointer     ctid = NULL;
+       const char **p_values;
+       PGresult   *res;
+       int                     n_rows;
+
+       /* The operation should be INSERT, UPDATE, or DELETE */
+       Assert(operation == CMD_INSERT ||
+                  operation == CMD_UPDATE ||
+                  operation == CMD_DELETE);
+
+       /* Set up the prepared statement on the remote server, if we didn't yet */
+       if (!fmstate->p_name)
+               prepare_foreign_modify(fmstate);
+
+       /*
+        * For UPDATE/DELETE, get the ctid that was passed up as a resjunk column
+        */
+       if (operation == CMD_UPDATE || operation == CMD_DELETE)
+       {
+               Datum           datum;
+               bool            isNull;
+
+               datum = ExecGetJunkAttribute(planSlot,
+                                                                        fmstate->ctidAttno,
+                                                                        &isNull);
+               /* shouldn't ever get a null result... */
+               if (isNull)
+                       elog(ERROR, "ctid is NULL");
+               ctid = (ItemPointer) DatumGetPointer(datum);
+       }
+
+       /* Convert parameters needed by prepared statement to text form */
+       p_values = convert_prep_stmt_params(fmstate, ctid, slot);
+
+       /*
+        * Execute the prepared statement.
+        */
+       if (!PQsendQueryPrepared(fmstate->conn,
+                                                        fmstate->p_name,
+                                                        fmstate->p_nums,
+                                                        p_values,
+                                                        NULL,
+                                                        NULL,
+                                                        0))
+               pgfdw_report_error(ERROR, NULL, fmstate->conn, false, fmstate->query);
+
+       /*
+        * Get the result, and check for success.
+        *
+        * We don't use a PG_TRY block here, so be careful not to throw error
+        * without releasing the PGresult.
+        */
+       res = pgfdw_get_result(fmstate->conn, fmstate->query);
+       if (PQresultStatus(res) !=
+               (fmstate->has_returning ? PGRES_TUPLES_OK : PGRES_COMMAND_OK))
+               pgfdw_report_error(ERROR, res, fmstate->conn, true, fmstate->query);
+
+       /* Check number of rows affected, and fetch RETURNING tuple if any */
+       if (fmstate->has_returning)
+       {
+               n_rows = PQntuples(res);
+               if (n_rows > 0)
+                       store_returning_result(fmstate, slot, res);
+       }
+       else
+               n_rows = atoi(PQcmdTuples(res));
+
+       /* And clean up */
+       PQclear(res);
+
+       MemoryContextReset(fmstate->temp_cxt);
+
+       /*
+        * Return NULL if nothing was inserted/updated/deleted on the remote end
+        */
+       return (n_rows > 0) ? slot : NULL;
+}
+
 /*
  * prepare_foreign_modify
  *             Establish a prepared statement for execution of INSERT/UPDATE/DELETE