Rewrite array_cmp to not depend on deconstruct_array. Should be a little

faster, but more importantly does not leak memory.  Still needs more work
though, per my recent note to pgsql-hackers.

diff --git a/src/backend/utils/adt/arrayfuncs.c b/src/backend/utils/adt/arrayfuncs.c
index df8265d99956380c240aa423080636e7b752ba79..37504718ad5e234f6b20a886836ec358238b13b4 100644 (file)
--- a/src/backend/utils/adt/arrayfuncs.c
+++ b/src/backend/utils/adt/arrayfuncs.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.97 2003/08/08 21:42:04 momjian Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.98 2003/08/15 00:22:26 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -2510,18 +2510,21 @@ array_cmp(FunctionCallInfo fcinfo)
 {
        ArrayType  *array1 = PG_GETARG_ARRAYTYPE_P(0);
        ArrayType  *array2 = PG_GETARG_ARRAYTYPE_P(1);
+       char       *p1 = (char *) ARR_DATA_PTR(array1);
+       char       *p2 = (char *) ARR_DATA_PTR(array2);
+       int                     ndims1 = ARR_NDIM(array1);
+       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);
        FmgrInfo   *ac_fmgr_info = fcinfo->flinfo;
-       Datum           opresult;
        int                     result = 0;
-       Oid                     element_type = InvalidOid;
        int                     typlen;
        bool            typbyval;
        char            typalign;
-       Datum      *dvalues1;
-       int                     nelems1;
-       Datum      *dvalues2;
-       int                     nelems2;
-       int                     min_nelems;
+       int                     min_nitems;
        int                     i;
        typedef struct
        {
@@ -2534,7 +2537,6 @@ array_cmp(FunctionCallInfo fcinfo)
        } ac_extra;
        ac_extra   *my_extra;
 
-       element_type = ARR_ELEMTYPE(array1);
        if (element_type != ARR_ELEMTYPE(array2))
                ereport(ERROR,
                                (errcode(ERRCODE_DATATYPE_MISMATCH),
@@ -2573,42 +2575,49 @@ array_cmp(FunctionCallInfo fcinfo)
        typbyval = my_extra->typbyval;
        typalign = my_extra->typalign;
 
-       /* extract a C array of arg array datums */
-       deconstruct_array(array1, element_type, typlen, typbyval, typalign,
-                                         &dvalues1, &nelems1);
+       /* Loop over source data */
+       min_nitems = Min(nitems1, nitems2);
+       for (i = 0; i < min_nitems; i++)
+       {
+               Datum           elt1;
+               Datum           elt2;
+               Datum           opresult;
+
+               /* Get element pair */
+               elt1 = fetch_att(p1, typbyval, typlen);
+               elt2 = fetch_att(p2, typbyval, typlen);
 
-       deconstruct_array(array2, element_type, typlen, typbyval, typalign,
-                                         &dvalues2, &nelems2);
+               p1 = att_addlength(p1, typlen, PointerGetDatum(p1));
+               p1 = (char *) att_align(p1, typalign);
+
+               p2 = att_addlength(p2, typlen, PointerGetDatum(p2));
+               p2 = (char *) att_align(p2, typalign);
+
+               /* Compare the pair of elements */
 
-       min_nelems = Min(nelems1, nelems2);
-       for (i = 0; i < min_nelems; i++)
-       {
                /* are they equal */
-               opresult = FunctionCall2(&my_extra->eqproc,
-                                                                dvalues1[i], dvalues2[i]);
+               opresult = FunctionCall2(&my_extra->eqproc, elt1, elt2);
+               if (DatumGetBool(opresult))
+                       continue;
 
-               if (!DatumGetBool(opresult))
+               /* nope, see if arg1 is less than arg2 */
+               opresult = FunctionCall2(&my_extra->ordproc, elt1, elt2);
+               if (DatumGetBool(opresult))
                {
-                       /* nope, see if arg1 is less than arg2 */
-                       opresult = FunctionCall2(&my_extra->ordproc,
-                                                                        dvalues1[i], dvalues2[i]);
-                       if (DatumGetBool(opresult))
-                       {
-                               /* arg1 is less than arg2 */
-                               result = -1;
-                               break;
-                       }
-                       else
-                       {
-                               /* arg1 is greater than arg2 */
-                               result = 1;
-                               break;
-                       }
+                       /* arg1 is less than arg2 */
+                       result = -1;
+                       break;
+               }
+               else
+               {
+                       /* arg1 is greater than arg2 */
+                       result = 1;
+                       break;
                }
        }
 
-       if ((result == 0) && (nelems1 != nelems2))
-               result = (nelems1 < nelems2) ? -1 : 1;
+       if ((result == 0) && (nitems1 != nitems2))
+               result = (nitems1 < nitems2) ? -1 : 1;
 
        /* Avoid leaking memory when handed toasted input. */
        PG_FREE_IF_COPY(array1, 0);