database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-07-31 22:04:40 +03:00
Code Activity

Merge the Constraint and FkConstraint node types into a single type.

Browse Source 
This was foreseen to be a good idea long ago, but nobody had got round
to doing it.  The recent patch for deferred unique constraints made
transformConstraintAttrs() ugly enough that I decided it was time.
This change will also greatly simplify parsing of deferred CHECK constraints,
if anyone ever gets around to implementing that.

While at it, add a location field to Constraint, and use that to provide
an error cursor for some of the constraint-related error messages.
This commit is contained in:
Tom Lane
2009-07-30 02:45:38 +00:00
parent 78aef14c59
commit 060baf2784
12 changed files with 394 additions and 515 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
src/backend/nodes/copyfuncs.c
View File

@ -15,7 +15,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.436 2009/07/29 20:56:19 tgl Exp $
* $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.437 2009/07/30 02:45:37 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -1738,25 +1738,6 @@ _copyRangeTblEntry(RangeTblEntry *from)
return newnode;
}
static FkConstraint *
_copyFkConstraint(FkConstraint *from)
{
FkConstraint *newnode = makeNode(FkConstraint);
COPY_STRING_FIELD(constr_name);
COPY_NODE_FIELD(pktable);
COPY_NODE_FIELD(fk_attrs);
COPY_NODE_FIELD(pk_attrs);
COPY_SCALAR_FIELD(fk_matchtype);
COPY_SCALAR_FIELD(fk_upd_action);
COPY_SCALAR_FIELD(fk_del_action);
COPY_SCALAR_FIELD(deferrable);
COPY_SCALAR_FIELD(initdeferred);
COPY_SCALAR_FIELD(skip_validation);
return newnode;
}
static SortGroupClause *
_copySortGroupClause(SortGroupClause *from)
{
@ -2085,14 +2066,22 @@ _copyConstraint(Constraint *from)
Constraint *newnode = makeNode(Constraint);
COPY_SCALAR_FIELD(contype);
COPY_STRING_FIELD(name);
COPY_STRING_FIELD(conname);
COPY_SCALAR_FIELD(deferrable);
COPY_SCALAR_FIELD(initdeferred);
COPY_LOCATION_FIELD(location);
COPY_NODE_FIELD(raw_expr);
COPY_STRING_FIELD(cooked_expr);
COPY_NODE_FIELD(keys);
COPY_NODE_FIELD(options);
COPY_STRING_FIELD(indexspace);
COPY_SCALAR_FIELD(deferrable);
COPY_SCALAR_FIELD(initdeferred);
COPY_NODE_FIELD(pktable);
COPY_NODE_FIELD(fk_attrs);
COPY_NODE_FIELD(pk_attrs);
COPY_SCALAR_FIELD(fk_matchtype);
COPY_SCALAR_FIELD(fk_upd_action);
COPY_SCALAR_FIELD(fk_del_action);
COPY_SCALAR_FIELD(skip_validation);
return newnode;
}
@ -4082,9 +4071,6 @@ copyObject(void *from)
case T_CommonTableExpr:
retval = _copyCommonTableExpr(from);
break;
case T_FkConstraint:
retval = _copyFkConstraint(from);
break;
case T_PrivGrantee:
retval = _copyPrivGrantee(from);
break;

36
src/backend/nodes/equalfuncs.c
View File

@ -22,7 +22,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/nodes/equalfuncs.c,v 1.359 2009/07/29 20:56:19 tgl Exp $
* $PostgreSQL: pgsql/src/backend/nodes/equalfuncs.c,v 1.360 2009/07/30 02:45:37 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -2064,14 +2064,22 @@ static bool
_equalConstraint(Constraint *a, Constraint *b)
{
COMPARE_SCALAR_FIELD(contype);
COMPARE_STRING_FIELD(name);
COMPARE_STRING_FIELD(conname);
COMPARE_SCALAR_FIELD(deferrable);
COMPARE_SCALAR_FIELD(initdeferred);
COMPARE_LOCATION_FIELD(location);
COMPARE_NODE_FIELD(raw_expr);
COMPARE_STRING_FIELD(cooked_expr);
COMPARE_NODE_FIELD(keys);
COMPARE_NODE_FIELD(options);
COMPARE_STRING_FIELD(indexspace);
COMPARE_SCALAR_FIELD(deferrable);
COMPARE_SCALAR_FIELD(initdeferred);
COMPARE_NODE_FIELD(pktable);
COMPARE_NODE_FIELD(fk_attrs);
COMPARE_NODE_FIELD(pk_attrs);
COMPARE_SCALAR_FIELD(fk_matchtype);
COMPARE_SCALAR_FIELD(fk_upd_action);
COMPARE_SCALAR_FIELD(fk_del_action);
COMPARE_SCALAR_FIELD(skip_validation);
return true;
}
@ -2189,23 +2197,6 @@ _equalCommonTableExpr(CommonTableExpr *a, CommonTableExpr *b)
return true;
}
static bool
_equalFkConstraint(FkConstraint *a, FkConstraint *b)
{
COMPARE_STRING_FIELD(constr_name);
COMPARE_NODE_FIELD(pktable);
COMPARE_NODE_FIELD(fk_attrs);
COMPARE_NODE_FIELD(pk_attrs);
COMPARE_SCALAR_FIELD(fk_matchtype);
COMPARE_SCALAR_FIELD(fk_upd_action);
COMPARE_SCALAR_FIELD(fk_del_action);
COMPARE_SCALAR_FIELD(deferrable);
COMPARE_SCALAR_FIELD(initdeferred);
COMPARE_SCALAR_FIELD(skip_validation);
return true;
}
static bool
_equalXmlSerialize(XmlSerialize *a, XmlSerialize *b)
{
@ -2859,9 +2850,6 @@ equal(void *a, void *b)
case T_CommonTableExpr:
retval = _equalCommonTableExpr(a, b);
break;
case T_FkConstraint:
retval = _equalFkConstraint(a, b);
break;
case T_PrivGrantee:
retval = _equalPrivGrantee(a, b);
break;

5
src/backend/nodes/nodeFuncs.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/nodes/nodeFuncs.c,v 1.41 2009/07/16 06:33:42 petere Exp $
* $PostgreSQL: pgsql/src/backend/nodes/nodeFuncs.c,v 1.42 2009/07/30 02:45:37 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -903,6 +903,9 @@ exprLocation(Node *expr)
case T_TypeName:
loc = ((TypeName *) expr)->location;
break;
case T_Constraint:
loc = ((Constraint *) expr)->location;
break;
case T_XmlSerialize:
/* XMLSERIALIZE keyword should always be the first thing */
loc = ((XmlSerialize *) expr)->location;

101
src/backend/nodes/outfuncs.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/nodes/outfuncs.c,v 1.362 2009/07/29 20:56:19 tgl Exp $
* $PostgreSQL: pgsql/src/backend/nodes/outfuncs.c,v 1.363 2009/07/30 02:45:37 tgl Exp $
*
* NOTES
* Every node type that can appear in stored rules' parsetrees *must*
@ -2277,33 +2277,20 @@ _outConstraint(StringInfo str, Constraint *node)
{
WRITE_NODE_TYPE("CONSTRAINT");
WRITE_STRING_FIELD(name);
WRITE_STRING_FIELD(conname);
WRITE_BOOL_FIELD(deferrable);
WRITE_BOOL_FIELD(initdeferred);
WRITE_LOCATION_FIELD(location);
appendStringInfo(str, " :contype ");
switch (node->contype)
{
case CONSTR_PRIMARY:
appendStringInfo(str, "PRIMARY_KEY");
WRITE_NODE_FIELD(keys);
WRITE_NODE_FIELD(options);
WRITE_STRING_FIELD(indexspace);
WRITE_BOOL_FIELD(deferrable);
WRITE_BOOL_FIELD(initdeferred);
case CONSTR_NULL:
appendStringInfo(str, "NULL");
break;
case CONSTR_UNIQUE:
appendStringInfo(str, "UNIQUE");
WRITE_NODE_FIELD(keys);
WRITE_NODE_FIELD(options);
WRITE_STRING_FIELD(indexspace);
WRITE_BOOL_FIELD(deferrable);
WRITE_BOOL_FIELD(initdeferred);
break;
case CONSTR_CHECK:
appendStringInfo(str, "CHECK");
WRITE_NODE_FIELD(raw_expr);
WRITE_STRING_FIELD(cooked_expr);
case CONSTR_NOTNULL:
appendStringInfo(str, "NOT_NULL");
break;
case CONSTR_DEFAULT:
@ -2312,33 +2299,60 @@ _outConstraint(StringInfo str, Constraint *node)
WRITE_STRING_FIELD(cooked_expr);
break;
case CONSTR_NOTNULL:
appendStringInfo(str, "NOT_NULL");
case CONSTR_CHECK:
appendStringInfo(str, "CHECK");
WRITE_NODE_FIELD(raw_expr);
WRITE_STRING_FIELD(cooked_expr);
break;
case CONSTR_PRIMARY:
appendStringInfo(str, "PRIMARY_KEY");
WRITE_NODE_FIELD(keys);
WRITE_NODE_FIELD(options);
WRITE_STRING_FIELD(indexspace);
break;
case CONSTR_UNIQUE:
appendStringInfo(str, "UNIQUE");
WRITE_NODE_FIELD(keys);
WRITE_NODE_FIELD(options);
WRITE_STRING_FIELD(indexspace);
break;
case CONSTR_FOREIGN:
appendStringInfo(str, "FOREIGN_KEY");
WRITE_NODE_FIELD(pktable);
WRITE_NODE_FIELD(fk_attrs);
WRITE_NODE_FIELD(pk_attrs);
WRITE_CHAR_FIELD(fk_matchtype);
WRITE_CHAR_FIELD(fk_upd_action);
WRITE_CHAR_FIELD(fk_del_action);
WRITE_BOOL_FIELD(skip_validation);
break;
case CONSTR_ATTR_DEFERRABLE:
appendStringInfo(str, "ATTR_DEFERRABLE");
break;
case CONSTR_ATTR_NOT_DEFERRABLE:
appendStringInfo(str, "ATTR_NOT_DEFERRABLE");
break;
case CONSTR_ATTR_DEFERRED:
appendStringInfo(str, "ATTR_DEFERRED");
break;
case CONSTR_ATTR_IMMEDIATE:
appendStringInfo(str, "ATTR_IMMEDIATE");
break;
default:
appendStringInfo(str, "<unrecognized_constraint>");
appendStringInfo(str, "<unrecognized_constraint %d>",
(int) node->contype);
break;
}
}
static void
_outFkConstraint(StringInfo str, FkConstraint *node)
{
WRITE_NODE_TYPE("FKCONSTRAINT");
WRITE_STRING_FIELD(constr_name);
WRITE_NODE_FIELD(pktable);
WRITE_NODE_FIELD(fk_attrs);
WRITE_NODE_FIELD(pk_attrs);
WRITE_CHAR_FIELD(fk_matchtype);
WRITE_CHAR_FIELD(fk_upd_action);
WRITE_CHAR_FIELD(fk_del_action);
WRITE_BOOL_FIELD(deferrable);
WRITE_BOOL_FIELD(initdeferred);
WRITE_BOOL_FIELD(skip_validation);
}
/*
* _outNode -
@ -2765,9 +2779,6 @@ _outNode(StringInfo str, void *obj)
case T_Constraint:
_outConstraint(str, obj);
break;
case T_FkConstraint:
_outFkConstraint(str, obj);
break;
case T_FuncCall:
_outFuncCall(str, obj);
break;