diff --git a/src/backend/catalog/pg_inherits.c b/src/backend/catalog/pg_inherits.c index 245a374..1bd8a58 100644 *** a/src/backend/catalog/pg_inherits.c --- b/src/backend/catalog/pg_inherits.c *************** has_superclass(Oid relationId) *** 301,306 **** --- 301,311 ---- /* * Given two type OIDs, determine whether the first is a complex type * (class type) that inherits from the second. + * + * This essentially asks whether the first type is guaranteed to be coercible + * to the second. Therefore, we allow the first type to be a domain over a + * complex type that inherits from the second; that creates no difficulties. + * But the second type cannot be a domain. */ bool typeInheritsFrom(Oid subclassTypeId, Oid superclassTypeId) *************** typeInheritsFrom(Oid subclassTypeId, Oid *** 314,322 **** ListCell *queue_item; /* We need to work with the associated relation OIDs */ ! subclassRelid = typeidTypeRelid(subclassTypeId); if (subclassRelid == InvalidOid) ! return false; /* not a complex type */ superclassRelid = typeidTypeRelid(superclassTypeId); if (superclassRelid == InvalidOid) return false; /* not a complex type */ --- 319,327 ---- ListCell *queue_item; /* We need to work with the associated relation OIDs */ ! subclassRelid = typeOrDomainTypeRelid(subclassTypeId); if (subclassRelid == InvalidOid) ! return false; /* not a complex type or domain over one */ superclassRelid = typeidTypeRelid(superclassTypeId); if (superclassRelid == InvalidOid) return false; /* not a complex type */ diff --git a/src/backend/catalog/pg_proc.c b/src/backend/catalog/pg_proc.c index 571856e..47916cf 100644 *** a/src/backend/catalog/pg_proc.c --- b/src/backend/catalog/pg_proc.c *************** ProcedureCreate(const char *procedureNam *** 262,268 **** */ if (parameterCount == 1 && OidIsValid(parameterTypes->values[0]) && ! (relid = typeidTypeRelid(parameterTypes->values[0])) != InvalidOid && get_attnum(relid, procedureName) != InvalidAttrNumber) ereport(ERROR, (errcode(ERRCODE_DUPLICATE_COLUMN), --- 262,268 ---- */ if (parameterCount == 1 && OidIsValid(parameterTypes->values[0]) && ! (relid = typeOrDomainTypeRelid(parameterTypes->values[0])) != InvalidOid && get_attnum(relid, procedureName) != InvalidAttrNumber) ereport(ERROR, (errcode(ERRCODE_DUPLICATE_COLUMN), diff --git a/src/backend/commands/typecmds.c b/src/backend/commands/typecmds.c index c2fc59d..0a08ef5 100644 *** a/src/backend/commands/typecmds.c --- b/src/backend/commands/typecmds.c *************** DefineDomain(CreateDomainStmt *stmt) *** 796,808 **** basetypeoid = HeapTupleGetOid(typeTup); /* ! * Base type must be a plain base type, another domain, an enum or a range ! * type. Domains over pseudotypes would create a security hole. Domains ! * over composite types might be made to work in the future, but not ! * today. */ typtype = baseType->typtype; if (typtype != TYPTYPE_BASE && typtype != TYPTYPE_DOMAIN && typtype != TYPTYPE_ENUM && typtype != TYPTYPE_RANGE) --- 796,811 ---- basetypeoid = HeapTupleGetOid(typeTup); /* ! * Base type must be a plain base type, a composite type, another domain, ! * an enum or a range type. Domains over pseudotypes would create a ! * security hole. (It would be shorter to code this to just check for ! * pseudotypes; but it seems safer to call out the specific typtypes that ! * are supported, rather than assume that all future typtypes would be ! * automatically supported.) */ typtype = baseType->typtype; if (typtype != TYPTYPE_BASE && + typtype != TYPTYPE_COMPOSITE && typtype != TYPTYPE_DOMAIN && typtype != TYPTYPE_ENUM && typtype != TYPTYPE_RANGE) diff --git a/src/backend/parser/parse_coerce.c b/src/backend/parser/parse_coerce.c index 0bc7dba..7b16d6c 100644 *** a/src/backend/parser/parse_coerce.c --- b/src/backend/parser/parse_coerce.c *************** coerce_type(ParseState *pstate, Node *no *** 500,508 **** --- 500,525 ---- * Input class type is a subclass of target, so generate an * appropriate runtime conversion (removing unneeded columns and * possibly rearranging the ones that are wanted). + * + * We will also get here when the input is a domain over a subclass of + * the target type. To keep life simple for the executor, we define + * ConvertRowtypeExpr as only working between regular composite types; + * therefore, in such cases insert a RelabelType to smash the input + * expression down to its base type. */ + Oid baseTypeId = getBaseType(inputTypeId); ConvertRowtypeExpr *r = makeNode(ConvertRowtypeExpr); + if (baseTypeId != inputTypeId) + { + RelabelType *rt = makeRelabelType((Expr *) node, + baseTypeId, -1, + InvalidOid, + COERCE_IMPLICIT_CAST); + + rt->location = location; + node = (Node *) rt; + } r->arg = (Expr *) node; r->resulttype = targetTypeId; r->convertformat = cformat; *************** coerce_record_to_complex(ParseState *pst *** 938,943 **** --- 955,962 ---- int location) { RowExpr *rowexpr; + Oid baseTypeId; + int32 baseTypeMod = -1; TupleDesc tupdesc; List *args = NIL; List *newargs; *************** coerce_record_to_complex(ParseState *pst *** 973,979 **** format_type_be(targetTypeId)), parser_coercion_errposition(pstate, location, node))); ! tupdesc = lookup_rowtype_tupdesc(targetTypeId, -1); newargs = NIL; ucolno = 1; arg = list_head(args); --- 992,1005 ---- format_type_be(targetTypeId)), parser_coercion_errposition(pstate, location, node))); ! /* ! * Look up the composite type, accounting for possibility that what we are ! * given is a domain over composite. ! */ ! baseTypeId = getBaseTypeAndTypmod(targetTypeId, &baseTypeMod); ! tupdesc = lookup_rowtype_tupdesc(baseTypeId, baseTypeMod); ! ! /* Process the fields */ newargs = NIL; ucolno = 1; arg = list_head(args); *************** coerce_record_to_complex(ParseState *pst *** 1041,1050 **** rowexpr = makeNode(RowExpr); rowexpr->args = newargs; ! rowexpr->row_typeid = targetTypeId; rowexpr->row_format = cformat; rowexpr->colnames = NIL; /* not needed for named target type */ rowexpr->location = location; return (Node *) rowexpr; } --- 1067,1087 ---- rowexpr = makeNode(RowExpr); rowexpr->args = newargs; ! rowexpr->row_typeid = baseTypeId; rowexpr->row_format = cformat; rowexpr->colnames = NIL; /* not needed for named target type */ rowexpr->location = location; + + /* If target is a domain, apply constraints */ + if (baseTypeId != targetTypeId) + { + rowexpr->row_format = COERCE_IMPLICIT_CAST; + return coerce_to_domain((Node *) rowexpr, + baseTypeId, baseTypeMod, + targetTypeId, + cformat, location, true, false); + } + return (Node *) rowexpr; } *************** is_complex_array(Oid typid) *** 2379,2391 **** /* * Check whether reltypeId is the row type of a typed table of type ! * reloftypeId. (This is conceptually similar to the subtype ! * relationship checked by typeInheritsFrom().) */ static bool typeIsOfTypedTable(Oid reltypeId, Oid reloftypeId) { ! Oid relid = typeidTypeRelid(reltypeId); bool result = false; if (relid) --- 2416,2428 ---- /* * Check whether reltypeId is the row type of a typed table of type ! * reloftypeId, or is a domain over such a row type. (This is conceptually ! * similar to the subtype relationship checked by typeInheritsFrom().) */ static bool typeIsOfTypedTable(Oid reltypeId, Oid reloftypeId) { ! Oid relid = typeOrDomainTypeRelid(reltypeId); bool result = false; if (relid) diff --git a/src/backend/parser/parse_func.c b/src/backend/parser/parse_func.c index 8487eda..7570108 100644 *** a/src/backend/parser/parse_func.c --- b/src/backend/parser/parse_func.c *************** ParseComplexProjection(ParseState *pstat *** 1819,1836 **** } /* ! * Else do it the hard way with get_expr_result_type(). * * If it's a Var of type RECORD, we have to work even harder: we have to ! * find what the Var refers to, and pass that to get_expr_result_type. * That task is handled by expandRecordVariable(). */ if (IsA(first_arg, Var) && ((Var *) first_arg)->vartype == RECORDOID) tupdesc = expandRecordVariable(pstate, (Var *) first_arg, 0); ! else if (get_expr_result_type(first_arg, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) return NULL; /* unresolvable RECORD type */ - Assert(tupdesc); for (i = 0; i < tupdesc->natts; i++) { --- 1819,1837 ---- } /* ! * Else do it the hard way with get_expr_result_tupdesc(). * * If it's a Var of type RECORD, we have to work even harder: we have to ! * find what the Var refers to, and pass that to get_expr_result_tupdesc. * That task is handled by expandRecordVariable(). */ if (IsA(first_arg, Var) && ((Var *) first_arg)->vartype == RECORDOID) tupdesc = expandRecordVariable(pstate, (Var *) first_arg, 0); ! else ! tupdesc = get_expr_result_tupdesc(first_arg, true); ! if (!tupdesc) return NULL; /* unresolvable RECORD type */ for (i = 0; i < tupdesc->natts; i++) { diff --git a/src/backend/parser/parse_target.c b/src/backend/parser/parse_target.c index 0a70539..d689e2a 100644 *** a/src/backend/parser/parse_target.c --- b/src/backend/parser/parse_target.c *************** transformAssignmentIndirection(ParseStat *** 725,730 **** --- 725,732 ---- else { FieldStore *fstore; + Oid baseTypeId; + int32 baseTypeMod; Oid typrelid; AttrNumber attnum; Oid fieldTypeId; *************** transformAssignmentIndirection(ParseStat *** 752,758 **** /* No subscripts, so can process field selection here */ ! typrelid = typeidTypeRelid(targetTypeId); if (!typrelid) ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), --- 754,767 ---- /* No subscripts, so can process field selection here */ ! /* ! * Look up the composite type, accounting for possibility that ! * what we are given is a domain over composite. ! */ ! baseTypeMod = targetTypMod; ! baseTypeId = getBaseTypeAndTypmod(targetTypeId, &baseTypeMod); ! ! typrelid = typeidTypeRelid(baseTypeId); if (!typrelid) ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), *************** transformAssignmentIndirection(ParseStat *** 796,802 **** fstore->arg = (Expr *) basenode; fstore->newvals = list_make1(rhs); fstore->fieldnums = list_make1_int(attnum); ! fstore->resulttype = targetTypeId; return (Node *) fstore; } --- 805,819 ---- fstore->arg = (Expr *) basenode; fstore->newvals = list_make1(rhs); fstore->fieldnums = list_make1_int(attnum); ! fstore->resulttype = baseTypeId; ! ! /* If target is a domain, apply constraints */ ! if (baseTypeId != targetTypeId) ! return coerce_to_domain((Node *) fstore, ! baseTypeId, baseTypeMod, ! targetTypeId, ! COERCE_IMPLICIT_CAST, location, ! false, false); return (Node *) fstore; } *************** ExpandRowReference(ParseState *pstate, N *** 1385,1406 **** * (This can be pretty inefficient if the expression involves nontrivial * computation :-(.) * ! * Verify it's a composite type, and get the tupdesc. We use ! * get_expr_result_type() because that can handle references to functions ! * returning anonymous record types. If that fails, use ! * lookup_rowtype_tupdesc(), which will almost certainly fail as well, but ! * it will give an appropriate error message. * * If it's a Var of type RECORD, we have to work even harder: we have to ! * find what the Var refers to, and pass that to get_expr_result_type. * That task is handled by expandRecordVariable(). */ if (IsA(expr, Var) && ((Var *) expr)->vartype == RECORDOID) tupleDesc = expandRecordVariable(pstate, (Var *) expr, 0); ! else if (get_expr_result_type(expr, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE) ! tupleDesc = lookup_rowtype_tupdesc_copy(exprType(expr), ! exprTypmod(expr)); Assert(tupleDesc); /* Generate a list of references to the individual fields */ --- 1402,1419 ---- * (This can be pretty inefficient if the expression involves nontrivial * computation :-(.) * ! * Verify it's a composite type, and get the tupdesc. ! * get_expr_result_tupdesc() handles this conveniently. * * If it's a Var of type RECORD, we have to work even harder: we have to ! * find what the Var refers to, and pass that to get_expr_result_tupdesc. * That task is handled by expandRecordVariable(). */ if (IsA(expr, Var) && ((Var *) expr)->vartype == RECORDOID) tupleDesc = expandRecordVariable(pstate, (Var *) expr, 0); ! else ! tupleDesc = get_expr_result_tupdesc(expr, false); Assert(tupleDesc); /* Generate a list of references to the individual fields */ *************** expandRecordVariable(ParseState *pstate, *** 1608,1622 **** /* * We now have an expression we can't expand any more, so see if ! * get_expr_result_type() can do anything with it. If not, pass to ! * lookup_rowtype_tupdesc() which will probably fail, but will give an ! * appropriate error message while failing. */ ! if (get_expr_result_type(expr, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE) ! tupleDesc = lookup_rowtype_tupdesc_copy(exprType(expr), ! exprTypmod(expr)); ! ! return tupleDesc; } --- 1621,1629 ---- /* * We now have an expression we can't expand any more, so see if ! * get_expr_result_tupdesc() can do anything with it. */ ! return get_expr_result_tupdesc(expr, false); } diff --git a/src/backend/parser/parse_type.c b/src/backend/parser/parse_type.c index d0b3fbe..b032651 100644 *** a/src/backend/parser/parse_type.c --- b/src/backend/parser/parse_type.c *************** stringTypeDatum(Type tp, char *string, i *** 641,647 **** return OidInputFunctionCall(typinput, string, typioparam, atttypmod); } ! /* given a typeid, return the type's typrelid (associated relation, if any) */ Oid typeidTypeRelid(Oid type_id) { --- 641,650 ---- return OidInputFunctionCall(typinput, string, typioparam, atttypmod); } ! /* ! * Given a typeid, return the type's typrelid (associated relation), if any. ! * Returns InvalidOid if type is not a composite type. ! */ Oid typeidTypeRelid(Oid type_id) { *************** typeidTypeRelid(Oid type_id) *** 652,658 **** typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_id)); if (!HeapTupleIsValid(typeTuple)) elog(ERROR, "cache lookup failed for type %u", type_id); - type = (Form_pg_type) GETSTRUCT(typeTuple); result = type->typrelid; ReleaseSysCache(typeTuple); --- 655,660 ---- *************** typeidTypeRelid(Oid type_id) *** 660,665 **** --- 662,699 ---- } /* + * Given a typeid, return the type's typrelid (associated relation), if any. + * Returns InvalidOid if type is not a composite type or a domain over one. + * This is the same as typeidTypeRelid(getBaseType(type_id)), but faster. + */ + Oid + typeOrDomainTypeRelid(Oid type_id) + { + HeapTuple typeTuple; + Form_pg_type type; + Oid result; + + for (;;) + { + typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_id)); + if (!HeapTupleIsValid(typeTuple)) + elog(ERROR, "cache lookup failed for type %u", type_id); + type = (Form_pg_type) GETSTRUCT(typeTuple); + if (type->typtype != TYPTYPE_DOMAIN) + { + /* Not a domain, so done looking through domains */ + break; + } + /* It is a domain, so examine the base type instead */ + type_id = type->typbasetype; + ReleaseSysCache(typeTuple); + } + result = type->typrelid; + ReleaseSysCache(typeTuple); + return result; + } + + /* * error context callback for parse failure during parseTypeString() */ static void diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c index 5a4adbd..9d069b5 100644 *** a/src/backend/utils/adt/ruleutils.c --- b/src/backend/utils/adt/ruleutils.c *************** get_name_for_var_field(Var *var, int fie *** 6706,6722 **** /* * If it's a Var of type RECORD, we have to find what the Var refers to; ! * if not, we can use get_expr_result_type. If that fails, we try ! * lookup_rowtype_tupdesc, which will probably fail too, but will ereport ! * an acceptable message. */ if (!IsA(var, Var) || var->vartype != RECORDOID) { ! if (get_expr_result_type((Node *) var, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE) ! tupleDesc = lookup_rowtype_tupdesc_copy(exprType((Node *) var), ! exprTypmod((Node *) var)); ! Assert(tupleDesc); /* Got the tupdesc, so we can extract the field name */ Assert(fieldno >= 1 && fieldno <= tupleDesc->natts); return NameStr(tupleDesc->attrs[fieldno - 1]->attname); --- 6706,6717 ---- /* * If it's a Var of type RECORD, we have to find what the Var refers to; ! * if not, we can use get_expr_result_tupdesc(). */ if (!IsA(var, Var) || var->vartype != RECORDOID) { ! tupleDesc = get_expr_result_tupdesc((Node *) var, false); /* Got the tupdesc, so we can extract the field name */ Assert(fieldno >= 1 && fieldno <= tupleDesc->natts); return NameStr(tupleDesc->attrs[fieldno - 1]->attname); *************** get_name_for_var_field(Var *var, int fie *** 7019,7032 **** /* * We now have an expression we can't expand any more, so see if ! * get_expr_result_type() can do anything with it. If not, pass to ! * lookup_rowtype_tupdesc() which will probably fail, but will give an ! * appropriate error message while failing. */ ! if (get_expr_result_type(expr, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE) ! tupleDesc = lookup_rowtype_tupdesc_copy(exprType(expr), ! exprTypmod(expr)); ! Assert(tupleDesc); /* Got the tupdesc, so we can extract the field name */ Assert(fieldno >= 1 && fieldno <= tupleDesc->natts); return NameStr(tupleDesc->attrs[fieldno - 1]->attname); --- 7014,7022 ---- /* * We now have an expression we can't expand any more, so see if ! * get_expr_result_tupdesc() can do anything with it. */ ! tupleDesc = get_expr_result_tupdesc(expr, false); /* Got the tupdesc, so we can extract the field name */ Assert(fieldno >= 1 && fieldno <= tupleDesc->natts); return NameStr(tupleDesc->attrs[fieldno - 1]->attname); diff --git a/src/backend/utils/fmgr/funcapi.c b/src/backend/utils/fmgr/funcapi.c index be47d41..f36be55 100644 *** a/src/backend/utils/fmgr/funcapi.c --- b/src/backend/utils/fmgr/funcapi.c *************** internal_get_result_type(Oid funcid, *** 394,399 **** --- 394,474 ---- } /* + * get_expr_result_tupdesc + * Get a tupdesc describing the result of a composite-valued expression + * + * If expression is not composite or rowtype can't be determined, returns NULL + * if noError is true, else throws error. + * + * This can resolve the same cases that get_expr_result_type() can, plus one + * more: if the expression yields domain-over-composite, it will look through + * the domain and return the base type's tupdesc. This is generally *not* + * appropriate to use when the caller is responsible for constructing a value + * of the expression's type, since one would end up constructing a value of + * the base type and failing to apply domain constraints if any. However, + * when the goal is just to find out what fields can be extracted from the + * expression's value, this is a convenient helper function. + */ + TupleDesc + get_expr_result_tupdesc(Node *expr, bool noError) + { + TupleDesc tupleDesc; + TupleDesc cache_tupdesc; + Oid exprTypeId; + Oid baseTypeId; + int32 baseTypeMod; + + /* + * First, try get_expr_result_type(), because that can handle references + * to functions returning anonymous record types. + */ + if (get_expr_result_type(expr, NULL, &tupleDesc) == TYPEFUNC_COMPOSITE) + return tupleDesc; + + /* + * There is one case get_expr_result_type() doesn't handle that we should, + * which is a domain over composite. So drill through any domain type + * before asking lookup_rowtype_tupdesc_noerror(). + */ + exprTypeId = exprType(expr); + baseTypeMod = exprTypmod(expr); + baseTypeId = getBaseTypeAndTypmod(exprTypeId, &baseTypeMod); + + cache_tupdesc = lookup_rowtype_tupdesc_noerror(baseTypeId, baseTypeMod, + true); + if (cache_tupdesc) + { + /* + * Success! But caller isn't expecting to have to manage a tupdesc + * refcount, so copy the cached tupdesc. + */ + tupleDesc = CreateTupleDescCopyConstr(cache_tupdesc); + DecrTupleDescRefCount(cache_tupdesc); + return tupleDesc; + } + + /* + * Throw error if requested. We could have left this to + * lookup_rowtype_tupdesc_noerror, but if we're dealing with a domain + * type, we prefer to finger the domain not its base type. + */ + if (!noError) + { + if (exprTypeId != RECORDOID) + ereport(ERROR, + (errcode(ERRCODE_WRONG_OBJECT_TYPE), + errmsg("type %s is not composite", + format_type_be(exprTypeId)))); + else + ereport(ERROR, + (errcode(ERRCODE_WRONG_OBJECT_TYPE), + errmsg("record type has not been registered"))); + } + + return NULL; + } + + /* * Given the result tuple descriptor for a function with OUT parameters, * replace any polymorphic columns (ANYELEMENT etc) with correct data types * deduced from the input arguments. Returns TRUE if able to deduce all types, diff --git a/src/include/funcapi.h b/src/include/funcapi.h index 951af2a..0909961 100644 *** a/src/include/funcapi.h --- b/src/include/funcapi.h *************** typedef struct FuncCallContext *** 143,148 **** --- 143,151 ---- * get_call_result_type. Note: the cases in which rowtypes cannot be * determined are different from the cases for get_call_result_type. * Do *not* use this if you can use one of the others. + * + * A related function, which should generally *not* be used for identifying + * a function's result type, is get_expr_result_tupdesc(). *---------- */ *************** extern TypeFuncClass get_func_result_typ *** 165,170 **** --- 168,175 ---- Oid *resultTypeId, TupleDesc *resultTupleDesc); + extern TupleDesc get_expr_result_tupdesc(Node *expr, bool noError); + extern bool resolve_polymorphic_argtypes(int numargs, Oid *argtypes, char *argmodes, Node *call_expr); diff --git a/src/include/parser/parse_type.h b/src/include/parser/parse_type.h index 7b843d0..9deec0d 100644 *** a/src/include/parser/parse_type.h --- b/src/include/parser/parse_type.h *************** extern Oid typeTypeCollation(Type typ); *** 46,55 **** extern Datum stringTypeDatum(Type tp, char *string, int32 atttypmod); extern Oid typeidTypeRelid(Oid type_id); extern TypeName *typeStringToTypeName(const char *str); extern void parseTypeString(const char *str, Oid *typeid_p, int32 *typmod_p, bool missing_ok); ! #define ISCOMPLEX(typeid) (typeidTypeRelid(typeid) != InvalidOid) #endif /* PARSE_TYPE_H */ --- 46,56 ---- extern Datum stringTypeDatum(Type tp, char *string, int32 atttypmod); extern Oid typeidTypeRelid(Oid type_id); + extern Oid typeOrDomainTypeRelid(Oid type_id); extern TypeName *typeStringToTypeName(const char *str); extern void parseTypeString(const char *str, Oid *typeid_p, int32 *typmod_p, bool missing_ok); ! #define ISCOMPLEX(typeid) (typeOrDomainTypeRelid(typeid) != InvalidOid) #endif /* PARSE_TYPE_H */ diff --git a/src/test/regress/expected/domain.out b/src/test/regress/expected/domain.out index 5fe999e..21075f5 100644 *** a/src/test/regress/expected/domain.out --- b/src/test/regress/expected/domain.out *************** select pg_typeof('{1,2,3}'::dia || 42); *** 198,203 **** --- 198,291 ---- (1 row) drop domain dia; + -- Test domains over composites + create type comptype as (r float8, i float8); + create domain dcomptype as comptype; + create table dcomptable (d1 dcomptype unique); + insert into dcomptable values (row(1,2)::dcomptype); + insert into dcomptable values (row(3,4)::comptype); + insert into dcomptable values (row(1,2)::dcomptype); -- fail on uniqueness + ERROR: duplicate key value violates unique constraint "dcomptable_d1_key" + DETAIL: Key (d1)=((1,2)) already exists. + insert into dcomptable (d1.r) values(11); + select * from dcomptable; + d1 + ------- + (1,2) + (3,4) + (11,) + (3 rows) + + select (d1).r, (d1).i, (d1).* from dcomptable; + r | i | r | i + ----+---+----+--- + 1 | 2 | 1 | 2 + 3 | 4 | 3 | 4 + 11 | | 11 | + (3 rows) + + update dcomptable set d1.r = (d1).r + 1 where (d1).i > 0; + select * from dcomptable; + d1 + ------- + (11,) + (2,2) + (4,4) + (3 rows) + + alter domain dcomptype add constraint c1 check ((value).r <= (value).i); + alter domain dcomptype add constraint c2 check ((value).r > (value).i); -- fail + ERROR: column "d1" of table "dcomptable" contains values that violate the new constraint + select row(2,1)::dcomptype; -- fail + ERROR: value for domain dcomptype violates check constraint "c1" + insert into dcomptable values (row(1,2)::comptype); + insert into dcomptable values (row(2,1)::comptype); -- fail + ERROR: value for domain dcomptype violates check constraint "c1" + insert into dcomptable (d1.r) values(99); + insert into dcomptable (d1.r, d1.i) values(99, 100); + insert into dcomptable (d1.r, d1.i) values(100, 99); -- fail + ERROR: value for domain dcomptype violates check constraint "c1" + update dcomptable set d1.r = (d1).r + 1 where (d1).i > 0; -- fail + ERROR: value for domain dcomptype violates check constraint "c1" + update dcomptable set d1.r = (d1).r - 1, d1.i = (d1).i + 1 where (d1).i > 0; + select * from dcomptable; + d1 + ---------- + (11,) + (99,) + (1,3) + (3,5) + (0,3) + (98,101) + (6 rows) + + explain (verbose, costs off) + update dcomptable set d1.r = (d1).r - 1, d1.i = (d1).i + 1 where (d1).i > 0; + QUERY PLAN + ----------------------------------------------------------------------------------------------- + Update on public.dcomptable + -> Seq Scan on public.dcomptable + Output: ROW(((d1).r - '1'::double precision), ((d1).i + '1'::double precision)), ctid + Filter: ((dcomptable.d1).i > '0'::double precision) + (4 rows) + + create rule silly as on delete to dcomptable do instead + update dcomptable set d1.r = (d1).r - 1, d1.i = (d1).i + 1 where (d1).i > 0; + \d+ dcomptable + Table "public.dcomptable" + Column | Type | Collation | Nullable | Default | Storage | Stats target | Description + --------+-----------+-----------+----------+---------+----------+--------------+------------- + d1 | dcomptype | | | | extended | | + Indexes: + "dcomptable_d1_key" UNIQUE CONSTRAINT, btree (d1) + Rules: + silly AS + ON DELETE TO dcomptable DO INSTEAD UPDATE dcomptable SET d1.r = (dcomptable.d1).r - 1::double precision, d1.i = (dcomptable.d1).i + 1::double precision + WHERE (dcomptable.d1).i > 0::double precision + + drop table dcomptable; + drop type comptype cascade; + NOTICE: drop cascades to type dcomptype -- Test domains over arrays of composite create type comptype as (r float8, i float8); create domain dcomptypea as comptype[]; diff --git a/src/test/regress/sql/domain.sql b/src/test/regress/sql/domain.sql index 5ec128d..ba45165 100644 *** a/src/test/regress/sql/domain.sql --- b/src/test/regress/sql/domain.sql *************** select pg_typeof('{1,2,3}'::dia || 42); *** 120,125 **** --- 120,164 ---- drop domain dia; + -- Test domains over composites + + create type comptype as (r float8, i float8); + create domain dcomptype as comptype; + create table dcomptable (d1 dcomptype unique); + + insert into dcomptable values (row(1,2)::dcomptype); + insert into dcomptable values (row(3,4)::comptype); + insert into dcomptable values (row(1,2)::dcomptype); -- fail on uniqueness + insert into dcomptable (d1.r) values(11); + + select * from dcomptable; + select (d1).r, (d1).i, (d1).* from dcomptable; + update dcomptable set d1.r = (d1).r + 1 where (d1).i > 0; + select * from dcomptable; + + alter domain dcomptype add constraint c1 check ((value).r <= (value).i); + alter domain dcomptype add constraint c2 check ((value).r > (value).i); -- fail + + select row(2,1)::dcomptype; -- fail + insert into dcomptable values (row(1,2)::comptype); + insert into dcomptable values (row(2,1)::comptype); -- fail + insert into dcomptable (d1.r) values(99); + insert into dcomptable (d1.r, d1.i) values(99, 100); + insert into dcomptable (d1.r, d1.i) values(100, 99); -- fail + update dcomptable set d1.r = (d1).r + 1 where (d1).i > 0; -- fail + update dcomptable set d1.r = (d1).r - 1, d1.i = (d1).i + 1 where (d1).i > 0; + select * from dcomptable; + + explain (verbose, costs off) + update dcomptable set d1.r = (d1).r - 1, d1.i = (d1).i + 1 where (d1).i > 0; + create rule silly as on delete to dcomptable do instead + update dcomptable set d1.r = (d1).r - 1, d1.i = (d1).i + 1 where (d1).i > 0; + \d+ dcomptable + + drop table dcomptable; + drop type comptype cascade; + + -- Test domains over arrays of composite create type comptype as (r float8, i float8);