-
-
Compatibility
-
- SQL99 defines CREATE DOMAIN, but says that the only allowed constraint
- type is CHECK constraints. CHECK constraints for domains are not yet
- supported by
PostgreSQL.
-
-
-
See Also
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.234 2002/11/11 22:19:21 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.235 2002/11/15 02:50:05 momjian Exp $
*
*
* INTERFACE ROUTINES
ccname = cdef->name;
/* Check against pre-existing constraints */
- if (ConstraintNameIsUsed(RelationGetRelid(rel),
+ if (ConstraintNameIsUsed(CONSTRAINT_RELATION,
+ RelationGetRelid(rel),
RelationGetNamespace(rel),
ccname))
elog(ERROR, "constraint \"%s\" already exists for relation \"%s\"",
* pre-existing constraints, nor with any auto-generated
* names so far.
*/
- ccname = GenerateConstraintName(RelationGetRelid(rel),
+ ccname = GenerateConstraintName(CONSTRAINT_RELATION,
+ RelationGetRelid(rel),
RelationGetNamespace(rel),
&constr_name_ctr);
/*
* Transform raw parsetree to executable expression.
*/
- expr = transformExpr(pstate, cdef->raw_expr);
+ expr = transformExpr(pstate, cdef->raw_expr, NULL);
/*
* Make sure it yields a boolean result.
/*
* Transform raw parsetree to executable expression.
*/
- expr = transformExpr(pstate, raw_default);
+ expr = transformExpr(pstate, raw_default, NULL);
/*
* Make sure default expr does not refer to any vars.
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/pg_constraint.c,v 1.7 2002/09/22 00:37:09 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/pg_constraint.c,v 1.8 2002/11/15 02:50:05 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
}
+ if (OidIsValid(domainId))
+ {
+ /*
+ * Register auto dependency from constraint to owning domain
+ */
+ ObjectAddress domobject;
+
+ domobject.classId = RelOid_pg_type;
+ domobject.objectId = domainId;
+
+ recordDependencyOn(&conobject, &domobject, DEPENDENCY_AUTO);
+ }
+
if (OidIsValid(foreignRelId))
{
/*
* this test is not very meaningful.
*/
bool
-ConstraintNameIsUsed(Oid relId, Oid relNamespace, const char *cname)
+ConstraintNameIsUsed(CONSTRAINTCATEGORY conCat, Oid objId, Oid objNamespace, const char *cname)
{
bool found;
Relation conDesc;
ScanKeyEntryInitialize(&skey[1], 0x0,
Anum_pg_constraint_connamespace, F_OIDEQ,
- ObjectIdGetDatum(relNamespace));
+ ObjectIdGetDatum(objNamespace));
conscan = systable_beginscan(conDesc, ConstraintNameNspIndex, true,
SnapshotNow, 2, skey);
{
Form_pg_constraint con = (Form_pg_constraint) GETSTRUCT(tup);
- if (con->conrelid == relId)
+ if (conCat == CONSTRAINT_RELATION && con->conrelid == objId)
+ {
+ found = true;
+ break;
+ }
+ else if (conCat == CONSTRAINT_DOMAIN && con->contypid == objId)
{
found = true;
break;
* someone else might choose the same name concurrently!
*/
char *
-GenerateConstraintName(Oid relId, Oid relNamespace, int *counter)
+GenerateConstraintName(CONSTRAINTCATEGORY conCat, Oid objId, Oid objNamespace, int *counter)
{
bool found;
Relation conDesc;
ScanKeyEntryInitialize(&skey[1], 0x0,
Anum_pg_constraint_connamespace, F_OIDEQ,
- ObjectIdGetDatum(relNamespace));
+ ObjectIdGetDatum(objNamespace));
conscan = systable_beginscan(conDesc, ConstraintNameNspIndex, true,
SnapshotNow, 2, skey);
{
Form_pg_constraint con = (Form_pg_constraint) GETSTRUCT(tup);
- if (con->conrelid == relId)
+ if (conCat == CONSTRAINT_RELATION && con->conrelid == objId)
+ {
+ found = true;
+ break;
+ }
+ else if (conCat == CONSTRAINT_DOMAIN && con->contypid == objId)
{
found = true;
break;
con = (Form_pg_constraint) GETSTRUCT(tup);
/*
- * If the constraint is for a relation, open and exclusive-lock the
- * relation it's for.
+ * If the constraint is for a relation, open and exclusive-lock
+ * the relation it's for.
+ *
+ * If the constraint is for a domain, open and lock the pg_type entry
+ * tye constraint is used on.
*
- * XXX not clear what we should lock, if anything, for other constraints.
+ * XXX not clear what we should lock, if anything, for assert constraints.
*/
if (OidIsValid(con->conrelid))
{
/* Keep lock on constraint's rel until end of xact */
heap_close(rel, NoLock);
}
+ /* Lock the domain row in pg_type */
+ else if (OidIsValid(con->contypid))
+ {
+ Relation typRel;
+ HeapTuple typTup;
+ ScanKeyData typKey[1];
+ SysScanDesc typScan;
+
+ typRel = heap_openr(TypeRelationName, RowExclusiveLock);
+
+ ScanKeyEntryInitialize(&typKey[0], 0x0,
+ Anum_pg_constraint_contypid, F_OIDEQ,
+ ObjectIdGetDatum(con->contypid));
+
+ typScan = systable_beginscan(typRel, TypeOidIndex, true,
+ SnapshotNow, 1, typKey);
+
+ typTup = systable_getnext(typScan);
+
+ if (!HeapTupleIsValid(typTup))
+ elog(ERROR, "RemoveConstraintById: Type %d does not exist",
+ con->contypid);
+
+ systable_endscan(typScan);
+
+ /* Keep lock on domain type until end of xact */
+ heap_close(typRel, NoLock);
+ }
/* Fry the constraint itself */
simple_heap_delete(conDesc, &tup->t_self);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/tablecmds.c,v 1.53 2002/11/11 22:19:21 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/tablecmds.c,v 1.54 2002/11/15 02:50:05 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
if (constr->name)
{
- if (ConstraintNameIsUsed(RelationGetRelid(rel),
+ if (ConstraintNameIsUsed(CONSTRAINT_RELATION,
+ RelationGetRelid(rel),
RelationGetNamespace(rel),
constr->name))
elog(ERROR, "constraint \"%s\" already exists for relation \"%s\"",
constr->name, RelationGetRelationName(rel));
}
else
- constr->name = GenerateConstraintName(RelationGetRelid(rel),
+ constr->name = GenerateConstraintName(CONSTRAINT_RELATION,
+ RelationGetRelid(rel),
RelationGetNamespace(rel),
&counter);
*/
if (fkconstraint->constr_name)
{
- if (ConstraintNameIsUsed(RelationGetRelid(rel),
+ if (ConstraintNameIsUsed(CONSTRAINT_RELATION,
+ RelationGetRelid(rel),
RelationGetNamespace(rel),
fkconstraint->constr_name))
elog(ERROR, "constraint \"%s\" already exists for relation \"%s\"",
RelationGetRelationName(rel));
}
else
- fkconstraint->constr_name = GenerateConstraintName(RelationGetRelid(rel),
+ fkconstraint->constr_name = GenerateConstraintName(CONSTRAINT_RELATION,
+ RelationGetRelid(rel),
RelationGetNamespace(rel),
&counter);
/*
* Convert the A_EXPR in raw_expr into an EXPR
*/
- expr = transformExpr(pstate, constr->raw_expr);
+ expr = transformExpr(pstate, constr->raw_expr, NULL);
/*
* Make sure it yields a boolean result.
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/typecmds.c,v 1.16 2002/11/11 22:19:22 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/typecmds.c,v 1.17 2002/11/15 02:50:06 momjian Exp $
*
* DESCRIPTION
* The "DefineFoo" routines take the parse tree and pick out the
#include "catalog/dependency.h"
#include "catalog/heap.h"
#include "catalog/namespace.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_type.h"
#include "commands/defrem.h"
#include "commands/tablecmds.h"
#include "miscadmin.h"
+#include "nodes/nodes.h"
+#include "optimizer/clauses.h"
+#include "optimizer/planmain.h"
+#include "optimizer/var.h"
+#include "parser/parse_coerce.h"
+#include "parser/parse_expr.h"
#include "parser/parse_func.h"
#include "parser/parse_type.h"
#include "utils/acl.h"
List *listptr;
Oid basetypeoid;
Oid domainoid;
- Form_pg_type baseType;
+ Form_pg_type baseType;
+ int counter = 0;
/* Convert list of names to a name and namespace */
domainNamespace = QualifiedNameGetCreationNamespace(stmt->domainname,
basetypelem = baseType->typelem;
/*
- * Run through constraints manually to avoid the additional processing
- * conducted by DefineRelation() and friends.
- *
- * Besides, we don't want any constraints to be cooked. We'll do that
- * when the table is created via MergeDomainAttributes().
+ * Run through constraints manually to avoid the additional
+ * processing conducted by DefineRelation() and friends.
*/
foreach(listptr, schema)
{
- Constraint *colDef = lfirst(listptr);
+ Node *newConstraint = lfirst(listptr);
+ Constraint *colDef;
ParseState *pstate;
+ /* Prior to processing, confirm that it is not a foreign key constraint */
+ if (nodeTag(newConstraint) == T_FkConstraint)
+ elog(ERROR, "CREATE DOMAIN / FOREIGN KEY constraints not supported");
+
+ colDef = (Constraint *) newConstraint;
+
switch (colDef->contype)
{
/*
elog(ERROR, "CREATE DOMAIN has conflicting NULL / NOT NULL constraint");
typNotNull = false;
nullDefined = true;
- break;
+ break;
- case CONSTR_UNIQUE:
- elog(ERROR, "CREATE DOMAIN / UNIQUE indexes not supported");
- break;
+ case CONSTR_UNIQUE:
+ elog(ERROR, "CREATE DOMAIN / UNIQUE indexes not supported");
+ break;
- case CONSTR_PRIMARY:
- elog(ERROR, "CREATE DOMAIN / PRIMARY KEY indexes not supported");
- break;
+ case CONSTR_PRIMARY:
+ elog(ERROR, "CREATE DOMAIN / PRIMARY KEY indexes not supported");
+ break;
- case CONSTR_CHECK:
- elog(ERROR, "DefineDomain: CHECK Constraints not supported");
- break;
+ /* Check constraints are handled after domain creation */
+ case CONSTR_CHECK:
+ break;
- case CONSTR_ATTR_DEFERRABLE:
- case CONSTR_ATTR_NOT_DEFERRABLE:
- case CONSTR_ATTR_DEFERRED:
- case CONSTR_ATTR_IMMEDIATE:
- elog(ERROR, "DefineDomain: DEFERRABLE, NON DEFERRABLE, DEFERRED and IMMEDIATE not supported");
- break;
+ case CONSTR_ATTR_DEFERRABLE:
+ case CONSTR_ATTR_NOT_DEFERRABLE:
+ case CONSTR_ATTR_DEFERRED:
+ case CONSTR_ATTR_IMMEDIATE:
+ elog(ERROR, "DefineDomain: DEFERRABLE, NON DEFERRABLE, DEFERRED and IMMEDIATE not supported");
+ break;
default:
elog(ERROR, "DefineDomain: unrecognized constraint node type");
basetypeoid, /* base type ID */
defaultValue, /* default type value (text) */
defaultValueBin, /* default type value (binary) */
- byValue, /* passed by value */
- alignment, /* required alignment */
- storage, /* TOAST strategy */
- stmt->typename->typmod, /* typeMod value */
- typNDims, /* Array dimensions for base type */
- typNotNull); /* Type NOT NULL */
+ byValue, /* passed by value */
+ alignment, /* required alignment */
+ storage, /* TOAST strategy */
+ stmt->typename->typmod, /* typeMod value */
+ typNDims, /* Array dimensions for base type */
+ typNotNull); /* Type NOT NULL */
+
+ /*
+ * Process constraints which refer to the domain ID returned by TypeCreate
+ */
+ foreach(listptr, schema)
+ {
+ Constraint *constr = lfirst(listptr);
+ ParseState *pstate;
+
+ switch (constr->contype)
+ {
+ case CONSTR_CHECK:
+ {
+ Node *expr;
+ char *ccsrc;
+ char *ccbin;
+ ConstraintTestValue *domVal;
+
+ /*
+ * Assign or validate constraint name
+ */
+ if (constr->name)
+ {
+ if (ConstraintNameIsUsed(CONSTRAINT_DOMAIN,
+ domainoid,
+ domainNamespace,
+ constr->name))
+ elog(ERROR, "constraint \"%s\" already exists for domain \"%s\"",
+ constr->name,
+ domainName);
+ }
+ else
+ constr->name = GenerateConstraintName(CONSTRAINT_DOMAIN,
+ domainoid,
+ domainNamespace,
+ &counter);
+
+ /*
+ * Convert the A_EXPR in raw_expr into an
+ * EXPR
+ */
+ pstate = make_parsestate(NULL);
+
+ /*
+ * We want to have the domain VALUE node type filled in so
+ * that proper casting can occur.
+ */
+ domVal = makeNode(ConstraintTestValue);
+ domVal->typeId = basetypeoid;
+ domVal->typeMod = stmt->typename->typmod;
+
+ expr = transformExpr(pstate, constr->raw_expr, domVal);
+
+ /*
+ * Domains don't allow var clauses
+ */
+ if (contain_var_clause(expr))
+ elog(ERROR, "cannot use column references in domain CHECK clause");
+
+ /*
+ * Make sure it yields a boolean result.
+ */
+ expr = coerce_to_boolean(expr, "CHECK");
+
+ /*
+ * Make sure no outside relations are
+ * referred to.
+ */
+ if (length(pstate->p_rtable) != 0)
+ elog(ERROR, "Relations cannot be referenced in domain CHECK constraint");
+
+ /*
+ * No subplans or aggregates, either...
+ */
+ if (contain_subplans(expr))
+ elog(ERROR, "cannot use subselect in CHECK constraint expression");
+ if (contain_agg_clause(expr))
+ elog(ERROR, "cannot use aggregate function in CHECK constraint expression");
+
+ /*
+ * Might as well try to reduce any constant expressions.
+ */
+ expr = eval_const_expressions(expr);
+
+ /*
+ * Must fix opids in operator clauses.
+ */
+ fix_opids(expr);
+
+ ccbin = nodeToString(expr);
+
+ /*
+ * Deparse it. Since VARNOs aren't allowed in domain
+ * constraints, relation context isn't required as anything
+ * other than a shell.
+ */
+ ccsrc = deparse_expression(expr,
+ deparse_context_for(domainName,
+ InvalidOid),
+ false, false);
+
+ /* Write the constraint */
+ CreateConstraintEntry(constr->name, /* Constraint Name */
+ domainNamespace, /* namespace */
+ CONSTRAINT_CHECK, /* Constraint Type */
+ false, /* Is Deferrable */
+ false, /* Is Deferred */
+ InvalidOid, /* not a relation constraint */
+ NULL,
+ 0,
+ domainoid, /* domain constraint */
+ InvalidOid, /* Foreign key fields */
+ NULL,
+ 0,
+ ' ',
+ ' ',
+ ' ',
+ InvalidOid,
+ expr, /* Tree form check constraint */
+ ccbin, /* Binary form check constraint */
+ ccsrc); /* Source form check constraint */
+ }
+ break;
+ default:
+ break;
+ }
+ }
/*
* Add any dependencies needed for the default expression.
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.108 2002/09/04 20:31:17 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.109 2002/11/15 02:50:06 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static Datum ExecEvalConstraintTest(ConstraintTest *constraint,
ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
+static Datum ExecEvalConstraintTestValue(ConstraintTestValue *conVal,
+ ExprContext *econtext,
+ bool *isNull, ExprDoneCond *isDone);
/*----------
}
}
+/*
+ * ExecEvalConstraintTestValue
+ *
+ * Return the value stored by constraintTest.
+ */
+static Datum
+ExecEvalConstraintTestValue(ConstraintTestValue *conVal, ExprContext *econtext,
+ bool *isNull, ExprDoneCond *isDone)
+{
+ /*
+ * If the Datum hasn't been set, then it's ExecEvalConstraintTest
+ * hasn't been called.
+ */
+ *isNull = econtext->domainValue_isNull;
+ return econtext->domainValue_datum;
+}
+
/*
* ExecEvalConstraintTest
*
case CONSTR_TEST_NOTNULL:
if (*isNull)
elog(ERROR, "Domain %s does not allow NULL values",
- constraint->name);
+ constraint->domname);
break;
case CONSTR_TEST_CHECK:
- /* TODO: Add CHECK Constraints to domains */
- elog(ERROR, "Domain CHECK Constraints not yet implemented");
+ {
+ Datum conResult;
+
+ /* Var with attnum == UnassignedAttrNum uses the result */
+ econtext->domainValue_datum = result;
+ econtext->domainValue_isNull = *isNull;
+
+ conResult = ExecEvalExpr(constraint->check_expr, econtext, isNull, isDone);
+
+ if (!DatumGetBool(conResult))
+ elog(ERROR, "Domain %s constraint %s failed",
+ constraint->name, constraint->domname);
+ }
break;
default:
elog(ERROR, "ExecEvalConstraintTest: Constraint type unknown");
isNull,
isDone);
break;
-
+ case T_ConstraintTestValue:
+ retDatum = ExecEvalConstraintTestValue((ConstraintTestValue *) expression,
+ econtext,
+ isNull,
+ isDone);
+ break;
default:
elog(ERROR, "ExecEvalExpr: unknown expression type %d",
nodeTag(expression));
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.217 2002/11/11 22:19:22 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.218 2002/11/15 02:50:06 momjian Exp $
*
*-------------------------------------------------------------------------
*/
newnode->testtype = from->testtype;
if (from->name)
newnode->name = pstrdup(from->name);
+ if (from->domname)
+ newnode->domname = pstrdup(from->domname);
Node_Copy(from, newnode, check_expr);
return newnode;
}
+static ConstraintTestValue *
+_copyConstraintTestValue(ConstraintTestValue *from)
+{
+ ConstraintTestValue *newnode = makeNode(ConstraintTestValue);
+
+ /*
+ * copy remainder of node
+ */
+ newnode->typeId = from->typeId;
+ newnode->typeMod = from->typeMod;
+
+ return newnode;
+}
+
+static DomainConstraintValue *
+_copyDomainConstraintValue(DomainConstraintValue *from)
+{
+ DomainConstraintValue *newnode = makeNode(DomainConstraintValue);
+
+ return newnode;
+}
+
static ArrayRef *
_copyArrayRef(ArrayRef *from)
{
case T_ConstraintTest:
retval = _copyConstraintTest(from);
break;
+ case T_ConstraintTestValue:
+ retval = _copyConstraintTestValue(from);
+ break;
case T_FkConstraint:
retval = _copyFkConstraint(from);
break;
case T_InsertDefault:
retval = _copyInsertDefault(from);
break;
+ case T_DomainConstraintValue:
+ retval = _copyDomainConstraintValue(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.163 2002/11/11 22:19:22 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.164 2002/11/15 02:50:06 momjian Exp $
*
*-------------------------------------------------------------------------
*/
return false;
if (!equalstr(a->name, b->name))
return false;
+ if (!equalstr(a->domname, b->domname))
+ return false;
if (!equal(a->check_expr, b->check_expr))
return false;
return true;
}
+static bool
+_equalConstraintTestValue(ConstraintTestValue *a, ConstraintTestValue *b)
+{
+ if (a->typeId != b->typeId)
+ return false;
+ if (a->typeMod != b->typeMod)
+ return false;
+ return true;
+}
+
+static bool
+_equalDomainConstraintValue(DomainConstraintValue *a, DomainConstraintValue *b)
+{
+ return true;
+}
+
/*
* Stuff from pg_list.h
*/
-
static bool
_equalValue(Value *a, Value *b)
{
case T_ConstraintTest:
retval = _equalConstraintTest(a, b);
break;
+ case T_ConstraintTestValue:
+ retval = _equalConstraintTestValue(a, b);
+ break;
case T_FkConstraint:
retval = _equalFkConstraint(a, b);
break;
case T_InsertDefault:
retval = _equalInsertDefault(a, b);
break;
+ case T_DomainConstraintValue:
+ retval = _equalDomainConstraintValue(a, b);
+ break;
default:
elog(WARNING, "equal: don't know whether nodes of type %d are equal",
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.179 2002/11/11 22:19:22 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.180 2002/11/15 02:50:07 momjian Exp $
*
* NOTES
* Every (plan) node in POSTGRES has an associated "out" routine which
appendStringInfo(str, " :testtype %d :name ",
(int) node->testtype);
_outToken(str, node->name);
+ appendStringInfo(str, " :domain ");
+ _outToken(str, node->domname);
appendStringInfo(str, " :check_expr ");
_outNode(str, node->check_expr);
}
+/*
+ * ConstraintTestValue
+ */
+static void
+_outConstraintTestValue(StringInfo str, ConstraintTestValue *node)
+{
+ appendStringInfo(str, " CONSTRAINTTESTVALUE :typeid %u :typemod %d ",
+ node->typeId,
+ node->typeMod);
+}
+
+/*
+ * DomainConstraintValue
+ */
+static void
+_outDomainConstraintValue(StringInfo str, DomainConstraintValue *node)
+{
+ appendStringInfo(str, " DOMAINCONSTRAINTVALUE ");
+}
+
/*
* _outNode -
* converts a Node into ascii string and append it to 'str'
case T_ConstraintTest:
_outConstraintTest(str, obj);
break;
+ case T_ConstraintTestValue:
+ _outConstraintTestValue(str, obj);
+ break;
case T_FuncCall:
_outFuncCall(str, obj);
break;
+ case T_DomainConstraintValue:
+ _outDomainConstraintValue(str, obj);
+ break;
default:
elog(WARNING, "_outNode: don't know how to print type %d ",
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.136 2002/11/06 00:00:44 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.137 2002/11/15 02:50:07 momjian Exp $
*
* NOTES
* Most of the read functions for plan nodes are tested. (In fact, they
token = pg_strtok(&length); /* now read it */
local_node->name = nullable_string(token, length);
+ token = pg_strtok(&length); /* get :domname */
+ token = pg_strtok(&length); /* get domname */
+ local_node->domname = nullable_string(token, length);
+
token = pg_strtok(&length); /* eat :check_expr */
local_node->check_expr = nodeRead(true); /* now read it */
return local_node;
}
+/* ----------------
+ * _readConstraintTestValue
+ *
+ * ConstraintTestValue is a subclass of Node
+ * ----------------
+ */
+static ConstraintTestValue *
+_readConstraintTestValue(void)
+{
+ ConstraintTestValue *local_node;
+ char *token;
+ int length;
+
+ local_node = makeNode(ConstraintTestValue);
+ token = pg_strtok(&length); /* eat :typeid */
+ token = pg_strtok(&length); /* get typeid */
+ local_node->typeId = atooid(token);
+ token = pg_strtok(&length); /* eat :typemod */
+ token = pg_strtok(&length); /* get typemod */
+ local_node->typeMod = atoi(token);
+
+ return local_node;
+}
+
+/* ----------------
+ * _readDomainConstraintValue
+ *
+ * DomainConstraintValue is a subclass of Node
+ * ----------------
+ */
+static DomainConstraintValue *
+_readDomainConstraintValue(void)
+{
+ DomainConstraintValue *local_node;
+
+ local_node = makeNode(DomainConstraintValue);
+
+ return local_node;
+}
+
/* ----------------
* _readVar
*
return_value = _readBooleanTest();
else if (length == 14 && strncmp(token, "CONSTRAINTTEST", length) == 0)
return_value = _readConstraintTest();
+ else if (length == 21 && strncmp(token, "DOMAINCONSTRAINTVALUE", length) == 0)
+ return_value = _readDomainConstraintValue();
+ else if (length == 19 && strncmp(token, "CONSTRAINTTESTVALUE", length) == 0)
+ return_value = _readConstraintTestValue();
else
elog(ERROR, "badly formatted planstring \"%.10s\"...", token);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.110 2002/11/06 22:31:24 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.111 2002/11/15 02:50:07 momjian Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
if (walker(((ConstraintTest *) node)->arg, context))
return true;
return walker(((ConstraintTest *) node)->check_expr, context);
+ case T_ConstraintTestValue:
+ break;
case T_SubLink:
{
SubLink *sublink = (SubLink *) node;
return (Node *) newnode;
}
break;
+ case T_ConstraintTestValue:
+ {
+ ConstraintTestValue *ctest = (ConstraintTestValue *) node;
+ ConstraintTestValue *newnode;
+
+ FLATCOPY(newnode, ctest, ConstraintTestValue);
+ return (Node *) newnode;
+ }
+ break;
case T_SubLink:
{
/*
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.253 2002/10/21 22:06:19 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.254 2002/11/15 02:50:07 momjian Exp $
*
*-------------------------------------------------------------------------
*/
Oid expected_type_id,
given_type_id;
- expr = transformExpr(pstate, expr);
+ expr = transformExpr(pstate, expr, NULL);
/* Cannot contain subselects or aggregates */
if (contain_subplans(expr))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.377 2002/11/13 00:44:08 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.378 2002/11/15 02:50:08 momjian Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
UNENCRYPTED UNION UNIQUE UNKNOWN UNLISTEN UNTIL
UPDATE USAGE USER USING
- VACUUM VALID VALIDATOR VALUES VARCHAR VARYING
+ VACUUM VALID VALIDATOR VALUE VALUES VARCHAR VARYING
VERBOSE VERSION VIEW VOLATILE
WHEN WHERE WITH WITHOUT WORK WRITE
n->subselect = $2;
$$ = (Node *)n;
}
+ | VALUE
+ {
+ DomainConstraintValue *n = makeNode(DomainConstraintValue);
+ $$ = (Node *)n;
+ }
;
/*
| UNIQUE
| USER
| USING
+ | VALUE
| WHEN
| WHERE
;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/keywords.c,v 1.130 2002/11/13 00:44:09 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/keywords.c,v 1.131 2002/11/15 02:50:08 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{"vacuum", VACUUM},
{"valid", VALID},
{"validator", VALIDATOR},
+ {"value", VALUE},
{"values", VALUES},
{"varchar", VARCHAR},
{"varying", VARYING},
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.98 2002/09/18 21:35:22 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.99 2002/11/15 02:50:08 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* transformJoinOnClause() does. Just invoke transformExpr() to fix
* up the operators, and we're done.
*/
- result = transformExpr(pstate, result);
+ result = transformExpr(pstate, result, NULL);
result = coerce_to_boolean(result, "JOIN/USING");
pstate->p_namespace = makeList2(j->larg, j->rarg);
/* This part is just like transformWhereClause() */
- result = transformExpr(pstate, j->quals);
+ result = transformExpr(pstate, j->quals, NULL);
result = coerce_to_boolean(result, "JOIN/ON");
save_namespace = pstate->p_namespace;
pstate->p_namespace = NIL;
- funcexpr = transformExpr(pstate, r->funccallnode);
+ funcexpr = transformExpr(pstate, r->funccallnode, NULL);
pstate->p_namespace = save_namespace;
if (clause == NULL)
return NULL;
- qual = transformExpr(pstate, clause);
+ qual = transformExpr(pstate, clause, NULL);
qual = coerce_to_boolean(qual, "WHERE");
* willing to match a resjunk target here, though the above cases must
* ignore resjunk targets.
*/
- expr = transformExpr(pstate, node);
+ expr = transformExpr(pstate, node, NULL);
foreach(tl, tlist)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_coerce.c,v 2.85 2002/10/24 22:09:00 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_coerce.c,v 2.86 2002/11/15 02:50:09 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
+#include "access/genam.h"
+#include "access/heapam.h"
+#include "catalog/catname.h"
+#include "catalog/indexing.h"
#include "catalog/pg_cast.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_proc.h"
#include "nodes/makefuncs.h"
#include "optimizer/clauses.h"
for (;;)
{
HeapTuple tup;
+ HeapTuple conTup;
Form_pg_type typTup;
+ ScanKeyData key[1];
+ int nkeys = 0;
+ SysScanDesc scan;
+ Relation conRel;
+
tup = SearchSysCache(TYPEOID,
ObjectIdGetDatum(typeId),
0, 0, 0);
if (typTup->typnotnull && notNull == NULL)
notNull = pstrdup(NameStr(typTup->typname));
- /* TODO: Add CHECK Constraints to domains */
+ /* Add CHECK Constraints to domains */
+ conRel = heap_openr(ConstraintRelationName, RowShareLock);
+
+ ScanKeyEntryInitialize(&key[nkeys++], 0x0,
+ Anum_pg_constraint_contypid, F_OIDEQ,
+ ObjectIdGetDatum(typeId));
+
+ scan = systable_beginscan(conRel, ConstraintTypidIndex, true,
+ SnapshotNow, nkeys, key);
+
+ while (HeapTupleIsValid(conTup = systable_getnext(scan)))
+ {
+ Datum val;
+ bool isNull;
+ ConstraintTest *r = makeNode(ConstraintTest);
+ Form_pg_constraint c = (Form_pg_constraint) GETSTRUCT(conTup);
+
+ /* Not expecting conbin to be NULL, but we'll test for it anyway */
+ val = fastgetattr(conTup,
+ Anum_pg_constraint_conbin,
+ conRel->rd_att, &isNull);
+
+ if (isNull)
+ elog(ERROR, "coerce_type_constraints: domain %s constraint %s has NULL conbin",
+ NameStr(typTup->typname), NameStr(c->conname));
+
+ r->arg = arg;
+ r->testtype = CONSTR_TEST_CHECK;
+ r->name = NameStr(c->conname);
+ r->domname = NameStr(typTup->typname);
+ r->check_expr = stringToNode(MemoryContextStrdup(CacheMemoryContext,
+ DatumGetCString(DirectFunctionCall1(textout,
+ val))));
+
+ arg = (Node *) r;
+ }
+
+ systable_endscan(scan);
+ heap_close(conRel, RowShareLock);
if (typTup->typtype != 'd')
{
r->arg = arg;
r->testtype = CONSTR_TEST_NOTNULL;
- r->name = notNull;
+ r->name = "NOT NULL";
+ r->domname = notNull;
r->check_expr = NULL;
arg = (Node *) r;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.129 2002/09/18 21:35:22 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.130 2002/11/15 02:50:09 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/params.h"
+#include "optimizer/clauses.h"
#include "parser/analyze.h"
#include "parser/gramparse.h"
#include "parser/parse.h"
* input and output of transformExpr; see SubLink for example.
*/
Node *
-transformExpr(ParseState *pstate, Node *expr)
+transformExpr(ParseState *pstate, Node *expr, ConstraintTestValue *domVal)
{
Node *result = NULL;
ExprFieldSelect *efs = (ExprFieldSelect *) expr;
List *fields;
- result = transformExpr(pstate, efs->arg);
+ result = transformExpr(pstate, efs->arg, domVal);
/* handle qualification, if any */
foreach(fields, efs->fields)
{
case T_TypeCast:
{
TypeCast *tc = (TypeCast *) expr;
- Node *arg = transformExpr(pstate, tc->arg);
+ Node *arg = transformExpr(pstate, tc->arg, domVal);
result = typecast_expression(arg, tc->typename);
break;
n->arg = a->lexpr;
result = transformExpr(pstate,
- (Node *) n);
+ (Node *) n, domVal);
}
else
{
Node *lexpr = transformExpr(pstate,
- a->lexpr);
+ a->lexpr, domVal);
Node *rexpr = transformExpr(pstate,
- a->rexpr);
+ a->rexpr, domVal);
result = (Node *) make_op(a->name,
lexpr,
case AND:
{
Node *lexpr = transformExpr(pstate,
- a->lexpr);
+ a->lexpr, domVal);
Node *rexpr = transformExpr(pstate,
- a->rexpr);
+ a->rexpr, domVal);
Expr *expr = makeNode(Expr);
lexpr = coerce_to_boolean(lexpr, "AND");
case OR:
{
Node *lexpr = transformExpr(pstate,
- a->lexpr);
+ a->lexpr, domVal);
Node *rexpr = transformExpr(pstate,
- a->rexpr);
+ a->rexpr, domVal);
Expr *expr = makeNode(Expr);
lexpr = coerce_to_boolean(lexpr, "OR");
case NOT:
{
Node *rexpr = transformExpr(pstate,
- a->rexpr);
+ a->rexpr, domVal);
Expr *expr = makeNode(Expr);
rexpr = coerce_to_boolean(rexpr, "NOT");
case DISTINCT:
{
Node *lexpr = transformExpr(pstate,
- a->lexpr);
+ a->lexpr, domVal);
Node *rexpr = transformExpr(pstate,
- a->rexpr);
+ a->rexpr, domVal);
result = (Node *) make_op(a->name,
lexpr,
* Will result in a boolean constant node.
*/
Node *lexpr = transformExpr(pstate,
- a->lexpr);
+ a->lexpr, domVal);
ltype = exprType(lexpr);
foreach(telem, (List *) a->rexpr)
n->val.val.str = (matched ? "t" : "f");
n->typename = SystemTypeName("bool");
- result = transformExpr(pstate, (Node *) n);
+ result = transformExpr(pstate, (Node *) n, domVal);
}
break;
}
/* transform the list of arguments */
foreach(args, fn->args)
lfirst(args) = transformExpr(pstate,
- (Node *) lfirst(args));
+ (Node *) lfirst(args), domVal);
result = ParseFuncOrColumn(pstate,
fn->funcname,
fn->args,
List *elist;
foreach(elist, left_list)
- lfirst(elist) = transformExpr(pstate, lfirst(elist));
+ lfirst(elist) = transformExpr(pstate, lfirst(elist), domVal);
Assert(IsA(sublink->oper, A_Expr));
op = ((A_Expr *) sublink->oper)->name;
warg = (Node *) makeSimpleA_Expr(OP, "=",
c->arg, warg);
}
- neww->expr = transformExpr(pstate, warg);
+ neww->expr = transformExpr(pstate, warg, domVal);
neww->expr = coerce_to_boolean(neww->expr, "CASE/WHEN");
n->val.type = T_Null;
warg = (Node *) n;
}
- neww->result = transformExpr(pstate, warg);
+ neww->result = transformExpr(pstate, warg, domVal);
newargs = lappend(newargs, neww);
typeids = lappendi(typeids, exprType(neww->result));
n->val.type = T_Null;
defresult = (Node *) n;
}
- newc->defresult = transformExpr(pstate, defresult);
+ newc->defresult = transformExpr(pstate, defresult, domVal);
/*
* Note: default result is considered the most significant
{
NullTest *n = (NullTest *) expr;
- n->arg = transformExpr(pstate, n->arg);
+ n->arg = transformExpr(pstate, n->arg, domVal);
/* the argument can be any type, so don't coerce it */
result = expr;
break;
clausename = NULL; /* keep compiler quiet */
}
- b->arg = transformExpr(pstate, b->arg);
+ b->arg = transformExpr(pstate, b->arg, domVal);
b->arg = coerce_to_boolean(b->arg, clausename);
break;
}
+ case T_DomainConstraintValue:
+ {
+ result = (Node *) copyObject(domVal);
+
+ break;
+ }
+
/*********************************************
* Quietly accept node types that may be presented when we are
* called on an already-transformed tree.
case T_ConstraintTest:
type = exprType(((ConstraintTest *) expr)->arg);
break;
+ case T_ConstraintTestValue:
+ type = ((ConstraintTestValue *) expr)->typeId;
+ break;
default:
elog(ERROR, "exprType: Do not know how to get type for %d node",
nodeTag(expr));
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.72 2002/11/13 00:39:47 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.73 2002/11/15 02:50:09 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
if (ai->lidx)
{
- subexpr = transformExpr(pstate, ai->lidx);
+ subexpr = transformExpr(pstate, ai->lidx, NULL);
/* If it's not int4 already, try to coerce */
subexpr = coerce_to_target_type(subexpr, exprType(subexpr),
INT4OID, -1,
}
lowerIndexpr = lappend(lowerIndexpr, subexpr);
}
- subexpr = transformExpr(pstate, ai->uidx);
+ subexpr = transformExpr(pstate, ai->uidx, NULL);
/* If it's not int4 already, try to coerce */
subexpr = coerce_to_target_type(subexpr, exprType(subexpr),
INT4OID, -1,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.91 2002/09/28 20:00:19 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.92 2002/11/15 02:50:09 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* Transform the node if caller didn't do it already */
if (expr == NULL)
- expr = transformExpr(pstate, node);
+ expr = transformExpr(pstate, node, NULL);
if (IsA(expr, RangeVar))
elog(ERROR, "You can't use relation names alone in the target list, try relation.*.");
* back to source text
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.124 2002/09/19 23:40:56 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.125 2002/11/15 02:50:09 momjian Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
}
break;
+ case T_ConstraintTestValue:
+ {
+ appendStringInfo(buf, "VALUE");
+ }
+ break;
+
case T_SubLink:
get_sublink_expr(node, context);
break;
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: indexing.h,v 1.76 2002/10/18 20:33:57 tgl Exp $
+ * $Id: indexing.h,v 1.77 2002/11/15 02:50:10 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#define ConstraintNameNspIndex "pg_constraint_conname_nsp_index"
#define ConstraintOidIndex "pg_constraint_oid_index"
#define ConstraintRelidIndex "pg_constraint_conrelid_index"
+#define ConstraintTypidIndex "pg_constraint_contypid_index"
#define ConversionDefaultIndex "pg_conversion_default_index"
#define ConversionNameNspIndex "pg_conversion_name_nsp_index"
#define ConversionOidIndex "pg_conversion_oid_index"
DECLARE_INDEX(pg_constraint_conname_nsp_index on pg_constraint using btree(conname name_ops, connamespace oid_ops));
/* This following index is not used for a cache and is not unique */
DECLARE_INDEX(pg_constraint_conrelid_index on pg_constraint using btree(conrelid oid_ops));
+/* This following index is not used for a cache and is not unique */
+DECLARE_INDEX(pg_constraint_contypid_index on pg_constraint using btree(contypid oid_ops));
DECLARE_UNIQUE_INDEX(pg_constraint_oid_index on pg_constraint using btree(oid oid_ops));
DECLARE_UNIQUE_INDEX(pg_conversion_default_index on pg_conversion using btree(connamespace oid_ops, conforencoding int4_ops, contoencoding int4_ops, oid oid_ops));
DECLARE_UNIQUE_INDEX(pg_conversion_name_nsp_index on pg_conversion using btree(conname name_ops, connamespace oid_ops));
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_constraint.h,v 1.4 2002/09/22 00:37:09 tgl Exp $
+ * $Id: pg_constraint.h,v 1.5 2002/11/15 02:50:10 momjian Exp $
*
* NOTES
* the genbki.sh script reads this file and generates .bki
* the FKCONSTR_MATCH_xxx constants defined in parsenodes.h.
*/
+/*
+ * Used for constraint support functions where the
+ * and conrelid, contypid columns being looked up
+ */
+typedef enum CONSTRAINTCATEGORY {
+ CONSTRAINT_RELATION,
+ CONSTRAINT_DOMAIN,
+ CONSTRAINT_ASSERTION
+} CONSTRAINTCATEGORY;
/*
* prototypes for functions in pg_constraint.c
extern void RemoveConstraintById(Oid conId);
-extern bool ConstraintNameIsUsed(Oid relId, Oid relNamespace,
- const char *cname);
-extern char *GenerateConstraintName(Oid relId, Oid relNamespace,
- int *counter);
+extern bool ConstraintNameIsUsed(CONSTRAINTCATEGORY conCat, Oid objId, Oid objNamespace,
+ const char *cname);
+extern char *GenerateConstraintName(CONSTRAINTCATEGORY conCat, Oid objId, Oid objNamespace,
+ int *counter);
extern bool ConstraintNameIsGenerated(const char *cname);
#endif /* PG_CONSTRAINT_H */
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: execnodes.h,v 1.77 2002/11/06 22:31:24 tgl Exp $
+ * $Id: execnodes.h,v 1.78 2002/11/15 02:50:10 momjian Exp $
*
*-------------------------------------------------------------------------
*/
Datum *ecxt_aggvalues; /* precomputed values for Aggref nodes */
bool *ecxt_aggnulls; /* null flags for Aggref nodes */
+ /*
+ * Carry the domain value through the executor for application
+ * in a domain constraint
+ */
+ Datum domainValue_datum;
+ bool domainValue_isNull;
+
/* Functions to call back when ExprContext is shut down */
ExprContext_CB *ecxt_callbacks;
} ExprContext;
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: nodes.h,v 1.122 2002/11/10 02:17:25 momjian Exp $
+ * $Id: nodes.h,v 1.123 2002/11/15 02:50:10 momjian Exp $
*
*-------------------------------------------------------------------------
*/
T_ViewStmt,
T_LoadStmt,
T_CreateDomainStmt,
+ T_DomainConstraintValue,
T_CreatedbStmt,
T_DropdbStmt,
T_VacuumStmt,
T_NullTest,
T_BooleanTest,
T_ConstraintTest,
+ T_ConstraintTestValue,
T_CaseExpr,
T_CaseWhen,
T_FkConstraint,
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: parsenodes.h,v 1.213 2002/11/13 00:44:09 momjian Exp $
+ * $Id: parsenodes.h,v 1.214 2002/11/15 02:50:12 momjian Exp $
*
*-------------------------------------------------------------------------
*/
Node *arg; /* input expression */
ConstraintTestType testtype; /* test type */
char *name; /* name of constraint (for error msgs) */
+ char *domname; /* name of domain (for error messages) */
Node *check_expr; /* for CHECK test, a boolean expression */
} ConstraintTest;
+/*
+ * Placeholder node for the value to be processed by a domains
+ * check constraint.
+ */
+typedef struct DomainConstraintValue
+{
+ NodeTag type;
+} DomainConstraintValue;
+
+typedef struct ConstraintTestValue
+{
+ NodeTag type;
+ Oid typeId;
+ int32 typeMod;
+} ConstraintTestValue;
+
/*
* ColumnDef - column definition (used in various creates)
*
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: var.h,v 1.21 2002/06/20 20:29:51 momjian Exp $
+ * $Id: var.h,v 1.22 2002/11/15 02:50:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
int levelsup);
extern bool contain_whole_tuple_var(Node *node, int varno, int levelsup);
extern bool contain_var_clause(Node *node);
+extern bool contain_var_tuple_clause(Node *node);
extern List *pull_var_clause(Node *node, bool includeUpperVars);
extern Node *flatten_join_alias_vars(Node *node, List *rtable, bool force);
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_expr.h,v 1.28 2002/06/20 20:29:51 momjian Exp $
+ * $Id: parse_expr.h,v 1.29 2002/11/15 02:50:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern int max_expr_depth;
extern bool Transform_null_equals;
-extern Node *transformExpr(ParseState *pstate, Node *expr);
+
+extern Node *transformExpr(ParseState *pstate, Node *expr, ConstraintTestValue *domVal);
extern Oid exprType(Node *expr);
extern int32 exprTypmod(Node *expr);
extern bool exprIsLengthCoercion(Node *expr, int32 *coercedTypmod);
drop domain domaintextarr restrict;
create domain dnotnull varchar(15) NOT NULL;
create domain dnull varchar(15);
+create domain dcheck varchar(15) NOT NULL CHECK (VALUE = 'a' OR VALUE = 'c' OR VALUE = 'd');
create table nulltest
( col1 dnotnull
, col2 dnotnull NULL -- NOT NULL in the domain cannot be overridden
, col3 dnull NOT NULL
, col4 dnull
+ , col5 dcheck CHECK (col5 IN ('c', 'd'))
);
INSERT INTO nulltest DEFAULT VALUES;
ERROR: Domain dnotnull does not allow NULL values
-INSERT INTO nulltest values ('a', 'b', 'c', 'd'); -- Good
-INSERT INTO nulltest values (NULL, 'b', 'c', 'd');
+INSERT INTO nulltest values ('a', 'b', 'c', 'd', 'c'); -- Good
+insert into nulltest values ('a', 'b', 'c', 'd', NULL);
+ERROR: Domain $1 constraint dcheck failed
+insert into nulltest values ('a', 'b', 'c', 'd', 'a');
+ERROR: ExecInsert: rejected due to CHECK constraint "nulltest_col5" on "nulltest"
+INSERT INTO nulltest values (NULL, 'b', 'c', 'd', 'd');
ERROR: Domain dnotnull does not allow NULL values
-INSERT INTO nulltest values ('a', NULL, 'c', 'd');
+INSERT INTO nulltest values ('a', NULL, 'c', 'd', 'c');
ERROR: Domain dnotnull does not allow NULL values
-INSERT INTO nulltest values ('a', 'b', NULL, 'd');
+INSERT INTO nulltest values ('a', 'b', NULL, 'd', 'c');
ERROR: ExecInsert: Fail to add null value in not null attribute col3
-INSERT INTO nulltest values ('a', 'b', 'c', NULL); -- Good
+INSERT INTO nulltest values ('a', 'b', 'c', NULL, 'd'); -- Good
-- Test copy
COPY nulltest FROM stdin; --fail
-ERROR: copy: line 1, CopyFrom: Fail to add null value in not null attribute col3
+ERROR: copy: line 1, Domain $1 constraint dcheck failed
lost synchronization with server, resetting connection
SET autocommit TO 'on';
+-- Last row is bad
COPY nulltest FROM stdin;
+ERROR: copy: line 3, CopyFrom: rejected due to CHECK constraint "nulltest_col5" on "nulltest"
+lost synchronization with server, resetting connection
select * from nulltest;
- col1 | col2 | col3 | col4
-------+------+------+------
- a | b | c | d
- a | b | c |
- a | b | c |
-(3 rows)
+ col1 | col2 | col3 | col4 | col5
+------+------+------+------+------
+ a | b | c | d | c
+ a | b | c | | d
+(2 rows)
-- Test out coerced (casted) constraints
SELECT cast('1' as dnotnull);
create domain dnotnull varchar(15) NOT NULL;
create domain dnull varchar(15);
+create domain dcheck varchar(15) NOT NULL CHECK (VALUE = 'a' OR VALUE = 'c' OR VALUE = 'd');
create table nulltest
( col1 dnotnull
, col2 dnotnull NULL -- NOT NULL in the domain cannot be overridden
, col3 dnull NOT NULL
, col4 dnull
+ , col5 dcheck CHECK (col5 IN ('c', 'd'))
);
INSERT INTO nulltest DEFAULT VALUES;
-INSERT INTO nulltest values ('a', 'b', 'c', 'd'); -- Good
-INSERT INTO nulltest values (NULL, 'b', 'c', 'd');
-INSERT INTO nulltest values ('a', NULL, 'c', 'd');
-INSERT INTO nulltest values ('a', 'b', NULL, 'd');
-INSERT INTO nulltest values ('a', 'b', 'c', NULL); -- Good
+INSERT INTO nulltest values ('a', 'b', 'c', 'd', 'c'); -- Good
+insert into nulltest values ('a', 'b', 'c', 'd', NULL);
+insert into nulltest values ('a', 'b', 'c', 'd', 'a');
+INSERT INTO nulltest values (NULL, 'b', 'c', 'd', 'd');
+INSERT INTO nulltest values ('a', NULL, 'c', 'd', 'c');
+INSERT INTO nulltest values ('a', 'b', NULL, 'd', 'c');
+INSERT INTO nulltest values ('a', 'b', 'c', NULL, 'd'); -- Good
-- Test copy
COPY nulltest FROM stdin; --fail
-a b \N d
+a b \N d \N
\.
SET autocommit TO 'on';
+-- Last row is bad
COPY nulltest FROM stdin;
-a b c \N
+a b c \N c
+a b c \N d
+a b c \N a
\.
select * from nulltest;
projects / postgresql.git / commitdiff