summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorTom Lane2009-01-07 20:38:56 +0000
committerTom Lane2009-01-07 20:38:56 +0000
commit79e0fb76d4ef772cccff3f9740f380462c5eceb9 (patch)
tree59a013d95828ef7c9e292b0b1072825000e390b6
parentfe68180ea07285273c30268e033897ed1eaafd45 (diff)
Insert conditional SPI_push/SPI_pop calls into InputFunctionCall,
OutputFunctionCall, and friends. This allows SPI-using functions to invoke datatype I/O without concern for the possibility that a SPI-using function will be called (which could be either the I/O function itself, or a function used in a domain check constraint). It's a tad ugly, but not nearly as ugly as what'd be needed to make this work via retail insertion of push/pop operations in all the PLs. This reverts my patch of 2007-01-30 that inserted some retail SPI_push/pop calls into plpgsql; that approach only fixed plpgsql, and not any other PLs. But the other PLs have the issue too, as illustrated by a recent gripe from Christian Schröder. Back-patch to 8.2, which is as far back as this solution will work. It's also as far back as we need to worry about the domain-constraint case, since earlier versions did not attempt to check domain constraints within datatype input. I'm not aware of any old I/O functions that use SPI themselves, so this should be sufficient for a back-patch.
-rw-r--r--src/backend/executor/spi.c25
-rw-r--r--src/backend/utils/fmgr/fmgr.c53
-rw-r--r--src/include/executor/spi.h2
-rw-r--r--src/pl/plpgsql/src/pl_exec.c29
4 files changed, 73 insertions, 36 deletions
diff --git a/src/backend/executor/spi.c b/src/backend/executor/spi.c
index 3a3fd5962f..a49f14f12d 100644
--- a/src/backend/executor/spi.c
+++ b/src/backend/executor/spi.c
@@ -304,6 +304,31 @@ SPI_pop(void)
_SPI_curid--;
}
+/* Conditional push: push only if we're inside a SPI procedure */
+bool
+SPI_push_conditional(void)
+{
+ bool pushed = (_SPI_curid != _SPI_connected);
+
+ if (pushed)
+ {
+ _SPI_curid++;
+ /* We should now be in a state where SPI_connect would succeed */
+ Assert(_SPI_curid == _SPI_connected);
+ }
+ return pushed;
+}
+
+/* Conditional pop: pop only if SPI_push_conditional pushed */
+void
+SPI_pop_conditional(bool pushed)
+{
+ /* We should be in a state where SPI_connect would succeed */
+ Assert(_SPI_curid == _SPI_connected);
+ if (pushed)
+ _SPI_curid--;
+}
+
/* Restore state of SPI stack after aborting a subtransaction */
void
SPI_restore_connection(void)
diff --git a/src/backend/utils/fmgr/fmgr.c b/src/backend/utils/fmgr/fmgr.c
index f5e9696a7f..a6d8f3d075 100644
--- a/src/backend/utils/fmgr/fmgr.c
+++ b/src/backend/utils/fmgr/fmgr.c
@@ -19,6 +19,7 @@
#include "catalog/pg_language.h"
#include "catalog/pg_proc.h"
#include "executor/functions.h"
+#include "executor/spi.h"
#include "lib/stringinfo.h"
#include "miscadmin.h"
#include "nodes/nodeFuncs.h"
@@ -1846,16 +1847,25 @@ OidFunctionCall9(Oid functionId, Datum arg1, Datum arg2,
* the caller should assume the result is NULL, but we'll call the input
* function anyway if it's not strict. So this is almost but not quite
* the same as FunctionCall3.
+ *
+ * One important difference from the bare function call is that we will
+ * push any active SPI context, allowing SPI-using I/O functions to be
+ * called from other SPI functions without extra notation. This is a hack,
+ * but the alternative of expecting all SPI functions to do SPI_push/SPI_pop
+ * around I/O calls seems worse.
*/
Datum
InputFunctionCall(FmgrInfo *flinfo, char *str, Oid typioparam, int32 typmod)
{
FunctionCallInfoData fcinfo;
Datum result;
+ bool pushed;
if (str == NULL && flinfo->fn_strict)
return (Datum) 0; /* just return null result */
+ pushed = SPI_push_conditional();
+
InitFunctionCallInfoData(fcinfo, flinfo, 3, NULL, NULL);
fcinfo.arg[0] = CStringGetDatum(str);
@@ -1881,6 +1891,8 @@ InputFunctionCall(FmgrInfo *flinfo, char *str, Oid typioparam, int32 typmod)
fcinfo.flinfo->fn_oid);
}
+ SPI_pop_conditional(pushed);
+
return result;
}
@@ -1889,13 +1901,22 @@ InputFunctionCall(FmgrInfo *flinfo, char *str, Oid typioparam, int32 typmod)
*
* Do not call this on NULL datums.
*
- * This is mere window dressing for FunctionCall1, but its use is recommended
- * anyway so that code invoking output functions can be identified easily.
+ * This is almost just window dressing for FunctionCall1, but it includes
+ * SPI context pushing for the same reasons as InputFunctionCall.
*/
char *
OutputFunctionCall(FmgrInfo *flinfo, Datum val)
{
- return DatumGetCString(FunctionCall1(flinfo, val));
+ char *result;
+ bool pushed;
+
+ pushed = SPI_push_conditional();
+
+ result = DatumGetCString(FunctionCall1(flinfo, val));
+
+ SPI_pop_conditional(pushed);
+
+ return result;
}
/*
@@ -1904,7 +1925,8 @@ OutputFunctionCall(FmgrInfo *flinfo, Datum val)
* "buf" may be NULL to indicate we are reading a NULL. In this case
* the caller should assume the result is NULL, but we'll call the receive
* function anyway if it's not strict. So this is almost but not quite
- * the same as FunctionCall3.
+ * the same as FunctionCall3. Also, this includes SPI context pushing for
+ * the same reasons as InputFunctionCall.
*/
Datum
ReceiveFunctionCall(FmgrInfo *flinfo, StringInfo buf,
@@ -1912,10 +1934,13 @@ ReceiveFunctionCall(FmgrInfo *flinfo, StringInfo buf,
{
FunctionCallInfoData fcinfo;
Datum result;
+ bool pushed;
if (buf == NULL && flinfo->fn_strict)
return (Datum) 0; /* just return null result */
+ pushed = SPI_push_conditional();
+
InitFunctionCallInfoData(fcinfo, flinfo, 3, NULL, NULL);
fcinfo.arg[0] = PointerGetDatum(buf);
@@ -1941,6 +1966,8 @@ ReceiveFunctionCall(FmgrInfo *flinfo, StringInfo buf,
fcinfo.flinfo->fn_oid);
}
+ SPI_pop_conditional(pushed);
+
return result;
}
@@ -1949,14 +1976,24 @@ ReceiveFunctionCall(FmgrInfo *flinfo, StringInfo buf,
*
* Do not call this on NULL datums.
*
- * This is little more than window dressing for FunctionCall1, but its use is
- * recommended anyway so that code invoking output functions can be identified
- * easily. Note however that it does guarantee a non-toasted result.
+ * This is little more than window dressing for FunctionCall1, but it does
+ * guarantee a non-toasted result, which strictly speaking the underlying
+ * function doesn't. Also, this includes SPI context pushing for the same
+ * reasons as InputFunctionCall.
*/
bytea *
SendFunctionCall(FmgrInfo *flinfo, Datum val)
{
- return DatumGetByteaP(FunctionCall1(flinfo, val));
+ bytea *result;
+ bool pushed;
+
+ pushed = SPI_push_conditional();
+
+ result = DatumGetByteaP(FunctionCall1(flinfo, val));
+
+ SPI_pop_conditional(pushed);
+
+ return result;
}
/*
diff --git a/src/include/executor/spi.h b/src/include/executor/spi.h
index cf331d5147..1c422cfa13 100644
--- a/src/include/executor/spi.h
+++ b/src/include/executor/spi.h
@@ -66,6 +66,8 @@ extern int SPI_connect(void);
extern int SPI_finish(void);
extern void SPI_push(void);
extern void SPI_pop(void);
+extern bool SPI_push_conditional(void);
+extern void SPI_pop_conditional(bool pushed);
extern void SPI_restore_connection(void);
extern int SPI_execute(const char *src, bool read_only, long tcount);
extern int SPI_execute_plan(SPIPlanPtr plan, Datum *Values, const char *Nulls,
diff --git a/src/pl/plpgsql/src/pl_exec.c b/src/pl/plpgsql/src/pl_exec.c
index 13099e6ba8..fcb3648372 100644
--- a/src/pl/plpgsql/src/pl_exec.c
+++ b/src/pl/plpgsql/src/pl_exec.c
@@ -4690,27 +4690,11 @@ make_tuple_from_row(PLpgSQL_execstate *estate,
static char *
convert_value_to_string(Datum value, Oid valtype)
{
- char *str;
Oid typoutput;
bool typIsVarlena;
getTypeOutputInfo(valtype, &typoutput, &typIsVarlena);
-
- /*
- * We do SPI_push to allow the datatype output function to use SPI.
- * However we do not mess around with CommandCounterIncrement or advancing
- * the snapshot, which means that a stable output function would not see
- * updates made so far by our own function. The use-case for such
- * scenarios seems too narrow to justify the cycles that would be
- * expended.
- */
- SPI_push();
-
- str = OidOutputFunctionCall(typoutput, value);
-
- SPI_pop();
-
- return str;
+ return OidOutputFunctionCall(typoutput, value);
}
/* ----------
@@ -4736,25 +4720,14 @@ exec_cast_value(Datum value, Oid valtype,
char *extval;
extval = convert_value_to_string(value, valtype);
-
- /* Allow input function to use SPI ... see notes above */
- SPI_push();
-
value = InputFunctionCall(reqinput, extval,
reqtypioparam, reqtypmod);
-
- SPI_pop();
-
pfree(extval);
}
else
{
- SPI_push();
-
value = InputFunctionCall(reqinput, NULL,
reqtypioparam, reqtypmod);
-
- SPI_pop();
}
}