fix-multiple-assignment-to-domain-over-array.patch

diff --git a/src/backend/rewrite/rewriteHandler.c b/src/backend/rewrite/rewriteHandler.c
index f3c7526..0a6f4f3 100644
*** a/src/backend/rewrite/rewriteHandler.c
--- b/src/backend/rewrite/rewriteHandler.c
*************** process_matched_tle(TargetEntry *src_tle
*** 934,939 ****
--- 934,940 ----
  					const char *attrName)
  {
  	TargetEntry *result;
+ 	CoerceToDomain *coerce_expr = NULL;
  	Node	   *src_expr;
  	Node	   *prior_expr;
  	Node	   *src_input;
*************** process_matched_tle(TargetEntry *src_tle
*** 970,979 ****
--- 971,1000 ----
  	 * For FieldStore, instead of nesting we can generate a single
  	 * FieldStore with multiple target fields.  We must nest when
  	 * ArrayRefs are involved though.
+ 	 *
+ 	 * As a further complication, the destination column might be a domain,
+ 	 * resulting in each assignment containing a CoerceToDomain node over a
+ 	 * FieldStore or ArrayRef.  These should have matching target domains, so
+ 	 * we strip them and reconstitute a single CoerceToDomain over the
+ 	 * combined FieldStore/ArrayRef nodes.  (Notice that this has the result
+ 	 * that the domain's checks are applied only after we do all the field or
+ 	 * element updates, not after each one.  This is arguably desirable.)
  	 *----------
  	 */
  	src_expr = (Node *) src_tle->expr;
  	prior_expr = (Node *) prior_tle->expr;
+ 
+ 	if (src_expr && IsA(src_expr, CoerceToDomain) &&
+ 		prior_expr && IsA(prior_expr, CoerceToDomain) &&
+ 		((CoerceToDomain *) src_expr)->resulttype ==
+ 		((CoerceToDomain *) prior_expr)->resulttype)
+ 	{
+ 		/* we assume without checking that resulttypmod/resultcollid match */
+ 		coerce_expr = (CoerceToDomain *) src_expr;
+ 		src_expr = (Node *) ((CoerceToDomain *) src_expr)->arg;
+ 		prior_expr = (Node *) ((CoerceToDomain *) prior_expr)->arg;
+ 	}
+ 
  	src_input = get_assignment_input(src_expr);
  	prior_input = get_assignment_input(prior_expr);
  	if (src_input == NULL ||
*************** process_matched_tle(TargetEntry *src_tle
*** 1042,1047 ****
--- 1063,1078 ----
  		newexpr = NULL;
  	}
  
+ 	if (coerce_expr)
+ 	{
+ 		/* put back the CoerceToDomain */
+ 		CoerceToDomain *newcoerce = makeNode(CoerceToDomain);
+ 
+ 		memcpy(newcoerce, coerce_expr, sizeof(CoerceToDomain));
+ 		newcoerce->arg = (Expr *) newexpr;
+ 		newexpr = (Node *) newcoerce;
+ 	}
+ 
  	result = flatCopyTargetEntry(src_tle);
  	result->expr = (Expr *) newexpr;
  	return result;
diff --git a/src/test/regress/expected/domain.out b/src/test/regress/expected/domain.out
index 41b70e2..9fb750d 100644
*** a/src/test/regress/expected/domain.out
--- b/src/test/regress/expected/domain.out
*************** INSERT INTO domarrtest values ('{2,2}', 
*** 107,112 ****
--- 107,113 ----
  INSERT INTO domarrtest values (NULL, '{{"a","b","c"},{"d","e","f"}}');
  INSERT INTO domarrtest values (NULL, '{{"toolong","b","c"},{"d","e","f"}}');
  ERROR:  value too long for type character varying(4)
+ INSERT INTO domarrtest (testint4arr[1], testint4arr[3]) values (11,22);
  select * from domarrtest;
    testint4arr  |    testchar4arr     
  ---------------+---------------------
*************** select * from domarrtest;
*** 115,121 ****
   {2,2}         | {{a,b},{c,d},{e,f}}
   {2,2}         | {{a},{c}}
                 | {{a,b,c},{d,e,f}}
! (5 rows)
  
  select testint4arr[1], testchar4arr[2:2] from domarrtest;
   testint4arr | testchar4arr 
--- 116,123 ----
   {2,2}         | {{a,b},{c,d},{e,f}}
   {2,2}         | {{a},{c}}
                 | {{a,b,c},{d,e,f}}
!  {11,NULL,22}  | 
! (6 rows)
  
  select testint4arr[1], testchar4arr[2:2] from domarrtest;
   testint4arr | testchar4arr 
*************** select testint4arr[1], testchar4arr[2:2]
*** 125,131 ****
             2 | {{c,d}}
             2 | {{c}}
               | {{d,e,f}}
! (5 rows)
  
  select array_dims(testint4arr), array_dims(testchar4arr) from domarrtest;
   array_dims | array_dims 
--- 127,134 ----
             2 | {{c,d}}
             2 | {{c}}
               | {{d,e,f}}
!           11 | 
! (6 rows)
  
  select array_dims(testint4arr), array_dims(testchar4arr) from domarrtest;
   array_dims | array_dims 
*************** select array_dims(testint4arr), array_di
*** 135,141 ****
   [1:2]      | [1:3][1:2]
   [1:2]      | [1:2][1:1]
              | [1:2][1:3]
! (5 rows)
  
  COPY domarrtest FROM stdin;
  COPY domarrtest FROM stdin;	-- fail
--- 138,145 ----
   [1:2]      | [1:3][1:2]
   [1:2]      | [1:2][1:1]
              | [1:2][1:3]
!  [1:3]      | 
! (6 rows)
  
  COPY domarrtest FROM stdin;
  COPY domarrtest FROM stdin;	-- fail
*************** select * from domarrtest;
*** 149,157 ****
   {2,2}         | {{a,b},{c,d},{e,f}}
   {2,2}         | {{a},{c}}
                 | {{a,b,c},{d,e,f}}
   {3,4}         | {q,w,e}
                 | 
! (7 rows)
  
  drop table domarrtest;
  drop domain domainint4arr restrict;
--- 153,173 ----
   {2,2}         | {{a,b},{c,d},{e,f}}
   {2,2}         | {{a},{c}}
                 | {{a,b,c},{d,e,f}}
+  {11,NULL,22}  | 
   {3,4}         | {q,w,e}
                 | 
! (8 rows)
! 
! update domarrtest set
!   testint4arr[1] = testint4arr[1] + 1,
!   testint4arr[3] = testint4arr[3] - 1
! where testchar4arr is null;
! select * from domarrtest where testchar4arr is null;
!    testint4arr    | testchar4arr 
! ------------------+--------------
!  {12,NULL,21}     | 
!  {NULL,NULL,NULL} | 
! (2 rows)
  
  drop table domarrtest;
  drop domain domainint4arr restrict;
*************** select pg_typeof('{1,2,3}'::dia || 42); 
*** 182,187 ****
--- 198,289 ----
  (1 row)
  
  drop domain dia;
+ -- Test domains over arrays of composite
+ create type comptype as (r float8, i float8);
+ create domain dcomptypea as comptype[];
+ create table dcomptable (d1 dcomptypea unique);
+ insert into dcomptable values (array[row(1,2)]::dcomptypea);
+ insert into dcomptable values (array[row(3,4), row(5,6)]::comptype[]);
+ insert into dcomptable values (array[row(7,8)::comptype, row(9,10)::comptype]);
+ insert into dcomptable values (array[row(1,2)]::dcomptypea);  -- fail on uniqueness
+ ERROR:  duplicate key value violates unique constraint "dcomptable_d1_key"
+ DETAIL:  Key (d1)=({"(1,2)"}) already exists.
+ insert into dcomptable (d1[1]) values(row(9,10));
+ insert into dcomptable (d1[1].r) values(11);
+ select * from dcomptable;
+          d1         
+ --------------------
+  {"(1,2)"}
+  {"(3,4)","(5,6)"}
+  {"(7,8)","(9,10)"}
+  {"(9,10)"}
+  {"(11,)"}
+ (5 rows)
+ 
+ select d1[2], d1[1].r, d1[1].i from dcomptable;
+    d1   | r  | i  
+ --------+----+----
+         |  1 |  2
+  (5,6)  |  3 |  4
+  (9,10) |  7 |  8
+         |  9 | 10
+         | 11 |   
+ (5 rows)
+ 
+ update dcomptable set d1[2] = row(d1[2].i, d1[2].r);
+ select * from dcomptable;
+          d1         
+ --------------------
+  {"(1,2)","(,)"}
+  {"(3,4)","(6,5)"}
+  {"(7,8)","(10,9)"}
+  {"(9,10)","(,)"}
+  {"(11,)","(,)"}
+ (5 rows)
+ 
+ update dcomptable set d1[1].r = d1[1].r + 1 where d1[1].i > 0;
+ select * from dcomptable;
+          d1         
+ --------------------
+  {"(11,)","(,)"}
+  {"(2,2)","(,)"}
+  {"(4,4)","(6,5)"}
+  {"(8,8)","(10,9)"}
+  {"(10,10)","(,)"}
+ (5 rows)
+ 
+ alter domain dcomptypea add constraint c1 check (value[1].r <= value[1].i);
+ alter domain dcomptypea add constraint c2 check (value[1].r > value[1].i);  -- fail
+ ERROR:  column "d1" of table "dcomptable" contains values that violate the new constraint
+ select array[row(2,1)]::dcomptypea;  -- fail
+ ERROR:  value for domain dcomptypea violates check constraint "c1"
+ insert into dcomptable values (array[row(1,2)]::comptype[]);
+ insert into dcomptable values (array[row(2,1)]::comptype[]);  -- fail
+ ERROR:  value for domain dcomptypea violates check constraint "c1"
+ insert into dcomptable (d1[1].r) values(99);
+ insert into dcomptable (d1[1].r, d1[1].i) values(99, 100);
+ insert into dcomptable (d1[1].r, d1[1].i) values(100, 99);  -- fail
+ ERROR:  value for domain dcomptypea violates check constraint "c1"
+ update dcomptable set d1[1].r = d1[1].r + 1 where d1[1].i > 0;  -- fail
+ ERROR:  value for domain dcomptypea violates check constraint "c1"
+ update dcomptable set d1[1].r = d1[1].r - 1 where d1[1].i > 0;
+ select * from dcomptable;
+          d1         
+ --------------------
+  {"(11,)","(,)"}
+  {"(99,)"}
+  {"(1,2)","(,)"}
+  {"(3,4)","(6,5)"}
+  {"(7,8)","(10,9)"}
+  {"(9,10)","(,)"}
+  {"(0,2)"}
+  {"(98,100)"}
+ (8 rows)
+ 
+ drop table dcomptable;
+ drop type comptype cascade;
+ NOTICE:  drop cascades to type dcomptypea
+ -- Test not-null restrictions
  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');
diff --git a/src/test/regress/sql/domain.sql b/src/test/regress/sql/domain.sql
index 407d3ef..1fd7b11 100644
*** a/src/test/regress/sql/domain.sql
--- b/src/test/regress/sql/domain.sql
*************** INSERT INTO domarrtest values ('{2,2}', 
*** 85,90 ****
--- 85,91 ----
  INSERT INTO domarrtest values ('{2,2}', '{{"a"},{"c"}}');
  INSERT INTO domarrtest values (NULL, '{{"a","b","c"},{"d","e","f"}}');
  INSERT INTO domarrtest values (NULL, '{{"toolong","b","c"},{"d","e","f"}}');
+ INSERT INTO domarrtest (testint4arr[1], testint4arr[3]) values (11,22);
  select * from domarrtest;
  select testint4arr[1], testchar4arr[2:2] from domarrtest;
  select array_dims(testint4arr), array_dims(testchar4arr) from domarrtest;
*************** COPY domarrtest FROM stdin;	-- fail
*** 100,105 ****
--- 101,113 ----
  
  select * from domarrtest;
  
+ update domarrtest set
+   testint4arr[1] = testint4arr[1] + 1,
+   testint4arr[3] = testint4arr[3] - 1
+ where testchar4arr is null;
+ 
+ select * from domarrtest where testchar4arr is null;
+ 
  drop table domarrtest;
  drop domain domainint4arr restrict;
  drop domain domainchar4arr restrict;
*************** select pg_typeof('{1,2,3}'::dia);
*** 111,116 ****
--- 119,164 ----
  select pg_typeof('{1,2,3}'::dia || 42); -- should be int[] not dia
  drop domain dia;
  
+ 
+ -- Test domains over arrays of composite
+ 
+ create type comptype as (r float8, i float8);
+ create domain dcomptypea as comptype[];
+ create table dcomptable (d1 dcomptypea unique);
+ 
+ insert into dcomptable values (array[row(1,2)]::dcomptypea);
+ insert into dcomptable values (array[row(3,4), row(5,6)]::comptype[]);
+ insert into dcomptable values (array[row(7,8)::comptype, row(9,10)::comptype]);
+ insert into dcomptable values (array[row(1,2)]::dcomptypea);  -- fail on uniqueness
+ insert into dcomptable (d1[1]) values(row(9,10));
+ insert into dcomptable (d1[1].r) values(11);
+ 
+ select * from dcomptable;
+ select d1[2], d1[1].r, d1[1].i from dcomptable;
+ update dcomptable set d1[2] = row(d1[2].i, d1[2].r);
+ select * from dcomptable;
+ update dcomptable set d1[1].r = d1[1].r + 1 where d1[1].i > 0;
+ select * from dcomptable;
+ 
+ alter domain dcomptypea add constraint c1 check (value[1].r <= value[1].i);
+ alter domain dcomptypea add constraint c2 check (value[1].r > value[1].i);  -- fail
+ 
+ select array[row(2,1)]::dcomptypea;  -- fail
+ insert into dcomptable values (array[row(1,2)]::comptype[]);
+ insert into dcomptable values (array[row(2,1)]::comptype[]);  -- fail
+ insert into dcomptable (d1[1].r) values(99);
+ insert into dcomptable (d1[1].r, d1[1].i) values(99, 100);
+ insert into dcomptable (d1[1].r, d1[1].i) values(100, 99);  -- fail
+ update dcomptable set d1[1].r = d1[1].r + 1 where d1[1].i > 0;  -- fail
+ update dcomptable set d1[1].r = d1[1].r - 1 where d1[1].i > 0;
+ select * from dcomptable;
+ 
+ drop table dcomptable;
+ drop type comptype cascade;
+ 
+ 
+ -- Test not-null restrictions
+ 
  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');