-<!-- $PostgreSQL: pgsql/doc/src/sgml/plpgsql.sgml,v 1.111 2007/06/11 15:08:32 tgl Exp $ -->
+<!-- $PostgreSQL: pgsql/doc/src/sgml/plpgsql.sgml,v 1.112 2007/06/11 22:22:40 tgl Exp $ -->
<chapter id="plpgsql">
<title><application>PL/pgSQL</application> - <acronym>SQL</acronym> Procedural Language</title>
MOVE curs1;
MOVE LAST FROM curs3;
MOVE RELATIVE -2 FROM curs4;
+</programlisting>
+ </para>
+ </sect3>
+
+ <sect3>
+ <title><literal>UPDATE/DELETE WHERE CURRENT OF</></title>
+
+<synopsis>
+UPDATE <replaceable>table</replaceable> SET ... WHERE CURRENT OF <replaceable>cursor</replaceable>;
+DELETE FROM <replaceable>table</replaceable> WHERE CURRENT OF <replaceable>cursor</replaceable>;
+</synopsis>
+
+ <para>
+ When a cursor is positioned on a table row, that row can be updated
+ or deleted using the cursor to identify the row. Note that this
+ only works for simple (non-join, non-grouping) cursor queries.
+ For additional information see the
+ <xref linkend="sql-declare" endterm="sql-declare-title">
+ reference page.
+ </para>
+
+ <para>
+ An example:
+<programlisting>
+UPDATE foo SET dataval = myval WHERE CURRENT OF curs1;
</programlisting>
</para>
</sect3>
* Portions Copyright (c) 1996-2007, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/backend/executor/execCurrent.c,v 1.1 2007/06/11 01:16:22 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/executor/execCurrent.c,v 1.2 2007/06/11 22:22:40 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
+#include "catalog/pg_type.h"
#include "executor/executor.h"
+#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/portal.h"
+static char *fetch_param_value(ExprContext *econtext, int paramId);
static ScanState *search_plan_tree(PlanState *node, Oid table_oid);
/*
* execCurrentOf
*
- * Given the name of a cursor and the OID of a table, determine which row
- * of the table is currently being scanned by the cursor, and return its
- * TID into *current_tid.
+ * Given a CURRENT OF expression and the OID of a table, determine which row
+ * of the table is currently being scanned by the cursor named by CURRENT OF,
+ * and return the row's TID into *current_tid.
*
* Returns TRUE if a row was identified. Returns FALSE if the cursor is valid
* for the table but is not currently scanning a row of the table (this is a
* valid updatable scan of the specified table.
*/
bool
-execCurrentOf(char *cursor_name, Oid table_oid,
+execCurrentOf(CurrentOfExpr *cexpr,
+ ExprContext *econtext,
+ Oid table_oid,
ItemPointer current_tid)
{
+ char *cursor_name;
char *table_name;
Portal portal;
QueryDesc *queryDesc;
ScanState *scanstate;
- HeapTuple tup;
+ bool lisnull;
+ Oid tuple_tableoid;
+ ItemPointer tuple_tid;
+
+ /* Get the cursor name --- may have to look up a parameter reference */
+ if (cexpr->cursor_name)
+ cursor_name = cexpr->cursor_name;
+ else
+ cursor_name = fetch_param_value(econtext, cexpr->cursor_param);
/* Fetch table name for possible use in error messages */
table_name = get_rel_name(table_oid);
if (TupIsNull(scanstate->ss_ScanTupleSlot))
return false;
- tup = scanstate->ss_ScanTupleSlot->tts_tuple;
- if (tup == NULL)
- elog(ERROR, "CURRENT OF applied to non-materialized tuple");
- Assert(tup->t_tableOid == table_oid);
+ /* Use slot_getattr to catch any possible mistakes */
+ tuple_tableoid = DatumGetObjectId(slot_getattr(scanstate->ss_ScanTupleSlot,
+ TableOidAttributeNumber,
+ &lisnull));
+ Assert(!lisnull);
+ tuple_tid = (ItemPointer)
+ DatumGetPointer(slot_getattr(scanstate->ss_ScanTupleSlot,
+ SelfItemPointerAttributeNumber,
+ &lisnull));
+ Assert(!lisnull);
+
+ Assert(tuple_tableoid == table_oid);
- *current_tid = tup->t_self;
+ *current_tid = *tuple_tid;
return true;
}
+/*
+ * fetch_param_value
+ *
+ * Fetch the string value of a param, verifying it is of type REFCURSOR.
+ */
+static char *
+fetch_param_value(ExprContext *econtext, int paramId)
+{
+ ParamListInfo paramInfo = econtext->ecxt_param_list_info;
+
+ if (paramInfo &&
+ paramId > 0 && paramId <= paramInfo->numParams)
+ {
+ ParamExternData *prm = ¶mInfo->params[paramId - 1];
+
+ if (OidIsValid(prm->ptype) && !prm->isnull)
+ {
+ Assert(prm->ptype == REFCURSOROID);
+ /* We know that refcursor uses text's I/O routines */
+ return DatumGetCString(DirectFunctionCall1(textout,
+ prm->value));
+ }
+ }
+
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("no value found for parameter %d", paramId)));
+ return NULL;
+}
+
/*
* search_plan_tree
*
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/executor/execQual.c,v 1.219 2007/06/11 01:16:22 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/executor/execQual.c,v 1.220 2007/06/11 22:22:40 tgl Exp $
*
*-------------------------------------------------------------------------
*/
bool *isNull, ExprDoneCond *isDone)
{
CurrentOfExpr *cexpr = (CurrentOfExpr *) exprstate->expr;
- bool result;
- HeapTuple tup;
+ bool result;
+ bool lisnull;
+ Oid tableoid;
+ ItemPointer tuple_tid;
ItemPointerData cursor_tid;
if (isDone)
Assert(cexpr->cvarno != INNER);
Assert(cexpr->cvarno != OUTER);
Assert(!TupIsNull(econtext->ecxt_scantuple));
- tup = econtext->ecxt_scantuple->tts_tuple;
- if (tup == NULL)
- elog(ERROR, "CURRENT OF applied to non-materialized tuple");
-
- if (execCurrentOf(cexpr->cursor_name, tup->t_tableOid, &cursor_tid))
- result = ItemPointerEquals(&cursor_tid, &(tup->t_self));
+ /* Use slot_getattr to catch any possible mistakes */
+ tableoid = DatumGetObjectId(slot_getattr(econtext->ecxt_scantuple,
+ TableOidAttributeNumber,
+ &lisnull));
+ Assert(!lisnull);
+ tuple_tid = (ItemPointer)
+ DatumGetPointer(slot_getattr(econtext->ecxt_scantuple,
+ SelfItemPointerAttributeNumber,
+ &lisnull));
+ Assert(!lisnull);
+
+ if (execCurrentOf(cexpr, econtext, tableoid, &cursor_tid))
+ result = ItemPointerEquals(&cursor_tid, tuple_tid);
else
result = false;
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/executor/nodeTidscan.c,v 1.54 2007/06/11 01:16:22 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/executor/nodeTidscan.c,v 1.55 2007/06/11 22:22:40 tgl Exp $
*
*-------------------------------------------------------------------------
*/
CurrentOfExpr *cexpr = (CurrentOfExpr *) expr;
ItemPointerData cursor_tid;
- if (execCurrentOf(cexpr->cursor_name,
+ if (execCurrentOf(cexpr, econtext,
RelationGetRelid(tidstate->ss.ss_currentRelation),
&cursor_tid))
{
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.378 2007/06/11 01:16:22 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.379 2007/06/11 22:22:40 tgl Exp $
*
*-------------------------------------------------------------------------
*/
COPY_SCALAR_FIELD(cvarno);
COPY_STRING_FIELD(cursor_name);
+ COPY_SCALAR_FIELD(cursor_param);
return newnode;
}
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/nodes/equalfuncs.c,v 1.309 2007/06/11 01:16:22 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/nodes/equalfuncs.c,v 1.310 2007/06/11 22:22:40 tgl Exp $
*
*-------------------------------------------------------------------------
*/
{
COMPARE_SCALAR_FIELD(cvarno);
COMPARE_STRING_FIELD(cursor_name);
+ COMPARE_SCALAR_FIELD(cursor_param);
return true;
}
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/nodes/outfuncs.c,v 1.310 2007/06/11 01:16:22 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/nodes/outfuncs.c,v 1.311 2007/06/11 22:22:40 tgl Exp $
*
* NOTES
* Every node type that can appear in stored rules' parsetrees *must*
WRITE_UINT_FIELD(cvarno);
WRITE_STRING_FIELD(cursor_name);
+ WRITE_INT_FIELD(cursor_param);
}
static void
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/nodes/readfuncs.c,v 1.208 2007/06/11 01:16:22 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/nodes/readfuncs.c,v 1.209 2007/06/11 22:22:41 tgl Exp $
*
* NOTES
* Path and Plan nodes do not have any readfuncs support, because we
READ_UINT_FIELD(cvarno);
READ_STRING_FIELD(cursor_name);
+ READ_INT_FIELD(cursor_param);
READ_DONE();
}
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/parser/gram.y,v 2.592 2007/06/11 01:16:25 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/parser/gram.y,v 2.593 2007/06/11 22:22:41 tgl Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
| WHERE CURRENT_P OF name
{
CurrentOfExpr *n = makeNode(CurrentOfExpr);
+ /* cvarno is filled in by parse analysis */
n->cursor_name = $4;
+ n->cursor_param = 0;
+ $$ = (Node *) n;
+ }
+ | WHERE CURRENT_P OF PARAM
+ {
+ CurrentOfExpr *n = makeNode(CurrentOfExpr);
+ /* cvarno is filled in by parse analysis */
+ n->cursor_name = NULL;
+ n->cursor_param = $4;
$$ = (Node *) n;
}
| /*EMPTY*/ { $$ = NULL; }
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/parser/parse_expr.c,v 1.219 2007/06/11 01:16:25 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/parser/parse_expr.c,v 1.220 2007/06/11 22:22:42 tgl Exp $
*
*-------------------------------------------------------------------------
*/
static Node *transformXmlExpr(ParseState *pstate, XmlExpr *x);
static Node *transformXmlSerialize(ParseState *pstate, XmlSerialize *xs);
static Node *transformBooleanTest(ParseState *pstate, BooleanTest *b);
+static Node *transformCurrentOfExpr(ParseState *pstate, CurrentOfExpr *cexpr);
static Node *transformColumnRef(ParseState *pstate, ColumnRef *cref);
static Node *transformWholeRowRef(ParseState *pstate, char *schemaname,
char *relname, int location);
-static Node *transformBooleanTest(ParseState *pstate, BooleanTest *b);
static Node *transformIndirection(ParseState *pstate, Node *basenode,
List *indirection);
static Node *typecast_expression(ParseState *pstate, Node *expr,
break;
case T_CurrentOfExpr:
- {
- CurrentOfExpr *c = (CurrentOfExpr *) expr;
- int sublevels_up;
-
- /* CURRENT OF can only appear at top level of UPDATE/DELETE */
- Assert(pstate->p_target_rangetblentry != NULL);
- c->cvarno = RTERangeTablePosn(pstate,
- pstate->p_target_rangetblentry,
- &sublevels_up);
- Assert(sublevels_up == 0);
- result = expr;
- break;
- }
+ result = transformCurrentOfExpr(pstate, (CurrentOfExpr *) expr);
+ break;
/*********************************************
* Quietly accept node types that may be presented when we are
return node;
}
-static Node *
-transformParamRef(ParseState *pstate, ParamRef *pref)
+/*
+ * Locate the parameter type info for the given parameter number, and
+ * return a pointer to it.
+ */
+static Oid *
+find_param_type(ParseState *pstate, int paramno)
{
- int paramno = pref->number;
- ParseState *toppstate;
- Param *param;
+ Oid *result;
/*
* Find topmost ParseState, which is where paramtype info lives.
*/
- toppstate = pstate;
- while (toppstate->parentParseState != NULL)
- toppstate = toppstate->parentParseState;
+ while (pstate->parentParseState != NULL)
+ pstate = pstate->parentParseState;
/* Check parameter number is in range */
if (paramno <= 0) /* probably can't happen? */
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_PARAMETER),
errmsg("there is no parameter $%d", paramno)));
- if (paramno > toppstate->p_numparams)
+ if (paramno > pstate->p_numparams)
{
- if (!toppstate->p_variableparams)
+ if (!pstate->p_variableparams)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_PARAMETER),
errmsg("there is no parameter $%d",
paramno)));
/* Okay to enlarge param array */
- if (toppstate->p_paramtypes)
- toppstate->p_paramtypes =
- (Oid *) repalloc(toppstate->p_paramtypes,
- paramno * sizeof(Oid));
+ if (pstate->p_paramtypes)
+ pstate->p_paramtypes = (Oid *) repalloc(pstate->p_paramtypes,
+ paramno * sizeof(Oid));
else
- toppstate->p_paramtypes =
- (Oid *) palloc(paramno * sizeof(Oid));
+ pstate->p_paramtypes = (Oid *) palloc(paramno * sizeof(Oid));
/* Zero out the previously-unreferenced slots */
- MemSet(toppstate->p_paramtypes + toppstate->p_numparams,
+ MemSet(pstate->p_paramtypes + pstate->p_numparams,
0,
- (paramno - toppstate->p_numparams) * sizeof(Oid));
- toppstate->p_numparams = paramno;
+ (paramno - pstate->p_numparams) * sizeof(Oid));
+ pstate->p_numparams = paramno;
}
- if (toppstate->p_variableparams)
+
+ result = &pstate->p_paramtypes[paramno - 1];
+
+ if (pstate->p_variableparams)
{
/* If not seen before, initialize to UNKNOWN type */
- if (toppstate->p_paramtypes[paramno - 1] == InvalidOid)
- toppstate->p_paramtypes[paramno - 1] = UNKNOWNOID;
+ if (*result == InvalidOid)
+ *result = UNKNOWNOID;
}
+ return result;
+}
+
+static Node *
+transformParamRef(ParseState *pstate, ParamRef *pref)
+{
+ int paramno = pref->number;
+ Oid *pptype = find_param_type(pstate, paramno);
+ Param *param;
+
param = makeNode(Param);
param->paramkind = PARAM_EXTERN;
param->paramid = paramno;
- param->paramtype = toppstate->p_paramtypes[paramno - 1];
+ param->paramtype = *pptype;
param->paramtypmod = -1;
return (Node *) param;
return (Node *) b;
}
+static Node *
+transformCurrentOfExpr(ParseState *pstate, CurrentOfExpr *cexpr)
+{
+ int sublevels_up;
+
+ /* CURRENT OF can only appear at top level of UPDATE/DELETE */
+ Assert(pstate->p_target_rangetblentry != NULL);
+ cexpr->cvarno = RTERangeTablePosn(pstate,
+ pstate->p_target_rangetblentry,
+ &sublevels_up);
+ Assert(sublevels_up == 0);
+
+ /* If a parameter is used, it must be of type REFCURSOR */
+ if (cexpr->cursor_name == NULL)
+ {
+ Oid *pptype = find_param_type(pstate, cexpr->cursor_param);
+
+ if (pstate->p_variableparams && *pptype == UNKNOWNOID)
+ {
+ /* resolve unknown param type as REFCURSOR */
+ *pptype = REFCURSOROID;
+ }
+ else if (*pptype != REFCURSOROID)
+ {
+ ereport(ERROR,
+ (errcode(ERRCODE_AMBIGUOUS_PARAMETER),
+ errmsg("inconsistent types deduced for parameter $%d",
+ cexpr->cursor_param),
+ errdetail("%s versus %s",
+ format_type_be(*pptype),
+ format_type_be(REFCURSOROID))));
+ }
+ }
+
+ return (Node *) cexpr;
+}
+
/*
* Construct a whole-row reference to represent the notation "relation.*".
*
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/adt/ruleutils.c,v 1.260 2007/06/11 01:16:29 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/adt/ruleutils.c,v 1.261 2007/06/11 22:22:42 tgl Exp $
*
*-------------------------------------------------------------------------
*/
break;
case T_CurrentOfExpr:
- appendStringInfo(buf, "CURRENT OF %s",
- quote_identifier(((CurrentOfExpr *) node)->cursor_name));
+ {
+ CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
+
+ if (cexpr->cursor_name)
+ appendStringInfo(buf, "CURRENT OF %s",
+ quote_identifier(cexpr->cursor_name));
+ else
+ appendStringInfo(buf, "CURRENT OF $%d",
+ cexpr->cursor_param);
+ }
break;
case T_List:
* Portions Copyright (c) 1996-2007, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/executor/executor.h,v 1.140 2007/06/11 01:16:30 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/executor/executor.h,v 1.141 2007/06/11 22:22:42 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/*
* prototypes from functions in execCurrent.c
*/
-extern bool execCurrentOf(char *cursor_name, Oid table_oid,
+extern bool execCurrentOf(CurrentOfExpr *cexpr,
+ ExprContext *econtext,
+ Oid table_oid,
ItemPointer current_tid);
/*
* Portions Copyright (c) 1996-2007, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/nodes/primnodes.h,v 1.131 2007/06/11 01:16:30 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/nodes/primnodes.h,v 1.132 2007/06/11 22:22:42 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* of the target relation being constrained; this aids placing the expression
* correctly during planning. We can assume however that its "levelsup" is
* always zero, due to the syntactic constraints on where it can appear.
+ *
+ * The referenced cursor can be represented either as a hardwired string
+ * or as a reference to a run-time parameter of type REFCURSOR. The latter
+ * case is for the convenience of plpgsql.
*/
typedef struct CurrentOfExpr
{
Expr xpr;
Index cvarno; /* RT index of target relation */
- char *cursor_name; /* name of referenced cursor */
+ char *cursor_name; /* name of referenced cursor, or NULL */
+ int cursor_param; /* refcursor parameter number, or 0 */
} CurrentOfExpr;
/*--------------------
projects / postgresql.git / commitdiff