Change array comparison rules to consider dimensionality information,

not only the array contents, before claiming two arrays are equal.
Per recent discussion.

diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index c0e364a30b87cca1c754d826b2e6cbc81ac68e47..b6f1a40b4a0a46c293b852be5a352d1e1d43a943 100644 (file)
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -1,5 +1,5 @@
 <!--
-$PostgreSQL: pgsql/doc/src/sgml/func.sgml,v 1.294 2005/11/19 01:50:08 tgl Exp $
+$PostgreSQL: pgsql/doc/src/sgml/func.sgml,v 1.295 2005/11/19 19:44:54 tgl Exp $
 PostgreSQL documentation
 -->
 
@@ -7403,6 +7403,19 @@ SELECT NULLIF(value, '(none)') ...
      </tgroup>
     </table>
 
+  <para>
+   Array comparisons compare the array contents element-by-element,
+   using the default btree comparison function for the element data type.
+   In multidimensional arrays the elements are visited in row-major order
+   (last subscript varies most rapidly).
+   If the contents of two arrays are equal but the dimensionality is
+   different, the first difference in the dimensionality information
+   determines the sort order.  (This is a change from versions of
+   <productname>PostgreSQL</> prior to 8.2: older versions would claim
+   that two arrays with the same contents were equal, even if the
+   number of dimensions or subscript ranges were different.)
+  </para>
+
   <para>
    See <xref linkend="arrays"> for more details about array operator
    behavior.

diff --git a/src/backend/utils/adt/arrayfuncs.c b/src/backend/utils/adt/arrayfuncs.c
index 3818b181904644b93c22891b4e642f2d700dfeaa..ec7009816b84f07ba69540d92baadd572ae9f9d5 100644 (file)
--- a/src/backend/utils/adt/arrayfuncs.c
+++ b/src/backend/utils/adt/arrayfuncs.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $PostgreSQL: pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.124 2005/11/17 22:14:52 tgl Exp $
+ *   $PostgreSQL: pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.125 2005/11/19 19:44:55 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -2965,10 +2965,9 @@ array_eq(PG_FUNCTION_ARGS)
    int         ndims2 = ARR_NDIM(array2);
    int        *dims1 = ARR_DIMS(array1);
    int        *dims2 = ARR_DIMS(array2);
-   int         nitems1 = ArrayGetNItems(ndims1, dims1);
-   int         nitems2 = ArrayGetNItems(ndims2, dims2);
    Oid         element_type = ARR_ELEMTYPE(array1);
    bool        result = true;
+   int         nitems;
    TypeCacheEntry *typentry;
    int         typlen;
    bool        typbyval;
@@ -2986,8 +2985,9 @@ array_eq(PG_FUNCTION_ARGS)
                (errcode(ERRCODE_DATATYPE_MISMATCH),
                 errmsg("cannot compare arrays of different element types")));
 
-   /* fast path if the arrays do not have the same number of elements */
-   if (nitems1 != nitems2)
+   /* fast path if the arrays do not have the same dimensionality */
+   if (ndims1 != ndims2 ||
+       memcmp(dims1, dims2, 2 * ndims1 * sizeof(int)) != 0)
        result = false;
    else
    {
@@ -3021,13 +3021,14 @@ array_eq(PG_FUNCTION_ARGS)
                                 NULL, NULL);
 
        /* Loop over source data */
+       nitems = ArrayGetNItems(ndims1, dims1);
        ptr1 = ARR_DATA_PTR(array1);
        ptr2 = ARR_DATA_PTR(array2);
        bitmap1 = ARR_NULLBITMAP(array1);
        bitmap2 = ARR_NULLBITMAP(array2);
        bitmask = 1;            /* use same bitmask for both arrays */
 
-       for (i = 0; i < nitems1; i++)
+       for (i = 0; i < nitems; i++)
        {
            Datum       elt1;
            Datum       elt2;
@@ -3221,13 +3222,13 @@ array_cmp(FunctionCallInfo fcinfo)
                             NULL, NULL);
 
    /* Loop over source data */
+   min_nitems = Min(nitems1, nitems2);
    ptr1 = ARR_DATA_PTR(array1);
    ptr2 = ARR_DATA_PTR(array2);
    bitmap1 = ARR_NULLBITMAP(array1);
    bitmap2 = ARR_NULLBITMAP(array2);
    bitmask = 1;                /* use same bitmask for both arrays */
 
-   min_nitems = Min(nitems1, nitems2);
    for (i = 0; i < min_nitems; i++)
    {
        Datum       elt1;
@@ -3317,8 +3318,31 @@ array_cmp(FunctionCallInfo fcinfo)
        }
    }
 
-   if ((result == 0) && (nitems1 != nitems2))
-       result = (nitems1 < nitems2) ? -1 : 1;
+   /*
+    * If arrays contain same data (up to end of shorter one), apply additional
+    * rules to sort by dimensionality.  The relative significance of the
+    * different bits of information is historical; mainly we just care that
+    * we don't say "equal" for arrays of different dimensionality.
+    */
+   if (result == 0)
+   {
+       if (nitems1 != nitems2)
+           result = (nitems1 < nitems2) ? -1 : 1;
+       else if (ndims1 != ndims2)
+           result = (ndims1 < ndims2) ? -1 : 1;
+       else
+       {
+           /* this relies on LB array immediately following DIMS array */
+           for (i = 0; i < ndims1 * 2; i++)
+           {
+               if (dims1[i] != dims2[i])
+               {
+                   result = (dims1[i] < dims2[i]) ? -1 : 1;
+                   break;
+               }
+           }
+       }
+   }
 
    /* Avoid leaking memory when handed toasted input. */
    PG_FREE_IF_COPY(array1, 0);