LCOV - code coverage report
Current view: top level - src/backend/utils/adt - rowtypes.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 668 843 79.2 %
Date: 2024-07-18 18:11:10 Functions: 22 24 91.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * rowtypes.c
       4             :  *    I/O and comparison functions for generic composite types.
       5             :  *
       6             :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/backend/utils/adt/rowtypes.c
      12             :  *
      13             :  *-------------------------------------------------------------------------
      14             :  */
      15             : #include "postgres.h"
      16             : 
      17             : #include <ctype.h>
      18             : 
      19             : #include "access/detoast.h"
      20             : #include "access/htup_details.h"
      21             : #include "catalog/pg_type.h"
      22             : #include "funcapi.h"
      23             : #include "libpq/pqformat.h"
      24             : #include "miscadmin.h"
      25             : #include "utils/builtins.h"
      26             : #include "utils/datum.h"
      27             : #include "utils/lsyscache.h"
      28             : #include "utils/typcache.h"
      29             : 
      30             : 
      31             : /*
      32             :  * structure to cache metadata needed for record I/O
      33             :  */
      34             : typedef struct ColumnIOData
      35             : {
      36             :     Oid         column_type;
      37             :     Oid         typiofunc;
      38             :     Oid         typioparam;
      39             :     bool        typisvarlena;
      40             :     FmgrInfo    proc;
      41             : } ColumnIOData;
      42             : 
      43             : typedef struct RecordIOData
      44             : {
      45             :     Oid         record_type;
      46             :     int32       record_typmod;
      47             :     int         ncolumns;
      48             :     ColumnIOData columns[FLEXIBLE_ARRAY_MEMBER];
      49             : } RecordIOData;
      50             : 
      51             : /*
      52             :  * structure to cache metadata needed for record comparison
      53             :  */
      54             : typedef struct ColumnCompareData
      55             : {
      56             :     TypeCacheEntry *typentry;   /* has everything we need, actually */
      57             : } ColumnCompareData;
      58             : 
      59             : typedef struct RecordCompareData
      60             : {
      61             :     int         ncolumns;       /* allocated length of columns[] */
      62             :     Oid         record1_type;
      63             :     int32       record1_typmod;
      64             :     Oid         record2_type;
      65             :     int32       record2_typmod;
      66             :     ColumnCompareData columns[FLEXIBLE_ARRAY_MEMBER];
      67             : } RecordCompareData;
      68             : 
      69             : 
      70             : /*
      71             :  * record_in        - input routine for any composite type.
      72             :  */
      73             : Datum
      74        1702 : record_in(PG_FUNCTION_ARGS)
      75             : {
      76        1702 :     char       *string = PG_GETARG_CSTRING(0);
      77        1702 :     Oid         tupType = PG_GETARG_OID(1);
      78        1702 :     int32       tupTypmod = PG_GETARG_INT32(2);
      79        1702 :     Node       *escontext = fcinfo->context;
      80             :     HeapTupleHeader result;
      81             :     TupleDesc   tupdesc;
      82             :     HeapTuple   tuple;
      83             :     RecordIOData *my_extra;
      84        1702 :     bool        needComma = false;
      85             :     int         ncolumns;
      86             :     int         i;
      87             :     char       *ptr;
      88             :     Datum      *values;
      89             :     bool       *nulls;
      90             :     StringInfoData buf;
      91             : 
      92        1702 :     check_stack_depth();        /* recurses for record-type columns */
      93             : 
      94             :     /*
      95             :      * Give a friendly error message if we did not get enough info to identify
      96             :      * the target record type.  (lookup_rowtype_tupdesc would fail anyway, but
      97             :      * with a non-user-friendly message.)  In ordinary SQL usage, we'll get -1
      98             :      * for typmod, since composite types and RECORD have no type modifiers at
      99             :      * the SQL level, and thus must fail for RECORD.  However some callers can
     100             :      * supply a valid typmod, and then we can do something useful for RECORD.
     101             :      */
     102        1702 :     if (tupType == RECORDOID && tupTypmod < 0)
     103           0 :         ereturn(escontext, (Datum) 0,
     104             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     105             :                  errmsg("input of anonymous composite types is not implemented")));
     106             : 
     107             :     /*
     108             :      * This comes from the composite type's pg_type.oid and stores system oids
     109             :      * in user tables, specifically DatumTupleFields. This oid must be
     110             :      * preserved by binary upgrades.
     111             :      */
     112        1702 :     tupdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
     113        1702 :     ncolumns = tupdesc->natts;
     114             : 
     115             :     /*
     116             :      * We arrange to look up the needed I/O info just once per series of
     117             :      * calls, assuming the record type doesn't change underneath us.
     118             :      */
     119        1702 :     my_extra = (RecordIOData *) fcinfo->flinfo->fn_extra;
     120        1702 :     if (my_extra == NULL ||
     121         986 :         my_extra->ncolumns != ncolumns)
     122             :     {
     123        1432 :         fcinfo->flinfo->fn_extra =
     124         716 :             MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
     125             :                                offsetof(RecordIOData, columns) +
     126         716 :                                ncolumns * sizeof(ColumnIOData));
     127         716 :         my_extra = (RecordIOData *) fcinfo->flinfo->fn_extra;
     128         716 :         my_extra->record_type = InvalidOid;
     129         716 :         my_extra->record_typmod = 0;
     130             :     }
     131             : 
     132        1702 :     if (my_extra->record_type != tupType ||
     133         986 :         my_extra->record_typmod != tupTypmod)
     134             :     {
     135       17140 :         MemSet(my_extra, 0,
     136             :                offsetof(RecordIOData, columns) +
     137             :                ncolumns * sizeof(ColumnIOData));
     138         716 :         my_extra->record_type = tupType;
     139         716 :         my_extra->record_typmod = tupTypmod;
     140         716 :         my_extra->ncolumns = ncolumns;
     141             :     }
     142             : 
     143        1702 :     values = (Datum *) palloc(ncolumns * sizeof(Datum));
     144        1702 :     nulls = (bool *) palloc(ncolumns * sizeof(bool));
     145             : 
     146             :     /*
     147             :      * Scan the string.  We use "buf" to accumulate the de-quoted data for
     148             :      * each column, which is then fed to the appropriate input converter.
     149             :      */
     150        1702 :     ptr = string;
     151             :     /* Allow leading whitespace */
     152        1708 :     while (*ptr && isspace((unsigned char) *ptr))
     153           6 :         ptr++;
     154        1702 :     if (*ptr++ != '(')
     155             :     {
     156          10 :         errsave(escontext,
     157             :                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
     158             :                  errmsg("malformed record literal: \"%s\"", string),
     159             :                  errdetail("Missing left parenthesis.")));
     160           0 :         goto fail;
     161             :     }
     162             : 
     163        1692 :     initStringInfo(&buf);
     164             : 
     165        7986 :     for (i = 0; i < ncolumns; i++)
     166             :     {
     167        6332 :         Form_pg_attribute att = TupleDescAttr(tupdesc, i);
     168        6332 :         ColumnIOData *column_info = &my_extra->columns[i];
     169        6332 :         Oid         column_type = att->atttypid;
     170             :         char       *column_data;
     171             : 
     172             :         /* Ignore dropped columns in datatype, but fill with nulls */
     173        6332 :         if (att->attisdropped)
     174             :         {
     175         330 :             values[i] = (Datum) 0;
     176         330 :             nulls[i] = true;
     177         330 :             continue;
     178             :         }
     179             : 
     180        6002 :         if (needComma)
     181             :         {
     182             :             /* Skip comma that separates prior field from this one */
     183        4310 :             if (*ptr == ',')
     184        4304 :                 ptr++;
     185             :             else
     186             :                 /* *ptr must be ')' */
     187             :             {
     188           6 :                 errsave(escontext,
     189             :                         (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
     190             :                          errmsg("malformed record literal: \"%s\"", string),
     191             :                          errdetail("Too few columns.")));
     192           0 :                 goto fail;
     193             :             }
     194             :         }
     195             : 
     196             :         /* Check for null: completely empty input means null */
     197        5996 :         if (*ptr == ',' || *ptr == ')')
     198             :         {
     199         470 :             column_data = NULL;
     200         470 :             nulls[i] = true;
     201             :         }
     202             :         else
     203             :         {
     204             :             /* Extract string for this column */
     205        5526 :             bool        inquote = false;
     206             : 
     207        5526 :             resetStringInfo(&buf);
     208       32114 :             while (inquote || !(*ptr == ',' || *ptr == ')'))
     209             :             {
     210       26594 :                 char        ch = *ptr++;
     211             : 
     212       26594 :                 if (ch == '\0')
     213             :                 {
     214           6 :                     errsave(escontext,
     215             :                             (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
     216             :                              errmsg("malformed record literal: \"%s\"",
     217             :                                     string),
     218             :                              errdetail("Unexpected end of input.")));
     219           6 :                     goto fail;
     220             :                 }
     221       26588 :                 if (ch == '\\')
     222             :                 {
     223           6 :                     if (*ptr == '\0')
     224             :                     {
     225           0 :                         errsave(escontext,
     226             :                                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
     227             :                                  errmsg("malformed record literal: \"%s\"",
     228             :                                         string),
     229             :                                  errdetail("Unexpected end of input.")));
     230           0 :                         goto fail;
     231             :                     }
     232           6 :                     appendStringInfoChar(&buf, *ptr++);
     233             :                 }
     234       26582 :                 else if (ch == '"')
     235             :                 {
     236        1766 :                     if (!inquote)
     237         852 :                         inquote = true;
     238         914 :                     else if (*ptr == '"')
     239             :                     {
     240             :                         /* doubled quote within quote sequence */
     241          62 :                         appendStringInfoChar(&buf, *ptr++);
     242             :                     }
     243             :                     else
     244         852 :                         inquote = false;
     245             :                 }
     246             :                 else
     247       24816 :                     appendStringInfoChar(&buf, ch);
     248             :             }
     249             : 
     250        5520 :             column_data = buf.data;
     251        5520 :             nulls[i] = false;
     252             :         }
     253             : 
     254             :         /*
     255             :          * Convert the column value
     256             :          */
     257        5990 :         if (column_info->column_type != column_type)
     258             :         {
     259        1808 :             getTypeInputInfo(column_type,
     260             :                              &column_info->typiofunc,
     261             :                              &column_info->typioparam);
     262        1808 :             fmgr_info_cxt(column_info->typiofunc, &column_info->proc,
     263        1808 :                           fcinfo->flinfo->fn_mcxt);
     264        1808 :             column_info->column_type = column_type;
     265             :         }
     266             : 
     267        5982 :         if (!InputFunctionCallSafe(&column_info->proc,
     268             :                                    column_data,
     269             :                                    column_info->typioparam,
     270             :                                    att->atttypmod,
     271             :                                    escontext,
     272        5990 :                                    &values[i]))
     273          18 :             goto fail;
     274             : 
     275             :         /*
     276             :          * Prep for next column
     277             :          */
     278        5964 :         needComma = true;
     279             :     }
     280             : 
     281        1654 :     if (*ptr++ != ')')
     282             :     {
     283           6 :         errsave(escontext,
     284             :                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
     285             :                  errmsg("malformed record literal: \"%s\"", string),
     286             :                  errdetail("Too many columns.")));
     287           0 :         goto fail;
     288             :     }
     289             :     /* Allow trailing whitespace */
     290        1666 :     while (*ptr && isspace((unsigned char) *ptr))
     291          18 :         ptr++;
     292        1648 :     if (*ptr)
     293             :     {
     294           6 :         errsave(escontext,
     295             :                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
     296             :                  errmsg("malformed record literal: \"%s\"", string),
     297             :                  errdetail("Junk after right parenthesis.")));
     298           0 :         goto fail;
     299             :     }
     300             : 
     301        1642 :     tuple = heap_form_tuple(tupdesc, values, nulls);
     302             : 
     303             :     /*
     304             :      * We cannot return tuple->t_data because heap_form_tuple allocates it as
     305             :      * part of a larger chunk, and our caller may expect to be able to pfree
     306             :      * our result.  So must copy the info into a new palloc chunk.
     307             :      */
     308        1642 :     result = (HeapTupleHeader) palloc(tuple->t_len);
     309        1642 :     memcpy(result, tuple->t_data, tuple->t_len);
     310             : 
     311        1642 :     heap_freetuple(tuple);
     312        1642 :     pfree(buf.data);
     313        1642 :     pfree(values);
     314        1642 :     pfree(nulls);
     315        1642 :     ReleaseTupleDesc(tupdesc);
     316             : 
     317        1642 :     PG_RETURN_HEAPTUPLEHEADER(result);
     318             : 
     319             :     /* exit here once we've done lookup_rowtype_tupdesc */
     320          24 : fail:
     321          24 :     ReleaseTupleDesc(tupdesc);
     322          24 :     PG_RETURN_NULL();
     323             : }
     324             : 
     325             : /*
     326             :  * record_out       - output routine for any composite type.
     327             :  */
     328             : Datum
     329       34868 : record_out(PG_FUNCTION_ARGS)
     330             : {
     331       34868 :     HeapTupleHeader rec = PG_GETARG_HEAPTUPLEHEADER(0);
     332             :     Oid         tupType;
     333             :     int32       tupTypmod;
     334             :     TupleDesc   tupdesc;
     335             :     HeapTupleData tuple;
     336             :     RecordIOData *my_extra;
     337       34868 :     bool        needComma = false;
     338             :     int         ncolumns;
     339             :     int         i;
     340             :     Datum      *values;
     341             :     bool       *nulls;
     342             :     StringInfoData buf;
     343             : 
     344       34868 :     check_stack_depth();        /* recurses for record-type columns */
     345             : 
     346             :     /* Extract type info from the tuple itself */
     347       34868 :     tupType = HeapTupleHeaderGetTypeId(rec);
     348       34868 :     tupTypmod = HeapTupleHeaderGetTypMod(rec);
     349       34868 :     tupdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
     350       34868 :     ncolumns = tupdesc->natts;
     351             : 
     352             :     /* Build a temporary HeapTuple control structure */
     353       34868 :     tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
     354       34868 :     ItemPointerSetInvalid(&(tuple.t_self));
     355       34868 :     tuple.t_tableOid = InvalidOid;
     356       34868 :     tuple.t_data = rec;
     357             : 
     358             :     /*
     359             :      * We arrange to look up the needed I/O info just once per series of
     360             :      * calls, assuming the record type doesn't change underneath us.
     361             :      */
     362       34868 :     my_extra = (RecordIOData *) fcinfo->flinfo->fn_extra;
     363       34868 :     if (my_extra == NULL ||
     364       30124 :         my_extra->ncolumns != ncolumns)
     365             :     {
     366        9536 :         fcinfo->flinfo->fn_extra =
     367        4768 :             MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
     368             :                                offsetof(RecordIOData, columns) +
     369        4768 :                                ncolumns * sizeof(ColumnIOData));
     370        4768 :         my_extra = (RecordIOData *) fcinfo->flinfo->fn_extra;
     371        4768 :         my_extra->record_type = InvalidOid;
     372        4768 :         my_extra->record_typmod = 0;
     373             :     }
     374             : 
     375       34868 :     if (my_extra->record_type != tupType ||
     376       30100 :         my_extra->record_typmod != tupTypmod)
     377             :     {
     378      106672 :         MemSet(my_extra, 0,
     379             :                offsetof(RecordIOData, columns) +
     380             :                ncolumns * sizeof(ColumnIOData));
     381        4808 :         my_extra->record_type = tupType;
     382        4808 :         my_extra->record_typmod = tupTypmod;
     383        4808 :         my_extra->ncolumns = ncolumns;
     384             :     }
     385             : 
     386       34868 :     values = (Datum *) palloc(ncolumns * sizeof(Datum));
     387       34868 :     nulls = (bool *) palloc(ncolumns * sizeof(bool));
     388             : 
     389             :     /* Break down the tuple into fields */
     390       34868 :     heap_deform_tuple(&tuple, tupdesc, values, nulls);
     391             : 
     392             :     /* And build the result string */
     393       34868 :     initStringInfo(&buf);
     394             : 
     395       34868 :     appendStringInfoChar(&buf, '(');
     396             : 
     397      211920 :     for (i = 0; i < ncolumns; i++)
     398             :     {
     399      177052 :         Form_pg_attribute att = TupleDescAttr(tupdesc, i);
     400      177052 :         ColumnIOData *column_info = &my_extra->columns[i];
     401      177052 :         Oid         column_type = att->atttypid;
     402             :         Datum       attr;
     403             :         char       *value;
     404             :         char       *tmp;
     405             :         bool        nq;
     406             : 
     407             :         /* Ignore dropped columns in datatype */
     408      177052 :         if (att->attisdropped)
     409         492 :             continue;
     410             : 
     411      176560 :         if (needComma)
     412      141698 :             appendStringInfoChar(&buf, ',');
     413      176560 :         needComma = true;
     414             : 
     415      176560 :         if (nulls[i])
     416             :         {
     417             :             /* emit nothing... */
     418        4182 :             continue;
     419             :         }
     420             : 
     421             :         /*
     422             :          * Convert the column value to text
     423             :          */
     424      172378 :         if (column_info->column_type != column_type)
     425             :         {
     426       10990 :             getTypeOutputInfo(column_type,
     427             :                               &column_info->typiofunc,
     428             :                               &column_info->typisvarlena);
     429       10990 :             fmgr_info_cxt(column_info->typiofunc, &column_info->proc,
     430       10990 :                           fcinfo->flinfo->fn_mcxt);
     431       10990 :             column_info->column_type = column_type;
     432             :         }
     433             : 
     434      172378 :         attr = values[i];
     435      172378 :         value = OutputFunctionCall(&column_info->proc, attr);
     436             : 
     437             :         /* Detect whether we need double quotes for this value */
     438      172378 :         nq = (value[0] == '\0');    /* force quotes for empty string */
     439   108258942 :         for (tmp = value; *tmp; tmp++)
     440             :         {
     441   108138302 :             char        ch = *tmp;
     442             : 
     443   108138302 :             if (ch == '"' || ch == '\\' ||
     444   108137408 :                 ch == '(' || ch == ')' || ch == ',' ||
     445   108136426 :                 isspace((unsigned char) ch))
     446             :             {
     447       51738 :                 nq = true;
     448       51738 :                 break;
     449             :             }
     450             :         }
     451             : 
     452             :         /* And emit the string */
     453      172378 :         if (nq)
     454       51742 :             appendStringInfoCharMacro(&buf, '"');
     455   108786866 :         for (tmp = value; *tmp; tmp++)
     456             :         {
     457   108614488 :             char        ch = *tmp;
     458             : 
     459   108614488 :             if (ch == '"' || ch == '\\')
     460         996 :                 appendStringInfoCharMacro(&buf, ch);
     461   108614488 :             appendStringInfoCharMacro(&buf, ch);
     462             :         }
     463      172378 :         if (nq)
     464       51742 :             appendStringInfoCharMacro(&buf, '"');
     465             :     }
     466             : 
     467       34868 :     appendStringInfoChar(&buf, ')');
     468             : 
     469       34868 :     pfree(values);
     470       34868 :     pfree(nulls);
     471       34868 :     ReleaseTupleDesc(tupdesc);
     472             : 
     473       34868 :     PG_RETURN_CSTRING(buf.data);
     474             : }
     475             : 
     476             : /*
     477             :  * record_recv      - binary input routine for any composite type.
     478             :  */
     479             : Datum
     480           0 : record_recv(PG_FUNCTION_ARGS)
     481             : {
     482           0 :     StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
     483           0 :     Oid         tupType = PG_GETARG_OID(1);
     484           0 :     int32       tupTypmod = PG_GETARG_INT32(2);
     485             :     HeapTupleHeader result;
     486             :     TupleDesc   tupdesc;
     487             :     HeapTuple   tuple;
     488             :     RecordIOData *my_extra;
     489             :     int         ncolumns;
     490             :     int         usercols;
     491             :     int         validcols;
     492             :     int         i;
     493             :     Datum      *values;
     494             :     bool       *nulls;
     495             : 
     496           0 :     check_stack_depth();        /* recurses for record-type columns */
     497             : 
     498             :     /*
     499             :      * Give a friendly error message if we did not get enough info to identify
     500             :      * the target record type.  (lookup_rowtype_tupdesc would fail anyway, but
     501             :      * with a non-user-friendly message.)  In ordinary SQL usage, we'll get -1
     502             :      * for typmod, since composite types and RECORD have no type modifiers at
     503             :      * the SQL level, and thus must fail for RECORD.  However some callers can
     504             :      * supply a valid typmod, and then we can do something useful for RECORD.
     505             :      */
     506           0 :     if (tupType == RECORDOID && tupTypmod < 0)
     507           0 :         ereport(ERROR,
     508             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     509             :                  errmsg("input of anonymous composite types is not implemented")));
     510             : 
     511           0 :     tupdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
     512           0 :     ncolumns = tupdesc->natts;
     513             : 
     514             :     /*
     515             :      * We arrange to look up the needed I/O info just once per series of
     516             :      * calls, assuming the record type doesn't change underneath us.
     517             :      */
     518           0 :     my_extra = (RecordIOData *) fcinfo->flinfo->fn_extra;
     519           0 :     if (my_extra == NULL ||
     520           0 :         my_extra->ncolumns != ncolumns)
     521             :     {
     522           0 :         fcinfo->flinfo->fn_extra =
     523           0 :             MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
     524             :                                offsetof(RecordIOData, columns) +
     525           0 :                                ncolumns * sizeof(ColumnIOData));
     526           0 :         my_extra = (RecordIOData *) fcinfo->flinfo->fn_extra;
     527           0 :         my_extra->record_type = InvalidOid;
     528           0 :         my_extra->record_typmod = 0;
     529             :     }
     530             : 
     531           0 :     if (my_extra->record_type != tupType ||
     532           0 :         my_extra->record_typmod != tupTypmod)
     533             :     {
     534           0 :         MemSet(my_extra, 0,
     535             :                offsetof(RecordIOData, columns) +
     536             :                ncolumns * sizeof(ColumnIOData));
     537           0 :         my_extra->record_type = tupType;
     538           0 :         my_extra->record_typmod = tupTypmod;
     539           0 :         my_extra->ncolumns = ncolumns;
     540             :     }
     541             : 
     542           0 :     values = (Datum *) palloc(ncolumns * sizeof(Datum));
     543           0 :     nulls = (bool *) palloc(ncolumns * sizeof(bool));
     544             : 
     545             :     /* Fetch number of columns user thinks it has */
     546           0 :     usercols = pq_getmsgint(buf, 4);
     547             : 
     548             :     /* Need to scan to count nondeleted columns */
     549           0 :     validcols = 0;
     550           0 :     for (i = 0; i < ncolumns; i++)
     551             :     {
     552           0 :         if (!TupleDescAttr(tupdesc, i)->attisdropped)
     553           0 :             validcols++;
     554             :     }
     555           0 :     if (usercols != validcols)
     556           0 :         ereport(ERROR,
     557             :                 (errcode(ERRCODE_DATATYPE_MISMATCH),
     558             :                  errmsg("wrong number of columns: %d, expected %d",
     559             :                         usercols, validcols)));
     560             : 
     561             :     /* Process each column */
     562           0 :     for (i = 0; i < ncolumns; i++)
     563             :     {
     564           0 :         Form_pg_attribute att = TupleDescAttr(tupdesc, i);
     565           0 :         ColumnIOData *column_info = &my_extra->columns[i];
     566           0 :         Oid         column_type = att->atttypid;
     567             :         Oid         coltypoid;
     568             :         int         itemlen;
     569             :         StringInfoData item_buf;
     570             :         StringInfo  bufptr;
     571             : 
     572             :         /* Ignore dropped columns in datatype, but fill with nulls */
     573           0 :         if (att->attisdropped)
     574             :         {
     575           0 :             values[i] = (Datum) 0;
     576           0 :             nulls[i] = true;
     577           0 :             continue;
     578             :         }
     579             : 
     580             :         /* Check column type recorded in the data */
     581           0 :         coltypoid = pq_getmsgint(buf, sizeof(Oid));
     582             : 
     583             :         /*
     584             :          * From a security standpoint, it doesn't matter whether the input's
     585             :          * column type matches what we expect: the column type's receive
     586             :          * function has to be robust enough to cope with invalid data.
     587             :          * However, from a user-friendliness standpoint, it's nicer to
     588             :          * complain about type mismatches than to throw "improper binary
     589             :          * format" errors.  But there's a problem: only built-in types have
     590             :          * OIDs that are stable enough to believe that a mismatch is a real
     591             :          * issue.  So complain only if both OIDs are in the built-in range.
     592             :          * Otherwise, carry on with the column type we "should" be getting.
     593             :          */
     594           0 :         if (coltypoid != column_type &&
     595           0 :             coltypoid < FirstGenbkiObjectId &&
     596             :             column_type < FirstGenbkiObjectId)
     597           0 :             ereport(ERROR,
     598             :                     (errcode(ERRCODE_DATATYPE_MISMATCH),
     599             :                      errmsg("binary data has type %u (%s) instead of expected %u (%s) in record column %d",
     600             :                             coltypoid,
     601             :                             format_type_extended(coltypoid, -1,
     602             :                                                  FORMAT_TYPE_ALLOW_INVALID),
     603             :                             column_type,
     604             :                             format_type_extended(column_type, -1,
     605             :                                                  FORMAT_TYPE_ALLOW_INVALID),
     606             :                             i + 1)));
     607             : 
     608             :         /* Get and check the item length */
     609           0 :         itemlen = pq_getmsgint(buf, 4);
     610           0 :         if (itemlen < -1 || itemlen > (buf->len - buf->cursor))
     611           0 :             ereport(ERROR,
     612             :                     (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
     613             :                      errmsg("insufficient data left in message")));
     614             : 
     615           0 :         if (itemlen == -1)
     616             :         {
     617             :             /* -1 length means NULL */
     618           0 :             bufptr = NULL;
     619           0 :             nulls[i] = true;
     620             :         }
     621             :         else
     622             :         {
     623             :             char       *strbuff;
     624             : 
     625             :             /*
     626             :              * Rather than copying data around, we just initialize a
     627             :              * StringInfo pointing to the correct portion of the message
     628             :              * buffer.
     629             :              */
     630           0 :             strbuff = &buf->data[buf->cursor];
     631           0 :             buf->cursor += itemlen;
     632           0 :             initReadOnlyStringInfo(&item_buf, strbuff, itemlen);
     633             : 
     634           0 :             bufptr = &item_buf;
     635           0 :             nulls[i] = false;
     636             :         }
     637             : 
     638             :         /* Now call the column's receiveproc */
     639           0 :         if (column_info->column_type != column_type)
     640             :         {
     641           0 :             getTypeBinaryInputInfo(column_type,
     642             :                                    &column_info->typiofunc,
     643             :                                    &column_info->typioparam);
     644           0 :             fmgr_info_cxt(column_info->typiofunc, &column_info->proc,
     645           0 :                           fcinfo->flinfo->fn_mcxt);
     646           0 :             column_info->column_type = column_type;
     647             :         }
     648             : 
     649           0 :         values[i] = ReceiveFunctionCall(&column_info->proc,
     650             :                                         bufptr,
     651             :                                         column_info->typioparam,
     652             :                                         att->atttypmod);
     653             : 
     654           0 :         if (bufptr)
     655             :         {
     656             :             /* Trouble if it didn't eat the whole buffer */
     657           0 :             if (item_buf.cursor != itemlen)
     658           0 :                 ereport(ERROR,
     659             :                         (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
     660             :                          errmsg("improper binary format in record column %d",
     661             :                                 i + 1)));
     662             :         }
     663             :     }
     664             : 
     665           0 :     tuple = heap_form_tuple(tupdesc, values, nulls);
     666             : 
     667             :     /*
     668             :      * We cannot return tuple->t_data because heap_form_tuple allocates it as
     669             :      * part of a larger chunk, and our caller may expect to be able to pfree
     670             :      * our result.  So must copy the info into a new palloc chunk.
     671             :      */
     672           0 :     result = (HeapTupleHeader) palloc(tuple->t_len);
     673           0 :     memcpy(result, tuple->t_data, tuple->t_len);
     674             : 
     675           0 :     heap_freetuple(tuple);
     676           0 :     pfree(values);
     677           0 :     pfree(nulls);
     678           0 :     ReleaseTupleDesc(tupdesc);
     679             : 
     680           0 :     PG_RETURN_HEAPTUPLEHEADER(result);
     681             : }
     682             : 
     683             : /*
     684             :  * record_send      - binary output routine for any composite type.
     685             :  */
     686             : Datum
     687           0 : record_send(PG_FUNCTION_ARGS)
     688             : {
     689           0 :     HeapTupleHeader rec = PG_GETARG_HEAPTUPLEHEADER(0);
     690             :     Oid         tupType;
     691             :     int32       tupTypmod;
     692             :     TupleDesc   tupdesc;
     693             :     HeapTupleData tuple;
     694             :     RecordIOData *my_extra;
     695             :     int         ncolumns;
     696             :     int         validcols;
     697             :     int         i;
     698             :     Datum      *values;
     699             :     bool       *nulls;
     700             :     StringInfoData buf;
     701             : 
     702           0 :     check_stack_depth();        /* recurses for record-type columns */
     703             : 
     704             :     /* Extract type info from the tuple itself */
     705           0 :     tupType = HeapTupleHeaderGetTypeId(rec);
     706           0 :     tupTypmod = HeapTupleHeaderGetTypMod(rec);
     707           0 :     tupdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
     708           0 :     ncolumns = tupdesc->natts;
     709             : 
     710             :     /* Build a temporary HeapTuple control structure */
     711           0 :     tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
     712           0 :     ItemPointerSetInvalid(&(tuple.t_self));
     713           0 :     tuple.t_tableOid = InvalidOid;
     714           0 :     tuple.t_data = rec;
     715             : 
     716             :     /*
     717             :      * We arrange to look up the needed I/O info just once per series of
     718             :      * calls, assuming the record type doesn't change underneath us.
     719             :      */
     720           0 :     my_extra = (RecordIOData *) fcinfo->flinfo->fn_extra;
     721           0 :     if (my_extra == NULL ||
     722           0 :         my_extra->ncolumns != ncolumns)
     723             :     {
     724           0 :         fcinfo->flinfo->fn_extra =
     725           0 :             MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
     726             :                                offsetof(RecordIOData, columns) +
     727           0 :                                ncolumns * sizeof(ColumnIOData));
     728           0 :         my_extra = (RecordIOData *) fcinfo->flinfo->fn_extra;
     729           0 :         my_extra->record_type = InvalidOid;
     730           0 :         my_extra->record_typmod = 0;
     731             :     }
     732             : 
     733           0 :     if (my_extra->record_type != tupType ||
     734           0 :         my_extra->record_typmod != tupTypmod)
     735             :     {
     736           0 :         MemSet(my_extra, 0,
     737             :                offsetof(RecordIOData, columns) +
     738             :                ncolumns * sizeof(ColumnIOData));
     739           0 :         my_extra->record_type = tupType;
     740           0 :         my_extra->record_typmod = tupTypmod;
     741           0 :         my_extra->ncolumns = ncolumns;
     742             :     }
     743             : 
     744           0 :     values = (Datum *) palloc(ncolumns * sizeof(Datum));
     745           0 :     nulls = (bool *) palloc(ncolumns * sizeof(bool));
     746             : 
     747             :     /* Break down the tuple into fields */
     748           0 :     heap_deform_tuple(&tuple, tupdesc, values, nulls);
     749             : 
     750             :     /* And build the result string */
     751           0 :     pq_begintypsend(&buf);
     752             : 
     753             :     /* Need to scan to count nondeleted columns */
     754           0 :     validcols = 0;
     755           0 :     for (i = 0; i < ncolumns; i++)
     756             :     {
     757           0 :         if (!TupleDescAttr(tupdesc, i)->attisdropped)
     758           0 :             validcols++;
     759             :     }
     760           0 :     pq_sendint32(&buf, validcols);
     761             : 
     762           0 :     for (i = 0; i < ncolumns; i++)
     763             :     {
     764           0 :         Form_pg_attribute att = TupleDescAttr(tupdesc, i);
     765           0 :         ColumnIOData *column_info = &my_extra->columns[i];
     766           0 :         Oid         column_type = att->atttypid;
     767             :         Datum       attr;
     768             :         bytea      *outputbytes;
     769             : 
     770             :         /* Ignore dropped columns in datatype */
     771           0 :         if (att->attisdropped)
     772           0 :             continue;
     773             : 
     774           0 :         pq_sendint32(&buf, column_type);
     775             : 
     776           0 :         if (nulls[i])
     777             :         {
     778             :             /* emit -1 data length to signify a NULL */
     779           0 :             pq_sendint32(&buf, -1);
     780           0 :             continue;
     781             :         }
     782             : 
     783             :         /*
     784             :          * Convert the column value to binary
     785             :          */
     786           0 :         if (column_info->column_type != column_type)
     787             :         {
     788           0 :             getTypeBinaryOutputInfo(column_type,
     789             :                                     &column_info->typiofunc,
     790             :                                     &column_info->typisvarlena);
     791           0 :             fmgr_info_cxt(column_info->typiofunc, &column_info->proc,
     792           0 :                           fcinfo->flinfo->fn_mcxt);
     793           0 :             column_info->column_type = column_type;
     794             :         }
     795             : 
     796           0 :         attr = values[i];
     797           0 :         outputbytes = SendFunctionCall(&column_info->proc, attr);
     798           0 :         pq_sendint32(&buf, VARSIZE(outputbytes) - VARHDRSZ);
     799           0 :         pq_sendbytes(&buf, VARDATA(outputbytes),
     800           0 :                      VARSIZE(outputbytes) - VARHDRSZ);
     801             :     }
     802             : 
     803           0 :     pfree(values);
     804           0 :     pfree(nulls);
     805           0 :     ReleaseTupleDesc(tupdesc);
     806             : 
     807           0 :     PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
     808             : }
     809             : 
     810             : 
     811             : /*
     812             :  * record_cmp()
     813             :  * Internal comparison function for records.
     814             :  *
     815             :  * Returns -1, 0 or 1
     816             :  *
     817             :  * Do not assume that the two inputs are exactly the same record type;
     818             :  * for instance we might be comparing an anonymous ROW() construct against a
     819             :  * named composite type.  We will compare as long as they have the same number
     820             :  * of non-dropped columns of the same types.
     821             :  */
     822             : static int
     823        4448 : record_cmp(FunctionCallInfo fcinfo)
     824             : {
     825        4448 :     HeapTupleHeader record1 = PG_GETARG_HEAPTUPLEHEADER(0);
     826        4448 :     HeapTupleHeader record2 = PG_GETARG_HEAPTUPLEHEADER(1);
     827        4448 :     int         result = 0;
     828             :     Oid         tupType1;
     829             :     Oid         tupType2;
     830             :     int32       tupTypmod1;
     831             :     int32       tupTypmod2;
     832             :     TupleDesc   tupdesc1;
     833             :     TupleDesc   tupdesc2;
     834             :     HeapTupleData tuple1;
     835             :     HeapTupleData tuple2;
     836             :     int         ncolumns1;
     837             :     int         ncolumns2;
     838             :     RecordCompareData *my_extra;
     839             :     int         ncols;
     840             :     Datum      *values1;
     841             :     Datum      *values2;
     842             :     bool       *nulls1;
     843             :     bool       *nulls2;
     844             :     int         i1;
     845             :     int         i2;
     846             :     int         j;
     847             : 
     848        4448 :     check_stack_depth();        /* recurses for record-type columns */
     849             : 
     850             :     /* Extract type info from the tuples */
     851        4448 :     tupType1 = HeapTupleHeaderGetTypeId(record1);
     852        4448 :     tupTypmod1 = HeapTupleHeaderGetTypMod(record1);
     853        4448 :     tupdesc1 = lookup_rowtype_tupdesc(tupType1, tupTypmod1);
     854        4448 :     ncolumns1 = tupdesc1->natts;
     855        4448 :     tupType2 = HeapTupleHeaderGetTypeId(record2);
     856        4448 :     tupTypmod2 = HeapTupleHeaderGetTypMod(record2);
     857        4448 :     tupdesc2 = lookup_rowtype_tupdesc(tupType2, tupTypmod2);
     858        4448 :     ncolumns2 = tupdesc2->natts;
     859             : 
     860             :     /* Build temporary HeapTuple control structures */
     861        4448 :     tuple1.t_len = HeapTupleHeaderGetDatumLength(record1);
     862        4448 :     ItemPointerSetInvalid(&(tuple1.t_self));
     863        4448 :     tuple1.t_tableOid = InvalidOid;
     864        4448 :     tuple1.t_data = record1;
     865        4448 :     tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
     866        4448 :     ItemPointerSetInvalid(&(tuple2.t_self));
     867        4448 :     tuple2.t_tableOid = InvalidOid;
     868        4448 :     tuple2.t_data = record2;
     869             : 
     870             :     /*
     871             :      * We arrange to look up the needed comparison info just once per series
     872             :      * of calls, assuming the record types don't change underneath us.
     873             :      */
     874        4448 :     ncols = Max(ncolumns1, ncolumns2);
     875        4448 :     my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
     876        4448 :     if (my_extra == NULL ||
     877        4000 :         my_extra->ncolumns < ncols)
     878             :     {
     879         896 :         fcinfo->flinfo->fn_extra =
     880         448 :             MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
     881         448 :                                offsetof(RecordCompareData, columns) +
     882             :                                ncols * sizeof(ColumnCompareData));
     883         448 :         my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
     884         448 :         my_extra->ncolumns = ncols;
     885         448 :         my_extra->record1_type = InvalidOid;
     886         448 :         my_extra->record1_typmod = 0;
     887         448 :         my_extra->record2_type = InvalidOid;
     888         448 :         my_extra->record2_typmod = 0;
     889             :     }
     890             : 
     891        4448 :     if (my_extra->record1_type != tupType1 ||
     892        4000 :         my_extra->record1_typmod != tupTypmod1 ||
     893        3994 :         my_extra->record2_type != tupType2 ||
     894        3994 :         my_extra->record2_typmod != tupTypmod2)
     895             :     {
     896        1652 :         MemSet(my_extra->columns, 0, ncols * sizeof(ColumnCompareData));
     897         454 :         my_extra->record1_type = tupType1;
     898         454 :         my_extra->record1_typmod = tupTypmod1;
     899         454 :         my_extra->record2_type = tupType2;
     900         454 :         my_extra->record2_typmod = tupTypmod2;
     901             :     }
     902             : 
     903             :     /* Break down the tuples into fields */
     904        4448 :     values1 = (Datum *) palloc(ncolumns1 * sizeof(Datum));
     905        4448 :     nulls1 = (bool *) palloc(ncolumns1 * sizeof(bool));
     906        4448 :     heap_deform_tuple(&tuple1, tupdesc1, values1, nulls1);
     907        4448 :     values2 = (Datum *) palloc(ncolumns2 * sizeof(Datum));
     908        4448 :     nulls2 = (bool *) palloc(ncolumns2 * sizeof(bool));
     909        4448 :     heap_deform_tuple(&tuple2, tupdesc2, values2, nulls2);
     910             : 
     911             :     /*
     912             :      * Scan corresponding columns, allowing for dropped columns in different
     913             :      * places in the two rows.  i1 and i2 are physical column indexes, j is
     914             :      * the logical column index.
     915             :      */
     916        4448 :     i1 = i2 = j = 0;
     917        6778 :     while (i1 < ncolumns1 || i2 < ncolumns2)
     918             :     {
     919             :         Form_pg_attribute att1;
     920             :         Form_pg_attribute att2;
     921             :         TypeCacheEntry *typentry;
     922             :         Oid         collation;
     923             : 
     924             :         /*
     925             :          * Skip dropped columns
     926             :          */
     927        5990 :         if (i1 < ncolumns1 && TupleDescAttr(tupdesc1, i1)->attisdropped)
     928             :         {
     929           0 :             i1++;
     930           0 :             continue;
     931             :         }
     932        5990 :         if (i2 < ncolumns2 && TupleDescAttr(tupdesc2, i2)->attisdropped)
     933             :         {
     934           0 :             i2++;
     935           0 :             continue;
     936             :         }
     937        5990 :         if (i1 >= ncolumns1 || i2 >= ncolumns2)
     938             :             break;              /* we'll deal with mismatch below loop */
     939             : 
     940        5984 :         att1 = TupleDescAttr(tupdesc1, i1);
     941        5984 :         att2 = TupleDescAttr(tupdesc2, i2);
     942             : 
     943             :         /*
     944             :          * Have two matching columns, they must be same type
     945             :          */
     946        5984 :         if (att1->atttypid != att2->atttypid)
     947           6 :             ereport(ERROR,
     948             :                     (errcode(ERRCODE_DATATYPE_MISMATCH),
     949             :                      errmsg("cannot compare dissimilar column types %s and %s at record column %d",
     950             :                             format_type_be(att1->atttypid),
     951             :                             format_type_be(att2->atttypid),
     952             :                             j + 1)));
     953             : 
     954             :         /*
     955             :          * If they're not same collation, we don't complain here, but the
     956             :          * comparison function might.
     957             :          */
     958        5978 :         collation = att1->attcollation;
     959        5978 :         if (collation != att2->attcollation)
     960           0 :             collation = InvalidOid;
     961             : 
     962             :         /*
     963             :          * Lookup the comparison function if not done already
     964             :          */
     965        5978 :         typentry = my_extra->columns[j].typentry;
     966        5978 :         if (typentry == NULL ||
     967        5196 :             typentry->type_id != att1->atttypid)
     968             :         {
     969         782 :             typentry = lookup_type_cache(att1->atttypid,
     970             :                                          TYPECACHE_CMP_PROC_FINFO);
     971         782 :             if (!OidIsValid(typentry->cmp_proc_finfo.fn_oid))
     972           6 :                 ereport(ERROR,
     973             :                         (errcode(ERRCODE_UNDEFINED_FUNCTION),
     974             :                          errmsg("could not identify a comparison function for type %s",
     975             :                                 format_type_be(typentry->type_id))));
     976         776 :             my_extra->columns[j].typentry = typentry;
     977             :         }
     978             : 
     979             :         /*
     980             :          * We consider two NULLs equal; NULL > not-NULL.
     981             :          */
     982        5972 :         if (!nulls1[i1] || !nulls2[i2])
     983             :         {
     984        5962 :             LOCAL_FCINFO(locfcinfo, 2);
     985             :             int32       cmpresult;
     986             : 
     987        5962 :             if (nulls1[i1])
     988             :             {
     989             :                 /* arg1 is greater than arg2 */
     990          12 :                 result = 1;
     991        3642 :                 break;
     992             :             }
     993        5950 :             if (nulls2[i2])
     994             :             {
     995             :                 /* arg1 is less than arg2 */
     996           0 :                 result = -1;
     997           0 :                 break;
     998             :             }
     999             : 
    1000             :             /* Compare the pair of elements */
    1001        5950 :             InitFunctionCallInfoData(*locfcinfo, &typentry->cmp_proc_finfo, 2,
    1002             :                                      collation, NULL, NULL);
    1003        5950 :             locfcinfo->args[0].value = values1[i1];
    1004        5950 :             locfcinfo->args[0].isnull = false;
    1005        5950 :             locfcinfo->args[1].value = values2[i2];
    1006        5950 :             locfcinfo->args[1].isnull = false;
    1007        5950 :             cmpresult = DatumGetInt32(FunctionCallInvoke(locfcinfo));
    1008             : 
    1009             :             /* We don't expect comparison support functions to return null */
    1010             :             Assert(!locfcinfo->isnull);
    1011             : 
    1012        5950 :             if (cmpresult < 0)
    1013             :             {
    1014             :                 /* arg1 is less than arg2 */
    1015        1898 :                 result = -1;
    1016        1898 :                 break;
    1017             :             }
    1018        4052 :             else if (cmpresult > 0)
    1019             :             {
    1020             :                 /* arg1 is greater than arg2 */
    1021        1732 :                 result = 1;
    1022        1732 :                 break;
    1023             :             }
    1024             :         }
    1025             : 
    1026             :         /* equal, so continue to next column */
    1027        2330 :         i1++, i2++, j++;
    1028             :     }
    1029             : 
    1030             :     /*
    1031             :      * If we didn't break out of the loop early, check for column count
    1032             :      * mismatch.  (We do not report such mismatch if we found unequal column
    1033             :      * values; is that a feature or a bug?)
    1034             :      */
    1035        4436 :     if (result == 0)
    1036             :     {
    1037         794 :         if (i1 != ncolumns1 || i2 != ncolumns2)
    1038           6 :             ereport(ERROR,
    1039             :                     (errcode(ERRCODE_DATATYPE_MISMATCH),
    1040             :                      errmsg("cannot compare record types with different numbers of columns")));
    1041             :     }
    1042             : 
    1043        4430 :     pfree(values1);
    1044        4430 :     pfree(nulls1);
    1045        4430 :     pfree(values2);
    1046        4430 :     pfree(nulls2);
    1047        4430 :     ReleaseTupleDesc(tupdesc1);
    1048        4430 :     ReleaseTupleDesc(tupdesc2);
    1049             : 
    1050             :     /* Avoid leaking memory when handed toasted input. */
    1051        4430 :     PG_FREE_IF_COPY(record1, 0);
    1052        4430 :     PG_FREE_IF_COPY(record2, 1);
    1053             : 
    1054        4430 :     return result;
    1055             : }
    1056             : 
    1057             : /*
    1058             :  * record_eq :
    1059             :  *        compares two records for equality
    1060             :  * result :
    1061             :  *        returns true if the records are equal, false otherwise.
    1062             :  *
    1063             :  * Note: we do not use record_cmp here, since equality may be meaningful in
    1064             :  * datatypes that don't have a total ordering (and hence no btree support).
    1065             :  */
    1066             : Datum
    1067        3690 : record_eq(PG_FUNCTION_ARGS)
    1068             : {
    1069        3690 :     HeapTupleHeader record1 = PG_GETARG_HEAPTUPLEHEADER(0);
    1070        3690 :     HeapTupleHeader record2 = PG_GETARG_HEAPTUPLEHEADER(1);
    1071        3690 :     bool        result = true;
    1072             :     Oid         tupType1;
    1073             :     Oid         tupType2;
    1074             :     int32       tupTypmod1;
    1075             :     int32       tupTypmod2;
    1076             :     TupleDesc   tupdesc1;
    1077             :     TupleDesc   tupdesc2;
    1078             :     HeapTupleData tuple1;
    1079             :     HeapTupleData tuple2;
    1080             :     int         ncolumns1;
    1081             :     int         ncolumns2;
    1082             :     RecordCompareData *my_extra;
    1083             :     int         ncols;
    1084             :     Datum      *values1;
    1085             :     Datum      *values2;
    1086             :     bool       *nulls1;
    1087             :     bool       *nulls2;
    1088             :     int         i1;
    1089             :     int         i2;
    1090             :     int         j;
    1091             : 
    1092        3690 :     check_stack_depth();        /* recurses for record-type columns */
    1093             : 
    1094             :     /* Extract type info from the tuples */
    1095        3690 :     tupType1 = HeapTupleHeaderGetTypeId(record1);
    1096        3690 :     tupTypmod1 = HeapTupleHeaderGetTypMod(record1);
    1097        3690 :     tupdesc1 = lookup_rowtype_tupdesc(tupType1, tupTypmod1);
    1098        3690 :     ncolumns1 = tupdesc1->natts;
    1099        3690 :     tupType2 = HeapTupleHeaderGetTypeId(record2);
    1100        3690 :     tupTypmod2 = HeapTupleHeaderGetTypMod(record2);
    1101        3690 :     tupdesc2 = lookup_rowtype_tupdesc(tupType2, tupTypmod2);
    1102        3690 :     ncolumns2 = tupdesc2->natts;
    1103             : 
    1104             :     /* Build temporary HeapTuple control structures */
    1105        3690 :     tuple1.t_len = HeapTupleHeaderGetDatumLength(record1);
    1106        3690 :     ItemPointerSetInvalid(&(tuple1.t_self));
    1107        3690 :     tuple1.t_tableOid = InvalidOid;
    1108        3690 :     tuple1.t_data = record1;
    1109        3690 :     tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
    1110        3690 :     ItemPointerSetInvalid(&(tuple2.t_self));
    1111        3690 :     tuple2.t_tableOid = InvalidOid;
    1112        3690 :     tuple2.t_data = record2;
    1113             : 
    1114             :     /*
    1115             :      * We arrange to look up the needed comparison info just once per series
    1116             :      * of calls, assuming the record types don't change underneath us.
    1117             :      */
    1118        3690 :     ncols = Max(ncolumns1, ncolumns2);
    1119        3690 :     my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
    1120        3690 :     if (my_extra == NULL ||
    1121        3320 :         my_extra->ncolumns < ncols)
    1122             :     {
    1123         740 :         fcinfo->flinfo->fn_extra =
    1124         370 :             MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
    1125         370 :                                offsetof(RecordCompareData, columns) +
    1126             :                                ncols * sizeof(ColumnCompareData));
    1127         370 :         my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
    1128         370 :         my_extra->ncolumns = ncols;
    1129         370 :         my_extra->record1_type = InvalidOid;
    1130         370 :         my_extra->record1_typmod = 0;
    1131         370 :         my_extra->record2_type = InvalidOid;
    1132         370 :         my_extra->record2_typmod = 0;
    1133             :     }
    1134             : 
    1135        3690 :     if (my_extra->record1_type != tupType1 ||
    1136        3320 :         my_extra->record1_typmod != tupTypmod1 ||
    1137        3320 :         my_extra->record2_type != tupType2 ||
    1138        3320 :         my_extra->record2_typmod != tupTypmod2)
    1139             :     {
    1140        1148 :         MemSet(my_extra->columns, 0, ncols * sizeof(ColumnCompareData));
    1141         370 :         my_extra->record1_type = tupType1;
    1142         370 :         my_extra->record1_typmod = tupTypmod1;
    1143         370 :         my_extra->record2_type = tupType2;
    1144         370 :         my_extra->record2_typmod = tupTypmod2;
    1145             :     }
    1146             : 
    1147             :     /* Break down the tuples into fields */
    1148        3690 :     values1 = (Datum *) palloc(ncolumns1 * sizeof(Datum));
    1149        3690 :     nulls1 = (bool *) palloc(ncolumns1 * sizeof(bool));
    1150        3690 :     heap_deform_tuple(&tuple1, tupdesc1, values1, nulls1);
    1151        3690 :     values2 = (Datum *) palloc(ncolumns2 * sizeof(Datum));
    1152        3690 :     nulls2 = (bool *) palloc(ncolumns2 * sizeof(bool));
    1153        3690 :     heap_deform_tuple(&tuple2, tupdesc2, values2, nulls2);
    1154             : 
    1155             :     /*
    1156             :      * Scan corresponding columns, allowing for dropped columns in different
    1157             :      * places in the two rows.  i1 and i2 are physical column indexes, j is
    1158             :      * the logical column index.
    1159             :      */
    1160        3690 :     i1 = i2 = j = 0;
    1161        6068 :     while (i1 < ncolumns1 || i2 < ncolumns2)
    1162             :     {
    1163        5330 :         LOCAL_FCINFO(locfcinfo, 2);
    1164             :         Form_pg_attribute att1;
    1165             :         Form_pg_attribute att2;
    1166             :         TypeCacheEntry *typentry;
    1167             :         Oid         collation;
    1168             :         bool        oprresult;
    1169             : 
    1170             :         /*
    1171             :          * Skip dropped columns
    1172             :          */
    1173        5330 :         if (i1 < ncolumns1 && TupleDescAttr(tupdesc1, i1)->attisdropped)
    1174             :         {
    1175           0 :             i1++;
    1176           0 :             continue;
    1177             :         }
    1178        5330 :         if (i2 < ncolumns2 && TupleDescAttr(tupdesc2, i2)->attisdropped)
    1179             :         {
    1180           0 :             i2++;
    1181           0 :             continue;
    1182             :         }
    1183        5330 :         if (i1 >= ncolumns1 || i2 >= ncolumns2)
    1184             :             break;              /* we'll deal with mismatch below loop */
    1185             : 
    1186        5324 :         att1 = TupleDescAttr(tupdesc1, i1);
    1187        5324 :         att2 = TupleDescAttr(tupdesc2, i2);
    1188             : 
    1189             :         /*
    1190             :          * Have two matching columns, they must be same type
    1191             :          */
    1192        5324 :         if (att1->atttypid != att2->atttypid)
    1193          12 :             ereport(ERROR,
    1194             :                     (errcode(ERRCODE_DATATYPE_MISMATCH),
    1195             :                      errmsg("cannot compare dissimilar column types %s and %s at record column %d",
    1196             :                             format_type_be(att1->atttypid),
    1197             :                             format_type_be(att2->atttypid),
    1198             :                             j + 1)));
    1199             : 
    1200             :         /*
    1201             :          * If they're not same collation, we don't complain here, but the
    1202             :          * equality function might.
    1203             :          */
    1204        5312 :         collation = att1->attcollation;
    1205        5312 :         if (collation != att2->attcollation)
    1206           0 :             collation = InvalidOid;
    1207             : 
    1208             :         /*
    1209             :          * Lookup the equality function if not done already
    1210             :          */
    1211        5312 :         typentry = my_extra->columns[j].typentry;
    1212        5312 :         if (typentry == NULL ||
    1213        4576 :             typentry->type_id != att1->atttypid)
    1214             :         {
    1215         736 :             typentry = lookup_type_cache(att1->atttypid,
    1216             :                                          TYPECACHE_EQ_OPR_FINFO);
    1217         736 :             if (!OidIsValid(typentry->eq_opr_finfo.fn_oid))
    1218           6 :                 ereport(ERROR,
    1219             :                         (errcode(ERRCODE_UNDEFINED_FUNCTION),
    1220             :                          errmsg("could not identify an equality operator for type %s",
    1221             :                                 format_type_be(typentry->type_id))));
    1222         730 :             my_extra->columns[j].typentry = typentry;
    1223             :         }
    1224             : 
    1225             :         /*
    1226             :          * We consider two NULLs equal; NULL > not-NULL.
    1227             :          */
    1228        5306 :         if (!nulls1[i1] || !nulls2[i2])
    1229             :         {
    1230        5056 :             if (nulls1[i1] || nulls2[i2])
    1231             :             {
    1232           6 :                 result = false;
    1233           6 :                 break;
    1234             :             }
    1235             : 
    1236             :             /* Compare the pair of elements */
    1237        5050 :             InitFunctionCallInfoData(*locfcinfo, &typentry->eq_opr_finfo, 2,
    1238             :                                      collation, NULL, NULL);
    1239        5050 :             locfcinfo->args[0].value = values1[i1];
    1240        5050 :             locfcinfo->args[0].isnull = false;
    1241        5050 :             locfcinfo->args[1].value = values2[i2];
    1242        5050 :             locfcinfo->args[1].isnull = false;
    1243        5050 :             oprresult = DatumGetBool(FunctionCallInvoke(locfcinfo));
    1244        5050 :             if (locfcinfo->isnull || !oprresult)
    1245             :             {
    1246        2922 :                 result = false;
    1247        2922 :                 break;
    1248             :             }
    1249             :         }
    1250             : 
    1251             :         /* equal, so continue to next column */
    1252        2378 :         i1++, i2++, j++;
    1253             :     }
    1254             : 
    1255             :     /*
    1256             :      * If we didn't break out of the loop early, check for column count
    1257             :      * mismatch.  (We do not report such mismatch if we found unequal column
    1258             :      * values; is that a feature or a bug?)
    1259             :      */
    1260        3672 :     if (result)
    1261             :     {
    1262         744 :         if (i1 != ncolumns1 || i2 != ncolumns2)
    1263           6 :             ereport(ERROR,
    1264             :                     (errcode(ERRCODE_DATATYPE_MISMATCH),
    1265             :                      errmsg("cannot compare record types with different numbers of columns")));
    1266             :     }
    1267             : 
    1268        3666 :     pfree(values1);
    1269        3666 :     pfree(nulls1);
    1270        3666 :     pfree(values2);
    1271        3666 :     pfree(nulls2);
    1272        3666 :     ReleaseTupleDesc(tupdesc1);
    1273        3666 :     ReleaseTupleDesc(tupdesc2);
    1274             : 
    1275             :     /* Avoid leaking memory when handed toasted input. */
    1276        3666 :     PG_FREE_IF_COPY(record1, 0);
    1277        3666 :     PG_FREE_IF_COPY(record2, 1);
    1278             : 
    1279        3666 :     PG_RETURN_BOOL(result);
    1280             : }
    1281             : 
    1282             : Datum
    1283          54 : record_ne(PG_FUNCTION_ARGS)
    1284             : {
    1285          54 :     PG_RETURN_BOOL(!DatumGetBool(record_eq(fcinfo)));
    1286             : }
    1287             : 
    1288             : Datum
    1289          36 : record_lt(PG_FUNCTION_ARGS)
    1290             : {
    1291          36 :     PG_RETURN_BOOL(record_cmp(fcinfo) < 0);
    1292             : }
    1293             : 
    1294             : Datum
    1295          12 : record_gt(PG_FUNCTION_ARGS)
    1296             : {
    1297          12 :     PG_RETURN_BOOL(record_cmp(fcinfo) > 0);
    1298             : }
    1299             : 
    1300             : Datum
    1301          12 : record_le(PG_FUNCTION_ARGS)
    1302             : {
    1303          12 :     PG_RETURN_BOOL(record_cmp(fcinfo) <= 0);
    1304             : }
    1305             : 
    1306             : Datum
    1307          42 : record_ge(PG_FUNCTION_ARGS)
    1308             : {
    1309          42 :     PG_RETURN_BOOL(record_cmp(fcinfo) >= 0);
    1310             : }
    1311             : 
    1312             : Datum
    1313        4274 : btrecordcmp(PG_FUNCTION_ARGS)
    1314             : {
    1315        4274 :     PG_RETURN_INT32(record_cmp(fcinfo));
    1316             : }
    1317             : 
    1318             : Datum
    1319          36 : record_larger(PG_FUNCTION_ARGS)
    1320             : {
    1321          36 :     if (record_cmp(fcinfo) > 0)
    1322          18 :         PG_RETURN_DATUM(PG_GETARG_DATUM(0));
    1323             :     else
    1324          18 :         PG_RETURN_DATUM(PG_GETARG_DATUM(1));
    1325             : }
    1326             : 
    1327             : Datum
    1328          36 : record_smaller(PG_FUNCTION_ARGS)
    1329             : {
    1330          36 :     if (record_cmp(fcinfo) < 0)
    1331          24 :         PG_RETURN_DATUM(PG_GETARG_DATUM(0));
    1332             :     else
    1333          12 :         PG_RETURN_DATUM(PG_GETARG_DATUM(1));
    1334             : }
    1335             : 
    1336             : 
    1337             : /*
    1338             :  * record_image_cmp :
    1339             :  * Internal byte-oriented comparison function for records.
    1340             :  *
    1341             :  * Returns -1, 0 or 1
    1342             :  *
    1343             :  * Note: The normal concepts of "equality" do not apply here; different
    1344             :  * representation of values considered to be equal are not considered to be
    1345             :  * identical.  As an example, for the citext type 'A' and 'a' are equal, but
    1346             :  * they are not identical.
    1347             :  */
    1348             : static int
    1349         852 : record_image_cmp(FunctionCallInfo fcinfo)
    1350             : {
    1351         852 :     HeapTupleHeader record1 = PG_GETARG_HEAPTUPLEHEADER(0);
    1352         852 :     HeapTupleHeader record2 = PG_GETARG_HEAPTUPLEHEADER(1);
    1353         852 :     int         result = 0;
    1354             :     Oid         tupType1;
    1355             :     Oid         tupType2;
    1356             :     int32       tupTypmod1;
    1357             :     int32       tupTypmod2;
    1358             :     TupleDesc   tupdesc1;
    1359             :     TupleDesc   tupdesc2;
    1360             :     HeapTupleData tuple1;
    1361             :     HeapTupleData tuple2;
    1362             :     int         ncolumns1;
    1363             :     int         ncolumns2;
    1364             :     RecordCompareData *my_extra;
    1365             :     int         ncols;
    1366             :     Datum      *values1;
    1367             :     Datum      *values2;
    1368             :     bool       *nulls1;
    1369             :     bool       *nulls2;
    1370             :     int         i1;
    1371             :     int         i2;
    1372             :     int         j;
    1373             : 
    1374             :     /* Extract type info from the tuples */
    1375         852 :     tupType1 = HeapTupleHeaderGetTypeId(record1);
    1376         852 :     tupTypmod1 = HeapTupleHeaderGetTypMod(record1);
    1377         852 :     tupdesc1 = lookup_rowtype_tupdesc(tupType1, tupTypmod1);
    1378         852 :     ncolumns1 = tupdesc1->natts;
    1379         852 :     tupType2 = HeapTupleHeaderGetTypeId(record2);
    1380         852 :     tupTypmod2 = HeapTupleHeaderGetTypMod(record2);
    1381         852 :     tupdesc2 = lookup_rowtype_tupdesc(tupType2, tupTypmod2);
    1382         852 :     ncolumns2 = tupdesc2->natts;
    1383             : 
    1384             :     /* Build temporary HeapTuple control structures */
    1385         852 :     tuple1.t_len = HeapTupleHeaderGetDatumLength(record1);
    1386         852 :     ItemPointerSetInvalid(&(tuple1.t_self));
    1387         852 :     tuple1.t_tableOid = InvalidOid;
    1388         852 :     tuple1.t_data = record1;
    1389         852 :     tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
    1390         852 :     ItemPointerSetInvalid(&(tuple2.t_self));
    1391         852 :     tuple2.t_tableOid = InvalidOid;
    1392         852 :     tuple2.t_data = record2;
    1393             : 
    1394             :     /*
    1395             :      * We arrange to look up the needed comparison info just once per series
    1396             :      * of calls, assuming the record types don't change underneath us.
    1397             :      */
    1398         852 :     ncols = Max(ncolumns1, ncolumns2);
    1399         852 :     my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
    1400         852 :     if (my_extra == NULL ||
    1401         606 :         my_extra->ncolumns < ncols)
    1402             :     {
    1403         492 :         fcinfo->flinfo->fn_extra =
    1404         246 :             MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
    1405         246 :                                offsetof(RecordCompareData, columns) +
    1406             :                                ncols * sizeof(ColumnCompareData));
    1407         246 :         my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
    1408         246 :         my_extra->ncolumns = ncols;
    1409         246 :         my_extra->record1_type = InvalidOid;
    1410         246 :         my_extra->record1_typmod = 0;
    1411         246 :         my_extra->record2_type = InvalidOid;
    1412         246 :         my_extra->record2_typmod = 0;
    1413             :     }
    1414             : 
    1415         852 :     if (my_extra->record1_type != tupType1 ||
    1416         606 :         my_extra->record1_typmod != tupTypmod1 ||
    1417         606 :         my_extra->record2_type != tupType2 ||
    1418         606 :         my_extra->record2_typmod != tupTypmod2)
    1419             :     {
    1420         876 :         MemSet(my_extra->columns, 0, ncols * sizeof(ColumnCompareData));
    1421         246 :         my_extra->record1_type = tupType1;
    1422         246 :         my_extra->record1_typmod = tupTypmod1;
    1423         246 :         my_extra->record2_type = tupType2;
    1424         246 :         my_extra->record2_typmod = tupTypmod2;
    1425             :     }
    1426             : 
    1427             :     /* Break down the tuples into fields */
    1428         852 :     values1 = (Datum *) palloc(ncolumns1 * sizeof(Datum));
    1429         852 :     nulls1 = (bool *) palloc(ncolumns1 * sizeof(bool));
    1430         852 :     heap_deform_tuple(&tuple1, tupdesc1, values1, nulls1);
    1431         852 :     values2 = (Datum *) palloc(ncolumns2 * sizeof(Datum));
    1432         852 :     nulls2 = (bool *) palloc(ncolumns2 * sizeof(bool));
    1433         852 :     heap_deform_tuple(&tuple2, tupdesc2, values2, nulls2);
    1434             : 
    1435             :     /*
    1436             :      * Scan corresponding columns, allowing for dropped columns in different
    1437             :      * places in the two rows.  i1 and i2 are physical column indexes, j is
    1438             :      * the logical column index.
    1439             :      */
    1440         852 :     i1 = i2 = j = 0;
    1441        1666 :     while (i1 < ncolumns1 || i2 < ncolumns2)
    1442             :     {
    1443             :         Form_pg_attribute att1;
    1444             :         Form_pg_attribute att2;
    1445             : 
    1446             :         /*
    1447             :          * Skip dropped columns
    1448             :          */
    1449        1498 :         if (i1 < ncolumns1 && TupleDescAttr(tupdesc1, i1)->attisdropped)
    1450             :         {
    1451           0 :             i1++;
    1452           0 :             continue;
    1453             :         }
    1454        1498 :         if (i2 < ncolumns2 && TupleDescAttr(tupdesc2, i2)->attisdropped)
    1455             :         {
    1456           0 :             i2++;
    1457           0 :             continue;
    1458             :         }
    1459        1498 :         if (i1 >= ncolumns1 || i2 >= ncolumns2)
    1460             :             break;              /* we'll deal with mismatch below loop */
    1461             : 
    1462        1492 :         att1 = TupleDescAttr(tupdesc1, i1);
    1463        1492 :         att2 = TupleDescAttr(tupdesc2, i2);
    1464             : 
    1465             :         /*
    1466             :          * Have two matching columns, they must be same type
    1467             :          */
    1468        1492 :         if (att1->atttypid != att2->atttypid)
    1469           6 :             ereport(ERROR,
    1470             :                     (errcode(ERRCODE_DATATYPE_MISMATCH),
    1471             :                      errmsg("cannot compare dissimilar column types %s and %s at record column %d",
    1472             :                             format_type_be(att1->atttypid),
    1473             :                             format_type_be(att2->atttypid),
    1474             :                             j + 1)));
    1475             : 
    1476             :         /*
    1477             :          * The same type should have the same length (or both should be
    1478             :          * variable).
    1479             :          */
    1480             :         Assert(att1->attlen == att2->attlen);
    1481             : 
    1482             :         /*
    1483             :          * We consider two NULLs equal; NULL > not-NULL.
    1484             :          */
    1485        1486 :         if (!nulls1[i1] || !nulls2[i2])
    1486             :         {
    1487        1486 :             int         cmpresult = 0;
    1488             : 
    1489        1486 :             if (nulls1[i1])
    1490             :             {
    1491             :                 /* arg1 is greater than arg2 */
    1492           0 :                 result = 1;
    1493           0 :                 break;
    1494             :             }
    1495        1486 :             if (nulls2[i2])
    1496             :             {
    1497             :                 /* arg1 is less than arg2 */
    1498           0 :                 result = -1;
    1499           0 :                 break;
    1500             :             }
    1501             : 
    1502             :             /* Compare the pair of elements */
    1503        1486 :             if (att1->attbyval)
    1504             :             {
    1505         978 :                 if (values1[i1] != values2[i2])
    1506         512 :                     cmpresult = (values1[i1] < values2[i2]) ? -1 : 1;
    1507             :             }
    1508         508 :             else if (att1->attlen > 0)
    1509             :             {
    1510          36 :                 cmpresult = memcmp(DatumGetPointer(values1[i1]),
    1511          36 :                                    DatumGetPointer(values2[i2]),
    1512          36 :                                    att1->attlen);
    1513             :             }
    1514         472 :             else if (att1->attlen == -1)
    1515             :             {
    1516             :                 Size        len1,
    1517             :                             len2;
    1518             :                 struct varlena *arg1val;
    1519             :                 struct varlena *arg2val;
    1520             : 
    1521         472 :                 len1 = toast_raw_datum_size(values1[i1]);
    1522         472 :                 len2 = toast_raw_datum_size(values2[i2]);
    1523         472 :                 arg1val = PG_DETOAST_DATUM_PACKED(values1[i1]);
    1524         472 :                 arg2val = PG_DETOAST_DATUM_PACKED(values2[i2]);
    1525             : 
    1526         472 :                 cmpresult = memcmp(VARDATA_ANY(arg1val),
    1527         472 :                                    VARDATA_ANY(arg2val),
    1528         472 :                                    Min(len1, len2) - VARHDRSZ);
    1529         472 :                 if ((cmpresult == 0) && (len1 != len2))
    1530           6 :                     cmpresult = (len1 < len2) ? -1 : 1;
    1531             : 
    1532         472 :                 if ((Pointer) arg1val != (Pointer) values1[i1])
    1533           0 :                     pfree(arg1val);
    1534         472 :                 if ((Pointer) arg2val != (Pointer) values2[i2])
    1535           0 :                     pfree(arg2val);
    1536             :             }
    1537             :             else
    1538           0 :                 elog(ERROR, "unexpected attlen: %d", att1->attlen);
    1539             : 
    1540        1486 :             if (cmpresult < 0)
    1541             :             {
    1542             :                 /* arg1 is less than arg2 */
    1543         368 :                 result = -1;
    1544         368 :                 break;
    1545             :             }
    1546        1118 :             else if (cmpresult > 0)
    1547             :             {
    1548             :                 /* arg1 is greater than arg2 */
    1549         304 :                 result = 1;
    1550         304 :                 break;
    1551             :             }
    1552             :         }
    1553             : 
    1554             :         /* equal, so continue to next column */
    1555         814 :         i1++, i2++, j++;
    1556             :     }
    1557             : 
    1558             :     /*
    1559             :      * If we didn't break out of the loop early, check for column count
    1560             :      * mismatch.  (We do not report such mismatch if we found unequal column
    1561             :      * values; is that a feature or a bug?)
    1562             :      */
    1563         846 :     if (result == 0)
    1564             :     {
    1565         174 :         if (i1 != ncolumns1 || i2 != ncolumns2)
    1566           6 :             ereport(ERROR,
    1567             :                     (errcode(ERRCODE_DATATYPE_MISMATCH),
    1568             :                      errmsg("cannot compare record types with different numbers of columns")));
    1569             :     }
    1570             : 
    1571         840 :     pfree(values1);
    1572         840 :     pfree(nulls1);
    1573         840 :     pfree(values2);
    1574         840 :     pfree(nulls2);
    1575         840 :     ReleaseTupleDesc(tupdesc1);
    1576         840 :     ReleaseTupleDesc(tupdesc2);
    1577             : 
    1578             :     /* Avoid leaking memory when handed toasted input. */
    1579         840 :     PG_FREE_IF_COPY(record1, 0);
    1580         840 :     PG_FREE_IF_COPY(record2, 1);
    1581             : 
    1582         840 :     return result;
    1583             : }
    1584             : 
    1585             : /*
    1586             :  * record_image_eq :
    1587             :  *        compares two records for identical contents, based on byte images
    1588             :  * result :
    1589             :  *        returns true if the records are identical, false otherwise.
    1590             :  *
    1591             :  * Note: we do not use record_image_cmp here, since we can avoid
    1592             :  * de-toasting for unequal lengths this way.
    1593             :  */
    1594             : Datum
    1595         260 : record_image_eq(PG_FUNCTION_ARGS)
    1596             : {
    1597         260 :     HeapTupleHeader record1 = PG_GETARG_HEAPTUPLEHEADER(0);
    1598         260 :     HeapTupleHeader record2 = PG_GETARG_HEAPTUPLEHEADER(1);
    1599         260 :     bool        result = true;
    1600             :     Oid         tupType1;
    1601             :     Oid         tupType2;
    1602             :     int32       tupTypmod1;
    1603             :     int32       tupTypmod2;
    1604             :     TupleDesc   tupdesc1;
    1605             :     TupleDesc   tupdesc2;
    1606             :     HeapTupleData tuple1;
    1607             :     HeapTupleData tuple2;
    1608             :     int         ncolumns1;
    1609             :     int         ncolumns2;
    1610             :     RecordCompareData *my_extra;
    1611             :     int         ncols;
    1612             :     Datum      *values1;
    1613             :     Datum      *values2;
    1614             :     bool       *nulls1;
    1615             :     bool       *nulls2;
    1616             :     int         i1;
    1617             :     int         i2;
    1618             :     int         j;
    1619             : 
    1620             :     /* Extract type info from the tuples */
    1621         260 :     tupType1 = HeapTupleHeaderGetTypeId(record1);
    1622         260 :     tupTypmod1 = HeapTupleHeaderGetTypMod(record1);
    1623         260 :     tupdesc1 = lookup_rowtype_tupdesc(tupType1, tupTypmod1);
    1624         260 :     ncolumns1 = tupdesc1->natts;
    1625         260 :     tupType2 = HeapTupleHeaderGetTypeId(record2);
    1626         260 :     tupTypmod2 = HeapTupleHeaderGetTypMod(record2);
    1627         260 :     tupdesc2 = lookup_rowtype_tupdesc(tupType2, tupTypmod2);
    1628         260 :     ncolumns2 = tupdesc2->natts;
    1629             : 
    1630             :     /* Build temporary HeapTuple control structures */
    1631         260 :     tuple1.t_len = HeapTupleHeaderGetDatumLength(record1);
    1632         260 :     ItemPointerSetInvalid(&(tuple1.t_self));
    1633         260 :     tuple1.t_tableOid = InvalidOid;
    1634         260 :     tuple1.t_data = record1;
    1635         260 :     tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
    1636         260 :     ItemPointerSetInvalid(&(tuple2.t_self));
    1637         260 :     tuple2.t_tableOid = InvalidOid;
    1638         260 :     tuple2.t_data = record2;
    1639             : 
    1640             :     /*
    1641             :      * We arrange to look up the needed comparison info just once per series
    1642             :      * of calls, assuming the record types don't change underneath us.
    1643             :      */
    1644         260 :     ncols = Max(ncolumns1, ncolumns2);
    1645         260 :     my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
    1646         260 :     if (my_extra == NULL ||
    1647         130 :         my_extra->ncolumns < ncols)
    1648             :     {
    1649         260 :         fcinfo->flinfo->fn_extra =
    1650         130 :             MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
    1651         130 :                                offsetof(RecordCompareData, columns) +
    1652             :                                ncols * sizeof(ColumnCompareData));
    1653         130 :         my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
    1654         130 :         my_extra->ncolumns = ncols;
    1655         130 :         my_extra->record1_type = InvalidOid;
    1656         130 :         my_extra->record1_typmod = 0;
    1657         130 :         my_extra->record2_type = InvalidOid;
    1658         130 :         my_extra->record2_typmod = 0;
    1659             :     }
    1660             : 
    1661         260 :     if (my_extra->record1_type != tupType1 ||
    1662         130 :         my_extra->record1_typmod != tupTypmod1 ||
    1663         130 :         my_extra->record2_type != tupType2 ||
    1664         130 :         my_extra->record2_typmod != tupTypmod2)
    1665             :     {
    1666         424 :         MemSet(my_extra->columns, 0, ncols * sizeof(ColumnCompareData));
    1667         130 :         my_extra->record1_type = tupType1;
    1668         130 :         my_extra->record1_typmod = tupTypmod1;
    1669         130 :         my_extra->record2_type = tupType2;
    1670         130 :         my_extra->record2_typmod = tupTypmod2;
    1671             :     }
    1672             : 
    1673             :     /* Break down the tuples into fields */
    1674         260 :     values1 = (Datum *) palloc(ncolumns1 * sizeof(Datum));
    1675         260 :     nulls1 = (bool *) palloc(ncolumns1 * sizeof(bool));
    1676         260 :     heap_deform_tuple(&tuple1, tupdesc1, values1, nulls1);
    1677         260 :     values2 = (Datum *) palloc(ncolumns2 * sizeof(Datum));
    1678         260 :     nulls2 = (bool *) palloc(ncolumns2 * sizeof(bool));
    1679         260 :     heap_deform_tuple(&tuple2, tupdesc2, values2, nulls2);
    1680             : 
    1681             :     /*
    1682             :      * Scan corresponding columns, allowing for dropped columns in different
    1683             :      * places in the two rows.  i1 and i2 are physical column indexes, j is
    1684             :      * the logical column index.
    1685             :      */
    1686         260 :     i1 = i2 = j = 0;
    1687         988 :     while (i1 < ncolumns1 || i2 < ncolumns2)
    1688             :     {
    1689             :         Form_pg_attribute att1;
    1690             :         Form_pg_attribute att2;
    1691             : 
    1692             :         /*
    1693             :          * Skip dropped columns
    1694             :          */
    1695         798 :         if (i1 < ncolumns1 && TupleDescAttr(tupdesc1, i1)->attisdropped)
    1696             :         {
    1697           0 :             i1++;
    1698           0 :             continue;
    1699             :         }
    1700         798 :         if (i2 < ncolumns2 && TupleDescAttr(tupdesc2, i2)->attisdropped)
    1701             :         {
    1702           0 :             i2++;
    1703           0 :             continue;
    1704             :         }
    1705         798 :         if (i1 >= ncolumns1 || i2 >= ncolumns2)
    1706             :             break;              /* we'll deal with mismatch below loop */
    1707             : 
    1708         792 :         att1 = TupleDescAttr(tupdesc1, i1);
    1709         792 :         att2 = TupleDescAttr(tupdesc2, i2);
    1710             : 
    1711             :         /*
    1712             :          * Have two matching columns, they must be same type
    1713             :          */
    1714         792 :         if (att1->atttypid != att2->atttypid)
    1715           6 :             ereport(ERROR,
    1716             :                     (errcode(ERRCODE_DATATYPE_MISMATCH),
    1717             :                      errmsg("cannot compare dissimilar column types %s and %s at record column %d",
    1718             :                             format_type_be(att1->atttypid),
    1719             :                             format_type_be(att2->atttypid),
    1720             :                             j + 1)));
    1721             : 
    1722             :         /*
    1723             :          * We consider two NULLs equal; NULL > not-NULL.
    1724             :          */
    1725         786 :         if (!nulls1[i1] || !nulls2[i2])
    1726             :         {
    1727         774 :             if (nulls1[i1] || nulls2[i2])
    1728             :             {
    1729           0 :                 result = false;
    1730           0 :                 break;
    1731             :             }
    1732             : 
    1733             :             /* Compare the pair of elements */
    1734         774 :             result = datum_image_eq(values1[i1], values2[i2], att1->attbyval, att2->attlen);
    1735         774 :             if (!result)
    1736          58 :                 break;
    1737             :         }
    1738             : 
    1739             :         /* equal, so continue to next column */
    1740         728 :         i1++, i2++, j++;
    1741             :     }
    1742             : 
    1743             :     /*
    1744             :      * If we didn't break out of the loop early, check for column count
    1745             :      * mismatch.  (We do not report such mismatch if we found unequal column
    1746             :      * values; is that a feature or a bug?)
    1747             :      */
    1748         254 :     if (result)
    1749             :     {
    1750         196 :         if (i1 != ncolumns1 || i2 != ncolumns2)
    1751           6 :             ereport(ERROR,
    1752             :                     (errcode(ERRCODE_DATATYPE_MISMATCH),
    1753             :                      errmsg("cannot compare record types with different numbers of columns")));
    1754             :     }
    1755             : 
    1756         248 :     pfree(values1);
    1757         248 :     pfree(nulls1);
    1758         248 :     pfree(values2);
    1759         248 :     pfree(nulls2);
    1760         248 :     ReleaseTupleDesc(tupdesc1);
    1761         248 :     ReleaseTupleDesc(tupdesc2);
    1762             : 
    1763             :     /* Avoid leaking memory when handed toasted input. */
    1764         248 :     PG_FREE_IF_COPY(record1, 0);
    1765         248 :     PG_FREE_IF_COPY(record2, 1);
    1766             : 
    1767         248 :     PG_RETURN_BOOL(result);
    1768             : }
    1769             : 
    1770             : Datum
    1771          48 : record_image_ne(PG_FUNCTION_ARGS)
    1772             : {
    1773          48 :     PG_RETURN_BOOL(!DatumGetBool(record_image_eq(fcinfo)));
    1774             : }
    1775             : 
    1776             : Datum
    1777          72 : record_image_lt(PG_FUNCTION_ARGS)
    1778             : {
    1779          72 :     PG_RETURN_BOOL(record_image_cmp(fcinfo) < 0);
    1780             : }
    1781             : 
    1782             : Datum
    1783          18 : record_image_gt(PG_FUNCTION_ARGS)
    1784             : {
    1785          18 :     PG_RETURN_BOOL(record_image_cmp(fcinfo) > 0);
    1786             : }
    1787             : 
    1788             : Datum
    1789          12 : record_image_le(PG_FUNCTION_ARGS)
    1790             : {
    1791          12 :     PG_RETURN_BOOL(record_image_cmp(fcinfo) <= 0);
    1792             : }
    1793             : 
    1794             : Datum
    1795          18 : record_image_ge(PG_FUNCTION_ARGS)
    1796             : {
    1797          18 :     PG_RETURN_BOOL(record_image_cmp(fcinfo) >= 0);
    1798             : }
    1799             : 
    1800             : Datum
    1801         732 : btrecordimagecmp(PG_FUNCTION_ARGS)
    1802             : {
    1803         732 :     PG_RETURN_INT32(record_image_cmp(fcinfo));
    1804             : }
    1805             : 
    1806             : 
    1807             : /*
    1808             :  * Row type hash functions
    1809             :  */
    1810             : 
    1811             : Datum
    1812         900 : hash_record(PG_FUNCTION_ARGS)
    1813             : {
    1814         900 :     HeapTupleHeader record = PG_GETARG_HEAPTUPLEHEADER(0);
    1815         900 :     uint32      result = 0;
    1816             :     Oid         tupType;
    1817             :     int32       tupTypmod;
    1818             :     TupleDesc   tupdesc;
    1819             :     HeapTupleData tuple;
    1820             :     int         ncolumns;
    1821             :     RecordCompareData *my_extra;
    1822             :     Datum      *values;
    1823             :     bool       *nulls;
    1824             : 
    1825         900 :     check_stack_depth();        /* recurses for record-type columns */
    1826             : 
    1827             :     /* Extract type info from tuple */
    1828         900 :     tupType = HeapTupleHeaderGetTypeId(record);
    1829         900 :     tupTypmod = HeapTupleHeaderGetTypMod(record);
    1830         900 :     tupdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
    1831         900 :     ncolumns = tupdesc->natts;
    1832             : 
    1833             :     /* Build temporary HeapTuple control structure */
    1834         900 :     tuple.t_len = HeapTupleHeaderGetDatumLength(record);
    1835         900 :     ItemPointerSetInvalid(&(tuple.t_self));
    1836         900 :     tuple.t_tableOid = InvalidOid;
    1837         900 :     tuple.t_data = record;
    1838             : 
    1839             :     /*
    1840             :      * We arrange to look up the needed hashing info just once per series of
    1841             :      * calls, assuming the record type doesn't change underneath us.
    1842             :      */
    1843         900 :     my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
    1844         900 :     if (my_extra == NULL ||
    1845         852 :         my_extra->ncolumns < ncolumns)
    1846             :     {
    1847          96 :         fcinfo->flinfo->fn_extra =
    1848          48 :             MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
    1849          48 :                                offsetof(RecordCompareData, columns) +
    1850             :                                ncolumns * sizeof(ColumnCompareData));
    1851          48 :         my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
    1852          48 :         my_extra->ncolumns = ncolumns;
    1853          48 :         my_extra->record1_type = InvalidOid;
    1854          48 :         my_extra->record1_typmod = 0;
    1855             :     }
    1856             : 
    1857         900 :     if (my_extra->record1_type != tupType ||
    1858         852 :         my_extra->record1_typmod != tupTypmod)
    1859             :     {
    1860         150 :         MemSet(my_extra->columns, 0, ncolumns * sizeof(ColumnCompareData));
    1861          48 :         my_extra->record1_type = tupType;
    1862          48 :         my_extra->record1_typmod = tupTypmod;
    1863             :     }
    1864             : 
    1865             :     /* Break down the tuple into fields */
    1866         900 :     values = (Datum *) palloc(ncolumns * sizeof(Datum));
    1867         900 :     nulls = (bool *) palloc(ncolumns * sizeof(bool));
    1868         900 :     heap_deform_tuple(&tuple, tupdesc, values, nulls);
    1869             : 
    1870        2730 :     for (int i = 0; i < ncolumns; i++)
    1871             :     {
    1872             :         Form_pg_attribute att;
    1873             :         TypeCacheEntry *typentry;
    1874             :         uint32      element_hash;
    1875             : 
    1876        1836 :         att = TupleDescAttr(tupdesc, i);
    1877             : 
    1878        1836 :         if (att->attisdropped)
    1879           0 :             continue;
    1880             : 
    1881             :         /*
    1882             :          * Lookup the hash function if not done already
    1883             :          */
    1884        1836 :         typentry = my_extra->columns[i].typentry;
    1885        1836 :         if (typentry == NULL ||
    1886        1740 :             typentry->type_id != att->atttypid)
    1887             :         {
    1888          96 :             typentry = lookup_type_cache(att->atttypid,
    1889             :                                          TYPECACHE_HASH_PROC_FINFO);
    1890          96 :             if (!OidIsValid(typentry->hash_proc_finfo.fn_oid))
    1891           6 :                 ereport(ERROR,
    1892             :                         (errcode(ERRCODE_UNDEFINED_FUNCTION),
    1893             :                          errmsg("could not identify a hash function for type %s",
    1894             :                                 format_type_be(typentry->type_id))));
    1895          90 :             my_extra->columns[i].typentry = typentry;
    1896             :         }
    1897             : 
    1898             :         /* Compute hash of element */
    1899        1830 :         if (nulls[i])
    1900             :         {
    1901           0 :             element_hash = 0;
    1902             :         }
    1903             :         else
    1904             :         {
    1905        1830 :             LOCAL_FCINFO(locfcinfo, 1);
    1906             : 
    1907        1830 :             InitFunctionCallInfoData(*locfcinfo, &typentry->hash_proc_finfo, 1,
    1908             :                                      att->attcollation, NULL, NULL);
    1909        1830 :             locfcinfo->args[0].value = values[i];
    1910        1830 :             locfcinfo->args[0].isnull = false;
    1911        1830 :             element_hash = DatumGetUInt32(FunctionCallInvoke(locfcinfo));
    1912             : 
    1913             :             /* We don't expect hash support functions to return null */
    1914             :             Assert(!locfcinfo->isnull);
    1915             :         }
    1916             : 
    1917             :         /* see hash_array() */
    1918        1830 :         result = (result << 5) - result + element_hash;
    1919             :     }
    1920             : 
    1921         894 :     pfree(values);
    1922         894 :     pfree(nulls);
    1923         894 :     ReleaseTupleDesc(tupdesc);
    1924             : 
    1925             :     /* Avoid leaking memory when handed toasted input. */
    1926         894 :     PG_FREE_IF_COPY(record, 0);
    1927             : 
    1928         894 :     PG_RETURN_UINT32(result);
    1929             : }
    1930             : 
    1931             : Datum
    1932          30 : hash_record_extended(PG_FUNCTION_ARGS)
    1933             : {
    1934          30 :     HeapTupleHeader record = PG_GETARG_HEAPTUPLEHEADER(0);
    1935          30 :     uint64      seed = PG_GETARG_INT64(1);
    1936          30 :     uint64      result = 0;
    1937             :     Oid         tupType;
    1938             :     int32       tupTypmod;
    1939             :     TupleDesc   tupdesc;
    1940             :     HeapTupleData tuple;
    1941             :     int         ncolumns;
    1942             :     RecordCompareData *my_extra;
    1943             :     Datum      *values;
    1944             :     bool       *nulls;
    1945             : 
    1946          30 :     check_stack_depth();        /* recurses for record-type columns */
    1947             : 
    1948             :     /* Extract type info from tuple */
    1949          30 :     tupType = HeapTupleHeaderGetTypeId(record);
    1950          30 :     tupTypmod = HeapTupleHeaderGetTypMod(record);
    1951          30 :     tupdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
    1952          30 :     ncolumns = tupdesc->natts;
    1953             : 
    1954             :     /* Build temporary HeapTuple control structure */
    1955          30 :     tuple.t_len = HeapTupleHeaderGetDatumLength(record);
    1956          30 :     ItemPointerSetInvalid(&(tuple.t_self));
    1957          30 :     tuple.t_tableOid = InvalidOid;
    1958          30 :     tuple.t_data = record;
    1959             : 
    1960             :     /*
    1961             :      * We arrange to look up the needed hashing info just once per series of
    1962             :      * calls, assuming the record type doesn't change underneath us.
    1963             :      */
    1964          30 :     my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
    1965          30 :     if (my_extra == NULL ||
    1966           0 :         my_extra->ncolumns < ncolumns)
    1967             :     {
    1968          60 :         fcinfo->flinfo->fn_extra =
    1969          30 :             MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
    1970          30 :                                offsetof(RecordCompareData, columns) +
    1971             :                                ncolumns * sizeof(ColumnCompareData));
    1972          30 :         my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
    1973          30 :         my_extra->ncolumns = ncolumns;
    1974          30 :         my_extra->record1_type = InvalidOid;
    1975          30 :         my_extra->record1_typmod = 0;
    1976             :     }
    1977             : 
    1978          30 :     if (my_extra->record1_type != tupType ||
    1979           0 :         my_extra->record1_typmod != tupTypmod)
    1980             :     {
    1981          90 :         MemSet(my_extra->columns, 0, ncolumns * sizeof(ColumnCompareData));
    1982          30 :         my_extra->record1_type = tupType;
    1983          30 :         my_extra->record1_typmod = tupTypmod;
    1984             :     }
    1985             : 
    1986             :     /* Break down the tuple into fields */
    1987          30 :     values = (Datum *) palloc(ncolumns * sizeof(Datum));
    1988          30 :     nulls = (bool *) palloc(ncolumns * sizeof(bool));
    1989          30 :     heap_deform_tuple(&tuple, tupdesc, values, nulls);
    1990             : 
    1991          78 :     for (int i = 0; i < ncolumns; i++)
    1992             :     {
    1993             :         Form_pg_attribute att;
    1994             :         TypeCacheEntry *typentry;
    1995             :         uint64      element_hash;
    1996             : 
    1997          54 :         att = TupleDescAttr(tupdesc, i);
    1998             : 
    1999          54 :         if (att->attisdropped)
    2000           0 :             continue;
    2001             : 
    2002             :         /*
    2003             :          * Lookup the hash function if not done already
    2004             :          */
    2005          54 :         typentry = my_extra->columns[i].typentry;
    2006          54 :         if (typentry == NULL ||
    2007           0 :             typentry->type_id != att->atttypid)
    2008             :         {
    2009          54 :             typentry = lookup_type_cache(att->atttypid,
    2010             :                                          TYPECACHE_HASH_EXTENDED_PROC_FINFO);
    2011          54 :             if (!OidIsValid(typentry->hash_extended_proc_finfo.fn_oid))
    2012           6 :                 ereport(ERROR,
    2013             :                         (errcode(ERRCODE_UNDEFINED_FUNCTION),
    2014             :                          errmsg("could not identify an extended hash function for type %s",
    2015             :                                 format_type_be(typentry->type_id))));
    2016          48 :             my_extra->columns[i].typentry = typentry;
    2017             :         }
    2018             : 
    2019             :         /* Compute hash of element */
    2020          48 :         if (nulls[i])
    2021             :         {
    2022           0 :             element_hash = 0;
    2023             :         }
    2024             :         else
    2025             :         {
    2026          48 :             LOCAL_FCINFO(locfcinfo, 2);
    2027             : 
    2028          48 :             InitFunctionCallInfoData(*locfcinfo, &typentry->hash_extended_proc_finfo, 2,
    2029             :                                      att->attcollation, NULL, NULL);
    2030          48 :             locfcinfo->args[0].value = values[i];
    2031          48 :             locfcinfo->args[0].isnull = false;
    2032          48 :             locfcinfo->args[1].value = Int64GetDatum(seed);
    2033          48 :             locfcinfo->args[0].isnull = false;
    2034          48 :             element_hash = DatumGetUInt64(FunctionCallInvoke(locfcinfo));
    2035             : 
    2036             :             /* We don't expect hash support functions to return null */
    2037             :             Assert(!locfcinfo->isnull);
    2038             :         }
    2039             : 
    2040             :         /* see hash_array_extended() */
    2041          48 :         result = (result << 5) - result + element_hash;
    2042             :     }
    2043             : 
    2044          24 :     pfree(values);
    2045          24 :     pfree(nulls);
    2046          24 :     ReleaseTupleDesc(tupdesc);
    2047             : 
    2048             :     /* Avoid leaking memory when handed toasted input. */
    2049          24 :     PG_FREE_IF_COPY(record, 0);
    2050             : 
    2051          24 :     PG_RETURN_UINT64(result);
    2052             : }

Generated by: LCOV version 1.14