Re: [PATCHES] array concat, et al patch

2003-08-19 Thread Tom Lane
Joe Conway [EMAIL PROTECTED] writes:
 Here's a patch for the documentation updates. Please apply.

Applied with one small change --- I thought the last example failed
to make the point that the elements of an ARRAY[] construct could be
dissimilar.

regards, tom lane

---(end of broadcast)---
TIP 1: subscribe and unsubscribe commands go to [EMAIL PROTECTED]


Re: [PATCHES] array concat, et al patch

2003-08-18 Thread Joe Conway
Tom Lane wrote:
You're on the hook for docs fixes...
Here's a patch for the documentation updates. Please apply.

Thanks,

Joe
Index: doc/src/sgml/array.sgml
===
RCS file: /opt/src/cvs/pgsql-server/doc/src/sgml/array.sgml,v
retrieving revision 1.29
diff -c -r1.29 array.sgml
*** doc/src/sgml/array.sgml 9 Aug 2003 22:50:21 -   1.29
--- doc/src/sgml/array.sgml 19 Aug 2003 05:31:16 -
***
*** 162,168 
expression syntax is discussed in more detail in xref
linkend=sql-syntax-array-constructors.
   /para
- 
   /sect2
  
   sect2
--- 162,167 
***
*** 326,334 
literal||/literal.
  programlisting
  SELECT ARRAY[1,2] || ARRAY[3,4];
!?column?
! ---
!  {{1,2},{3,4}}
  (1 row)
  
  SELECT ARRAY[5,6] || ARRAY[[1,2],[3,4]];
--- 325,333 
literal||/literal.
  programlisting
  SELECT ARRAY[1,2] || ARRAY[3,4];
!  ?column?
! ---
!  {1,2,3,4}
  (1 row)
  
  SELECT ARRAY[5,6] || ARRAY[[1,2],[3,4]];
***
*** 337,363 
   {{5,6},{1,2},{3,4}}
  (1 row)
  /programlisting
  
The concatenation operator allows a single element to be pushed on to the
beginning or end of a one-dimensional array. It also accepts two
replaceableN/-dimensional arrays, or an replaceableN/-dimensional
!   and an replaceableN+1/-dimensional array. In the former case, the two
!   replaceableN/-dimension arrays become outer elements of an
!   replaceableN+1/-dimensional array. In the latter, the
!   replaceableN/-dimensional array is added as either the first or last
!   outer element of the replaceableN+1/-dimensional array.
! 
!   When extending an array by concatenation, the subscripts of its existing
!   elements are preserved. For example, when pushing
!   onto the beginning of an array with one-based subscripts, the resulting
!   array has zero-based subscripts:
  
  programlisting
  SELECT array_dims(1 || ARRAY[2,3]);
   array_dims
  
   [0:2]
  (1 row)
  /programlisting
   /para
  
--- 336,403 
   {{5,6},{1,2},{3,4}}
  (1 row)
  /programlisting
+  /para
  
+  para
The concatenation operator allows a single element to be pushed on to the
beginning or end of a one-dimensional array. It also accepts two
replaceableN/-dimensional arrays, or an replaceableN/-dimensional
!   and an replaceableN+1/-dimensional array.
!  /para
  
+  para
+   When a single element is pushed on to the beginning of a one-dimensional
+   array, the result is an array with a lower bound subscript equal to
+   the righthand operand's lower bound subscript, minus one. When a single
+   element is pushed on to the end of a one-dimensional array, the result is
+   an array retaining the lower bound of the lefthand operand. For example:
  programlisting
  SELECT array_dims(1 || ARRAY[2,3]);
   array_dims
  
   [0:2]
  (1 row)
+ 
+ SELECT array_dims(ARRAY[1,2] || 3);
+  array_dims
+ 
+  [1:3]
+ (1 row)
+ /programlisting
+  /para
+ 
+  para
+   When two arrays with an equal number of dimensions are concatenated, the
+   result retains the lower bound subscript of the lefthand operand's outer
+   dimension. The result is an array comprising every element of the lefthand
+   operand followed by every element of the righthand operand. For example:
+ programlisting
+ SELECT array_dims(ARRAY[1,2] || ARRAY[3,4,5]);
+  array_dims
+ 
+  [1:5]
+ (1 row)
+ 
+ SELECT array_dims(ARRAY[[1,2],[3,4]] || ARRAY[[5,6],[7,8],[9,0]]);
+  array_dims
+ 
+  [1:5][1:2]
+ (1 row)
+ /programlisting
+  /para
+ 
+  para
+   When an replaceableN/-dimensional array is pushed on to the beginning
+   or end of an replaceableN+1/-dimensional array, the result is
+   analogous to the element-array case above. Each replaceableN/-dimensional
+   sub-array is essentially an element of the replaceableN+1/-dimensional
+   array's outer dimension. For example:
+ programlisting
+ SELECT array_dims(ARRAY[1,2] || ARRAY[[3,4],[5,6]]);
+  array_dims
+ 
+  [0:2][1:2]
+ (1 row)
  /programlisting
   /para
  
***
*** 386,394 
  (1 row)
  
  SELECT array_cat(ARRAY[1,2], ARRAY[3,4]);
!array_cat
! ---
!  {{1,2},{3,4}}
  (1 row)
  
  SELECT array_cat(ARRAY[[1,2],[3,4]], ARRAY[5,6]);
--- 426,434 
  (1 row)
  
  SELECT array_cat(ARRAY[1,2], ARRAY[3,4]);
!  array_cat
! ---
!  {1,2,3,4}
  (1 row)
  
  SELECT array_cat(ARRAY[[1,2],[3,4]], ARRAY[5,6]);
Index: doc/src/sgml/func.sgml
===
RCS file: /opt/src/cvs/pgsql-server/doc/src/sgml/func.sgml,v
retrieving revision 1.167
diff -c -r1.167 func.sgml
*** doc/src/sgml/func.sgml  17 Aug 2003 04:52:41 -  1.167
--- doc/src/sgml/func.sgml  19 Aug 2003 04:32:27 -
***
*** 7093,7099 
entry literal||/literal /entry
entryarray-to-array concatenation/entry

Re: [PATCHES] array concat, et al patch

2003-08-17 Thread Joe Conway
Tom Lane wrote:
Applied with only marginal changes.  (I thought the element-type checks
removed from parse_expr.c had better be applied at runtime; and
I noticed that array_cat scribbled on its inputs in some cases.)
Thanks!

You're on the hook for docs fixes...

I'm on it.

Joe

---(end of broadcast)---
TIP 3: if posting/reading through Usenet, please send an appropriate
 subscribe-nomail command to [EMAIL PROTECTED] so that your
 message can get through to the mailing list cleanly