Speed up COPY into tables with DEFAULT nextval()

Previously the presence of a nextval() prevented the
use of batch-mode COPY.  This patch introduces a
special case just for nextval() functions. In future
we will introduce a general case solution for
labelling volatile functions as safe for use.

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index f91f1646dac28e474d30685c52d9f85d3ad09d22..7c4039cb7ff2d225248ef8bdacabd385d25cf540 100644 (file)
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -2519,9 +2519,20 @@ BeginCopyFrom(Relation rel,
                                defmap[num_defaults] = attnum - 1;
                                num_defaults++;
 
-                               /* Check to see if we have any volatile expressions */
+                               /*
+                                * If a default expression looks at the table being loaded, then
+                                * it could give the wrong answer when using multi-insert. Since
+                                * database access can be dynamic this is hard to test for
+                                * exactly, so we use the much wider test of whether the
+                                * default expression is volatile. We allow for the special case
+                                * of when the default expression is the nextval() of a sequence
+                                * which in this specific case is known to be safe for use with
+                                * the multi-insert optimisation. Hence we use this special case
+                                * function checker rather than the standard check for
+                                * contain_volatile_functions().
+                                */
                                if (!volatile_defexprs)
-                                       volatile_defexprs = contain_volatile_functions((Node *) defexpr);
+                                       volatile_defexprs = contain_volatile_functions_not_nextval((Node *)defexpr);
                        }
                }
        }

diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c
index e0dbaf7e4e531924d7a799d44586438cefdbb0d5..201529b885a6211a16e5565695645e5d620d4a4b 100644 (file)
--- a/src/backend/optimizer/util/clauses.c
+++ b/src/backend/optimizer/util/clauses.c
@@ -45,6 +45,7 @@
 #include "utils/acl.h"
 #include "utils/builtins.h"
 #include "utils/datum.h"
+#include "utils/fmgroids.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
 #include "utils/syscache.h"
@@ -94,6 +95,7 @@ static bool expression_returns_set_rows_walker(Node *node, double *count);
 static bool contain_subplans_walker(Node *node, void *context);
 static bool contain_mutable_functions_walker(Node *node, void *context);
 static bool contain_volatile_functions_walker(Node *node, void *context);
+static bool contain_volatile_functions_not_nextval_walker(Node *node, void *context);
 static bool contain_nonstrict_functions_walker(Node *node, void *context);
 static bool contain_leaky_functions_walker(Node *node, void *context);
 static Relids find_nonnullable_rels_walker(Node *node, bool top_level);
@@ -971,6 +973,19 @@ contain_volatile_functions(Node *clause)
        return contain_volatile_functions_walker(clause, NULL);
 }
 
+bool
+contain_volatile_functions_not_nextval(Node *clause)
+{
+       return contain_volatile_functions_not_nextval_walker(clause, NULL);
+}
+
+/*
+ * General purpose code for checking expression volatility.
+ *
+ * Special purpose code for use in COPY is almost identical to this,
+ * so any changes here may also be needed in other contain_volatile...
+ * functions.
+ */
 static bool
 contain_volatile_functions_walker(Node *node, void *context)
 {
@@ -1072,6 +1087,107 @@ contain_volatile_functions_walker(Node *node, void *context)
                                                                  context);
 }
 
+/*
+ * Special purpose version of contain_volatile_functions for use in COPY
+ */
+static bool
+contain_volatile_functions_not_nextval_walker(Node *node, void *context)
+{
+       if (node == NULL)
+               return false;
+       if (IsA(node, FuncExpr))
+       {
+               FuncExpr   *expr = (FuncExpr *) node;
+
+               /*
+                * For this case only, we want to ignore the volatility of the
+                * nextval() function, since some callers want this.
+                */
+               if (expr->funcid != F_NEXTVAL_OID &&
+                       func_volatile(expr->funcid) == PROVOLATILE_VOLATILE)
+                       return true;
+               /* else fall through to check args */
+       }
+       else if (IsA(node, OpExpr))
+       {
+               OpExpr     *expr = (OpExpr *) node;
+
+               set_opfuncid(expr);
+               if (func_volatile(expr->opfuncid) == PROVOLATILE_VOLATILE)
+                       return true;
+               /* else fall through to check args */
+       }
+       else if (IsA(node, DistinctExpr))
+       {
+               DistinctExpr *expr = (DistinctExpr *) node;
+
+               set_opfuncid((OpExpr *) expr);  /* rely on struct equivalence */
+               if (func_volatile(expr->opfuncid) == PROVOLATILE_VOLATILE)
+                       return true;
+               /* else fall through to check args */
+       }
+       else if (IsA(node, NullIfExpr))
+       {
+               NullIfExpr *expr = (NullIfExpr *) node;
+
+               set_opfuncid((OpExpr *) expr);  /* rely on struct equivalence */
+               if (func_volatile(expr->opfuncid) == PROVOLATILE_VOLATILE)
+                       return true;
+               /* else fall through to check args */
+       }
+       else if (IsA(node, ScalarArrayOpExpr))
+       {
+               ScalarArrayOpExpr *expr = (ScalarArrayOpExpr *) node;
+
+               set_sa_opfuncid(expr);
+               if (func_volatile(expr->opfuncid) == PROVOLATILE_VOLATILE)
+                       return true;
+               /* else fall through to check args */
+       }
+       else if (IsA(node, CoerceViaIO))
+       {
+               CoerceViaIO *expr = (CoerceViaIO *) node;
+               Oid                     iofunc;
+               Oid                     typioparam;
+               bool            typisvarlena;
+
+               /* check the result type's input function */
+               getTypeInputInfo(expr->resulttype,
+                                                &iofunc, &typioparam);
+               if (func_volatile(iofunc) == PROVOLATILE_VOLATILE)
+                       return true;
+               /* check the input type's output function */
+               getTypeOutputInfo(exprType((Node *) expr->arg),
+                                                 &iofunc, &typisvarlena);
+               if (func_volatile(iofunc) == PROVOLATILE_VOLATILE)
+                       return true;
+               /* else fall through to check args */
+       }
+       else if (IsA(node, ArrayCoerceExpr))
+       {
+               ArrayCoerceExpr *expr = (ArrayCoerceExpr *) node;
+
+               if (OidIsValid(expr->elemfuncid) &&
+                       func_volatile(expr->elemfuncid) == PROVOLATILE_VOLATILE)
+                       return true;
+               /* else fall through to check args */
+       }
+       else if (IsA(node, RowCompareExpr))
+       {
+               /* RowCompare probably can't have volatile ops, but check anyway */
+               RowCompareExpr *rcexpr = (RowCompareExpr *) node;
+               ListCell   *opid;
+
+               foreach(opid, rcexpr->opnos)
+               {
+                       if (op_volatile(lfirst_oid(opid)) == PROVOLATILE_VOLATILE)
+                               return true;
+               }
+               /* else fall through to check args */
+       }
+       return expression_tree_walker(node, contain_volatile_functions_not_nextval_walker,
+                                                                 context);
+}
 
 /*****************************************************************************
  *             Check clauses for nonstrict functions

diff --git a/src/include/optimizer/clauses.h b/src/include/optimizer/clauses.h
index 53484ff8c0604182a3e29de0e2e40c439c850770..dd991b16bce0da3ea5c8ff3d2c4bd25a952ea980 100644 (file)
--- a/src/include/optimizer/clauses.h
+++ b/src/include/optimizer/clauses.h
@@ -61,6 +61,7 @@ extern bool contain_subplans(Node *clause);
 
 extern bool contain_mutable_functions(Node *clause);
 extern bool contain_volatile_functions(Node *clause);
+extern bool contain_volatile_functions_not_nextval(Node *clause);
 extern bool contain_nonstrict_functions(Node *clause);
 extern bool contain_leaky_functions(Node *clause);