so it has some chance of working in rules ...
<!--
-$Header: /cvsroot/pgsql/doc/src/sgml/ref/insert.sgml,v 1.22 2003/04/26 23:56:51 petere Exp $
+$Header: /cvsroot/pgsql/doc/src/sgml/ref/insert.sgml,v 1.23 2003/07/03 16:32:03 tgl Exp $
PostgreSQL documentation
-->
<para>
The columns in the target list may be listed in any order.
Each column not present in the target list will be inserted
- using a default value, either a declared default value
+ using a default value, either its declared default value
or null.
</para>
<term><literal>DEFAULT VALUES</literal></term>
<listitem>
<para>
- All columns will be filled their default values.
+ All columns will be filled with their default values.
</para>
</listitem>
</varlistentry>
<!--
-$Header: /cvsroot/pgsql/doc/src/sgml/ref/update.sgml,v 1.22 2003/06/25 04:19:24 momjian Exp $
+$Header: /cvsroot/pgsql/doc/src/sgml/ref/update.sgml,v 1.23 2003/07/03 16:32:12 tgl Exp $
PostgreSQL documentation
-->
<para>
<command>UPDATE</command> changes the values of the specified
columns in all rows that satisfy the condition. Only the columns to
- be modified need appear as columns in the statement.
+ be modified need be mentioned in the statement; columns not explicitly
+ <literal>SET</> retain their previous values.
</para>
<para>
<para>
You must have the <literal>UPDATE</literal> privilege on the table
to update it, as well as the <literal>SELECT</literal>
- privilege to any table whose values are read in the <replaceable
- class="parameter">condition</replaceable>.
+ privilege to any table whose values are read in the
+ <replaceable class="parameter">expression</replaceable>s or
+ <replaceable class="parameter">condition</replaceable>.
</para>
</refsect1>
<term><replaceable class="PARAMETER">expression</replaceable></term>
<listitem>
<para>
- An expression or value to assign to the column.
+ An expression to assign to the column. The expression may use the
+ old values of this and other columns in the table.
</para>
</listitem>
</varlistentry>
<term><literal>DEFAULT</literal></term>
<listitem>
<para>
- This column will be filled with its default value.
+ Set the column to its default value (which will be NULL if no
+ specific default expression has been assigned to it).
</para>
</listitem>
</varlistentry>
<listitem>
<para>
A list of table expressions, allowing columns from other tables
- to appear in the <literal>WHERE</> condition.
+ to appear in the <literal>WHERE</> condition and the update expressions.
</para>
</listitem>
</varlistentry>
<term><replaceable class="PARAMETER">condition</replaceable></term>
<listitem>
<para>
- A value expression that returns a value of type
- <type>boolean</type> that determines the rows which are to be
- updated.
+ An expression that returns a value of type <type>boolean</type>.
+ Only rows for which this expression returns <literal>true</>
+ will be updated.
</para>
</listitem>
</varlistentry>
column <structfield>kind</> of the table <literal>films</literal>:
<programlisting>
-UPDATE filme SET kind = 'Dramatic' WHERE kind = 'Drama';
+UPDATE films SET kind = 'Dramatic' WHERE kind = 'Drama';
</programlisting>
</para>
+
+ <para>
+ Adjust temperature entries and reset precipitation to its default
+ value in one row of the table <literal>weather</literal>:
+
+<programlisting>
+UPDATE weather SET temp_lo = temp_lo+1, temp_hi = temp_lo+15, prcp = DEFAULT
+ WHERE city = 'San Francisco' AND date = '2003-07-03';
+</programlisting>
+ </para>
+
</refsect1>
<refsect1>
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.258 2003/06/29 00:33:43 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.259 2003/07/03 16:32:20 tgl Exp $
*
*-------------------------------------------------------------------------
*/
return newnode;
}
+/*
+ * _copySetToDefault
+ */
+static SetToDefault *
+_copySetToDefault(SetToDefault *from)
+{
+ SetToDefault *newnode = makeNode(SetToDefault);
+
+ COPY_SCALAR_FIELD(typeId);
+ COPY_SCALAR_FIELD(typeMod);
+
+ return newnode;
+}
+
/*
* _copyTargetEntry
*/
return newnode;
}
-static SetToDefault *
-_copySetToDefault(SetToDefault *from)
-{
- SetToDefault *newnode = makeNode(SetToDefault);
-
- return newnode;
-}
-
static DeclareCursorStmt *
_copyDeclareCursorStmt(DeclareCursorStmt *from)
{
case T_CoerceToDomainValue:
retval = _copyCoerceToDomainValue(from);
break;
+ case T_SetToDefault:
+ retval = _copySetToDefault(from);
+ break;
case T_TargetEntry:
retval = _copyTargetEntry(from);
break;
case T_FuncWithArgs:
retval = _copyFuncWithArgs(from);
break;
- case T_SetToDefault:
- retval = _copySetToDefault(from);
- break;
default:
elog(ERROR, "copyObject: don't know how to copy node type %d",
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.201 2003/06/29 00:33:43 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.202 2003/07/03 16:32:32 tgl Exp $
*
*-------------------------------------------------------------------------
*/
return true;
}
+static bool
+_equalSetToDefault(SetToDefault *a, SetToDefault *b)
+{
+ COMPARE_SCALAR_FIELD(typeId);
+ COMPARE_SCALAR_FIELD(typeMod);
+
+ return true;
+}
+
static bool
_equalTargetEntry(TargetEntry *a, TargetEntry *b)
{
return true;
}
-static bool
-_equalSetToDefault(SetToDefault *a, SetToDefault *b)
-{
- return true;
-}
-
static bool
_equalDeclareCursorStmt(DeclareCursorStmt *a, DeclareCursorStmt *b)
{
case T_CoerceToDomainValue:
retval = _equalCoerceToDomainValue(a, b);
break;
+ case T_SetToDefault:
+ retval = _equalSetToDefault(a, b);
+ break;
case T_TargetEntry:
retval = _equalTargetEntry(a, b);
break;
case T_FuncWithArgs:
retval = _equalFuncWithArgs(a, b);
break;
- case T_SetToDefault:
- retval = _equalSetToDefault(a, b);
- break;
default:
elog(WARNING, "equal: don't know whether nodes of type %d are equal",
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.211 2003/06/29 00:33:43 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.212 2003/07/03 16:32:38 tgl Exp $
*
* NOTES
* Every node type that can appear in stored rules' parsetrees *must*
WRITE_INT_FIELD(typeMod);
}
+static void
+_outSetToDefault(StringInfo str, SetToDefault *node)
+{
+ WRITE_NODE_TYPE("SETTODEFAULT");
+
+ WRITE_OID_FIELD(typeId);
+ WRITE_INT_FIELD(typeMod);
+}
+
static void
_outTargetEntry(StringInfo str, TargetEntry *node)
{
case T_CoerceToDomainValue:
_outCoerceToDomainValue(str, obj);
break;
+ case T_SetToDefault:
+ _outSetToDefault(str, obj);
+ break;
case T_TargetEntry:
_outTargetEntry(str, obj);
break;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.157 2003/06/29 00:33:43 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.158 2003/07/03 16:32:39 tgl Exp $
*
* NOTES
* Path and Plan nodes do not have any readfuncs support, because we
READ_DONE();
}
+/*
+ * _readSetToDefault
+ */
+static SetToDefault *
+_readSetToDefault(void)
+{
+ READ_LOCALS(SetToDefault);
+
+ READ_OID_FIELD(typeId);
+ READ_INT_FIELD(typeMod);
+
+ READ_DONE();
+}
+
/*
* _readTargetEntry
*/
return_value = _readCoerceToDomain();
else if (MATCH("COERCETODOMAINVALUE", 19))
return_value = _readCoerceToDomainValue();
+ else if (MATCH("SETTODEFAULT", 12))
+ return_value = _readSetToDefault();
else if (MATCH("TARGETENTRY", 11))
return_value = _readTargetEntry();
else if (MATCH("RANGETBLREF", 11))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.144 2003/07/01 19:07:02 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.145 2003/07/03 16:33:07 tgl Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
case T_Const:
case T_Param:
case T_CoerceToDomainValue:
+ case T_SetToDefault:
case T_RangeTblRef:
/* primitive node types with no subnodes */
break;
case T_Const:
case T_Param:
case T_CoerceToDomainValue:
+ case T_SetToDefault:
case T_RangeTblRef:
/* primitive node types with no subnodes */
return (Node *) copyObject(node);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.424 2003/07/01 00:04:31 petere Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.425 2003/07/03 16:33:37 tgl Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
$$ = makeNode(ResTarget);
$$->name = $1;
$$->indirection = $2;
- $$->val = (Node *)$4;
+ $$->val = (Node *) $4;
}
| ColId opt_indirection '=' DEFAULT
{
- SetToDefault *def = makeNode(SetToDefault);
$$ = makeNode(ResTarget);
$$->name = $1;
- $$->indirection = NULL;
- $$->val = (Node *)def;
+ $$->indirection = $2;
+ $$->val = (Node *) makeNode(SetToDefault);
}
;
target_el { $$ = $1; }
| DEFAULT
{
- SetToDefault *def = makeNode(SetToDefault);
$$ = makeNode(ResTarget);
$$->name = NULL;
- $$->indirection = NULL;
- $$->val = (Node *)def;
+ $$->indirection = NIL;
+ $$->val = (Node *) makeNode(SetToDefault);
}
;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.154 2003/06/29 00:33:43 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.155 2003/07/03 16:34:16 tgl Exp $
*
*-------------------------------------------------------------------------
*/
case T_RelabelType:
case T_CoerceToDomain:
case T_CoerceToDomainValue:
+ case T_SetToDefault:
{
result = (Node *) expr;
break;
case T_CoerceToDomainValue:
type = ((CoerceToDomainValue *) expr)->typeId;
break;
+ case T_SetToDefault:
+ type = ((SetToDefault *) expr)->typeId;
+ break;
case T_RangeVar:
/*
* If someone uses a bare relation name in an expression,
return ((CoerceToDomain *) expr)->resulttypmod;
case T_CoerceToDomainValue:
return ((CoerceToDomainValue *) expr)->typeMod;
+ case T_SetToDefault:
+ return ((SetToDefault *) expr)->typeMod;
default:
break;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.105 2003/06/27 17:04:53 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.106 2003/07/03 16:34:20 tgl Exp $
*
*-------------------------------------------------------------------------
*/
false));
}
}
- else if (IsA(res->val, SetToDefault))
- {
- /*
- * If this is a DEFAULT element, we make a standard entry using
- * the default for the target expression. rewriteTargetList will
- * substitute the columns default for this expression.
- */
- p_target = lappend(p_target,
- makeTargetEntry(makeResdom((AttrNumber) pstate->p_next_resno++,
- UNKNOWNOID,
- -1,
- res->name,
- false),
- (Expr *) res->val));
- }
else
{
- /* Everything else but ColumnRef and SetToDefault */
+ /* Everything else but ColumnRef */
p_target = lappend(p_target,
transformTargetEntry(pstate,
res->val,
Oid type_id; /* type of value provided */
Oid attrtype; /* type of target column */
int32 attrtypmod;
- bool isDefault = false;
Resdom *resnode = tle->resdom;
Relation rd = pstate->p_target_relation;
attrtype = attnumTypeId(rd, attrno);
attrtypmod = rd->rd_att->attrs[attrno - 1]->atttypmod;
- /* The type of the default column is equivalent to that of the column */
- if (tle->expr != NULL && IsA(tle->expr, SetToDefault))
+ /*
+ * If the expression is a DEFAULT placeholder, insert the attribute's
+ * type/typmod into it so that exprType will report the right things.
+ * (We expect that the eventually substituted default expression will
+ * in fact have this type and typmod.) Also, reject trying to update
+ * an array element with DEFAULT, since there can't be any default for
+ * individual elements of a column.
+ */
+ if (tle->expr && IsA(tle->expr, SetToDefault))
{
- type_id = attrtype;
- isDefault = true;
+ SetToDefault *def = (SetToDefault *) tle->expr;
+
+ def->typeId = attrtype;
+ def->typeMod = attrtypmod;
+ if (indirection)
+ elog(ERROR, "cannot set an array element to DEFAULT");
}
- /* Otherwise the expression holds the type */
- else
- type_id = exprType((Node *) tle->expr);
+ /* Now we can use exprType() safely. */
+ type_id = exprType((Node *) tle->expr);
/*
* If there are subscripts on the target column, prepare an array
* coercion. But accept InvalidOid, which indicates the source is
* a NULL constant. (XXX is that still true?)
*/
- if (!isDefault && type_id != InvalidOid)
+ if (type_id != InvalidOid)
{
tle->expr = (Expr *)
coerce_to_target_type(pstate,
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.121 2003/06/25 04:19:24 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.122 2003/07/03 16:34:25 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* attributes that have defaults and are not assigned to in the given tlist.
* (We do not insert anything for default-less attributes, however. The
* planner will later insert NULLs for them, but there's no reason to slow
- * down rewriter processing with extra tlist nodes.)
+ * down rewriter processing with extra tlist nodes.) Also, for both INSERT
+ * and UPDATE, replace explicit DEFAULT specifications with column default
+ * expressions.
*
* 2. Merge multiple entries for the same target attribute, or declare error
* if we can't. Presently, multiple entries are only allowed for UPDATE of
{
Assert(strcmp(resdom->resname,
NameStr(att_tup->attname)) == 0);
-
- if (old_tle->expr != NULL && IsA(old_tle->expr, SetToDefault))
- {
- /* Set to the default value of the column, as requested */
- Node *new_expr;
-
- new_expr = build_column_default(target_relation, attrno);
-
- new_tle = makeTargetEntry(makeResdom(attrno,
- att_tup->atttypid,
- att_tup->atttypmod,
- pstrdup(NameStr(att_tup->attname)),
- false),
- (Expr *) new_expr);
- }
- else
- /* Normal Case */
- new_tle = process_matched_tle(old_tle, new_tle);
-
+ new_tle = process_matched_tle(old_tle, new_tle);
/* keep scanning to detect multiple assignments to attr */
}
}
- if (new_tle == NULL && commandType == CMD_INSERT)
+ /*
+ * Handle the two cases where we need to insert a default expression:
+ * it's an INSERT and there's no tlist entry for the column, or the
+ * tlist entry is a DEFAULT placeholder node.
+ */
+ if ((new_tle == NULL && commandType == CMD_INSERT) ||
+ (new_tle && new_tle->expr && IsA(new_tle->expr, SetToDefault)))
{
- /*
- * Didn't find a matching tlist entry; if it's an INSERT, look
- * for a default value, and add a tlist entry computing the
- * default if we find one.
- */
Node *new_expr;
new_expr = build_column_default(target_relation, attrno);
+ /*
+ * If there is no default (ie, default is effectively NULL),
+ * we can omit the tlist entry in the INSERT case, since the
+ * planner can insert a NULL for itself, and there's no point
+ * in spending any more rewriter cycles on the entry. But in the
+ * UPDATE case we've got to explicitly set the column to NULL.
+ */
+ if (!new_expr)
+ {
+ if (commandType == CMD_INSERT)
+ new_tle = NULL;
+ else
+ {
+ new_expr = (Node *) makeConst(att_tup->atttypid,
+ att_tup->attlen,
+ (Datum) 0,
+ true, /* isnull */
+ att_tup->attbyval);
+ /* this is to catch a NOT NULL domain constraint */
+ new_expr = coerce_to_domain(new_expr,
+ InvalidOid,
+ att_tup->atttypid,
+ COERCE_IMPLICIT_CAST);
+ }
+ }
+
if (new_expr)
new_tle = makeTargetEntry(makeResdom(attrno,
att_tup->atttypid,
* back to source text
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.143 2003/06/29 00:33:44 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.144 2003/07/03 16:34:25 tgl Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
appendStringInfo(buf, "VALUE");
break;
+ case T_SetToDefault:
+ appendStringInfo(buf, "DEFAULT");
+ break;
+
default:
elog(ERROR, "get_rule_expr: unknown node type %d", nodeTag(node));
break;
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: nodes.h,v 1.143 2003/06/29 00:33:44 tgl Exp $
+ * $Id: nodes.h,v 1.144 2003/07/03 16:34:25 tgl Exp $
*
*-------------------------------------------------------------------------
*/
T_BooleanTest,
T_CoerceToDomain,
T_CoerceToDomainValue,
+ T_SetToDefault,
T_TargetEntry,
T_RangeTblRef,
T_JoinExpr,
T_PrivGrantee,
T_FuncWithArgs,
T_PrivTarget,
- T_SetToDefault,
T_CreateOpClassItem,
T_CompositeTypeStmt,
T_InhRelation,
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: parsenodes.h,v 1.242 2003/06/29 00:33:44 tgl Exp $
+ * $Id: parsenodes.h,v 1.243 2003/07/03 16:34:25 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* assign */
} ResTarget;
-/*
- * Empty node used as a marker for Default Columns
- */
-typedef struct SetToDefault
-{
- NodeTag type;
-} SetToDefault;
-
/*
* SortGroupBy - for ORDER BY clause
*/
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: primnodes.h,v 1.86 2003/06/29 00:33:44 tgl Exp $
+ * $Id: primnodes.h,v 1.87 2003/07/03 16:34:26 tgl Exp $
*
*-------------------------------------------------------------------------
*/
int32 typeMod; /* typemod for substituted value */
} CoerceToDomainValue;
+/*
+ * Placeholder node for a DEFAULT marker in an INSERT or UPDATE command.
+ *
+ * This is not an executable expression: it must be replaced by the actual
+ * column default expression during rewriting. But it is convenient to
+ * treat it as an expression node during parsing and rewriting.
+ */
+typedef struct SetToDefault
+{
+ Expr xpr;
+ Oid typeId; /* type for substituted value */
+ int32 typeMod; /* typemod for substituted value */
+} SetToDefault;
/*
* TargetEntry -
projects / thirdparty / postgresql.git / commitdiff
