LCOV - code coverage report
Current view: top level - src/backend/utils/adt - varbit.c (source / functions) Hit Total Coverage
Test: PostgreSQL 15beta1 Lines: 575 676 85.1 %
Date: 2022-05-18 04:09:35 Functions: 44 49 89.8 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * varbit.c
       4             :  *    Functions for the SQL datatypes BIT() and BIT VARYING().
       5             :  *
       6             :  * The data structure contains the following elements:
       7             :  *   header  -- length of the whole data structure (incl header)
       8             :  *              in bytes (as with all varying length datatypes)
       9             :  *   data section -- private data section for the bits data structures
      10             :  *     bitlength -- length of the bit string in bits
      11             :  *     bitdata   -- bit string, most significant byte first
      12             :  *
      13             :  * The length of the bitdata vector should always be exactly as many
      14             :  * bytes as are needed for the given bitlength.  If the bitlength is
      15             :  * not a multiple of 8, the extra low-order padding bits of the last
      16             :  * byte must be zeroes.
      17             :  *
      18             :  * attypmod is defined as the length of the bit string in bits, or for
      19             :  * varying bits the maximum length.
      20             :  *
      21             :  * Code originally contributed by Adriaan Joubert.
      22             :  *
      23             :  * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
      24             :  * Portions Copyright (c) 1994, Regents of the University of California
      25             :  *
      26             :  * IDENTIFICATION
      27             :  *    src/backend/utils/adt/varbit.c
      28             :  *
      29             :  *-------------------------------------------------------------------------
      30             :  */
      31             : 
      32             : #include "postgres.h"
      33             : 
      34             : #include "access/htup_details.h"
      35             : #include "common/int.h"
      36             : #include "libpq/pqformat.h"
      37             : #include "nodes/nodeFuncs.h"
      38             : #include "nodes/supportnodes.h"
      39             : #include "port/pg_bitutils.h"
      40             : #include "utils/array.h"
      41             : #include "utils/builtins.h"
      42             : #include "utils/varbit.h"
      43             : 
      44             : #define HEXDIG(z)    ((z)<10 ? ((z)+'0') : ((z)-10+'A'))
      45             : 
      46             : /* Mask off any bits that should be zero in the last byte of a bitstring */
      47             : #define VARBIT_PAD(vb) \
      48             :     do { \
      49             :         int32   pad_ = VARBITPAD(vb); \
      50             :         Assert(pad_ >= 0 && pad_ < BITS_PER_BYTE); \
      51             :         if (pad_ > 0) \
      52             :             *(VARBITS(vb) + VARBITBYTES(vb) - 1) &= BITMASK << pad_; \
      53             :     } while (0)
      54             : 
      55             : /*
      56             :  * Many functions work byte-by-byte, so they have a pointer handy to the
      57             :  * last-plus-one byte, which saves a cycle or two.
      58             :  */
      59             : #define VARBIT_PAD_LAST(vb, ptr) \
      60             :     do { \
      61             :         int32   pad_ = VARBITPAD(vb); \
      62             :         Assert(pad_ >= 0 && pad_ < BITS_PER_BYTE); \
      63             :         if (pad_ > 0) \
      64             :             *((ptr) - 1) &= BITMASK << pad_; \
      65             :     } while (0)
      66             : 
      67             : /* Assert proper padding of a bitstring */
      68             : #ifdef USE_ASSERT_CHECKING
      69             : #define VARBIT_CORRECTLY_PADDED(vb) \
      70             :     do { \
      71             :         int32   pad_ = VARBITPAD(vb); \
      72             :         Assert(pad_ >= 0 && pad_ < BITS_PER_BYTE); \
      73             :         Assert(pad_ == 0 || \
      74             :                (*(VARBITS(vb) + VARBITBYTES(vb) - 1) & ~(BITMASK << pad_)) == 0); \
      75             :     } while (0)
      76             : #else
      77             : #define VARBIT_CORRECTLY_PADDED(vb) ((void) 0)
      78             : #endif
      79             : 
      80             : static VarBit *bit_catenate(VarBit *arg1, VarBit *arg2);
      81             : static VarBit *bitsubstring(VarBit *arg, int32 s, int32 l,
      82             :                             bool length_not_specified);
      83             : static VarBit *bit_overlay(VarBit *t1, VarBit *t2, int sp, int sl);
      84             : 
      85             : 
      86             : /*
      87             :  * common code for bittypmodin and varbittypmodin
      88             :  */
      89             : static int32
      90        2446 : anybit_typmodin(ArrayType *ta, const char *typename)
      91             : {
      92             :     int32       typmod;
      93             :     int32      *tl;
      94             :     int         n;
      95             : 
      96        2446 :     tl = ArrayGetIntegerTypmods(ta, &n);
      97             : 
      98             :     /*
      99             :      * we're not too tense about good error message here because grammar
     100             :      * shouldn't allow wrong number of modifiers for BIT
     101             :      */
     102        2446 :     if (n != 1)
     103           0 :         ereport(ERROR,
     104             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     105             :                  errmsg("invalid type modifier")));
     106             : 
     107        2446 :     if (*tl < 1)
     108           0 :         ereport(ERROR,
     109             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     110             :                  errmsg("length for type %s must be at least 1",
     111             :                         typename)));
     112        2446 :     if (*tl > (MaxAttrSize * BITS_PER_BYTE))
     113           0 :         ereport(ERROR,
     114             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     115             :                  errmsg("length for type %s cannot exceed %d",
     116             :                         typename, MaxAttrSize * BITS_PER_BYTE)));
     117             : 
     118        2446 :     typmod = *tl;
     119             : 
     120        2446 :     return typmod;
     121             : }
     122             : 
     123             : /*
     124             :  * common code for bittypmodout and varbittypmodout
     125             :  */
     126             : static char *
     127         336 : anybit_typmodout(int32 typmod)
     128             : {
     129         336 :     char       *res = (char *) palloc(64);
     130             : 
     131         336 :     if (typmod >= 0)
     132         336 :         snprintf(res, 64, "(%d)", typmod);
     133             :     else
     134           0 :         *res = '\0';
     135             : 
     136         336 :     return res;
     137             : }
     138             : 
     139             : 
     140             : /*
     141             :  * bit_in -
     142             :  *    converts a char string to the internal representation of a bitstring.
     143             :  *        The length is determined by the number of bits required plus
     144             :  *        VARHDRSZ bytes or from atttypmod.
     145             :  */
     146             : Datum
     147        5628 : bit_in(PG_FUNCTION_ARGS)
     148             : {
     149        5628 :     char       *input_string = PG_GETARG_CSTRING(0);
     150             : 
     151             : #ifdef NOT_USED
     152             :     Oid         typelem = PG_GETARG_OID(1);
     153             : #endif
     154        5628 :     int32       atttypmod = PG_GETARG_INT32(2);
     155             :     VarBit     *result;         /* The resulting bit string           */
     156             :     char       *sp;             /* pointer into the character string  */
     157             :     bits8      *r;              /* pointer into the result */
     158             :     int         len,            /* Length of the whole data structure */
     159             :                 bitlen,         /* Number of bits in the bit string   */
     160             :                 slen;           /* Length of the input string         */
     161             :     bool        bit_not_hex;    /* false = hex string  true = bit string */
     162             :     int         bc;
     163        5628 :     bits8       x = 0;
     164             : 
     165             :     /* Check that the first character is a b or an x */
     166        5628 :     if (input_string[0] == 'b' || input_string[0] == 'B')
     167             :     {
     168         760 :         bit_not_hex = true;
     169         760 :         sp = input_string + 1;
     170             :     }
     171        4868 :     else if (input_string[0] == 'x' || input_string[0] == 'X')
     172             :     {
     173        3422 :         bit_not_hex = false;
     174        3422 :         sp = input_string + 1;
     175             :     }
     176             :     else
     177             :     {
     178             :         /*
     179             :          * Otherwise it's binary.  This allows things like cast('1001' as bit)
     180             :          * to work transparently.
     181             :          */
     182        1446 :         bit_not_hex = true;
     183        1446 :         sp = input_string;
     184             :     }
     185             : 
     186             :     /*
     187             :      * Determine bitlength from input string.  MaxAllocSize ensures a regular
     188             :      * input is small enough, but we must check hex input.
     189             :      */
     190        5628 :     slen = strlen(sp);
     191        5628 :     if (bit_not_hex)
     192        2206 :         bitlen = slen;
     193             :     else
     194             :     {
     195        3422 :         if (slen > VARBITMAXLEN / 4)
     196           0 :             ereport(ERROR,
     197             :                     (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
     198             :                      errmsg("bit string length exceeds the maximum allowed (%d)",
     199             :                             VARBITMAXLEN)));
     200        3422 :         bitlen = slen * 4;
     201             :     }
     202             : 
     203             :     /*
     204             :      * Sometimes atttypmod is not supplied. If it is supplied we need to make
     205             :      * sure that the bitstring fits.
     206             :      */
     207        5628 :     if (atttypmod <= 0)
     208        4290 :         atttypmod = bitlen;
     209        1338 :     else if (bitlen != atttypmod)
     210           0 :         ereport(ERROR,
     211             :                 (errcode(ERRCODE_STRING_DATA_LENGTH_MISMATCH),
     212             :                  errmsg("bit string length %d does not match type bit(%d)",
     213             :                         bitlen, atttypmod)));
     214             : 
     215        5628 :     len = VARBITTOTALLEN(atttypmod);
     216             :     /* set to 0 so that *r is always initialised and string is zero-padded */
     217        5628 :     result = (VarBit *) palloc0(len);
     218        5628 :     SET_VARSIZE(result, len);
     219        5628 :     VARBITLEN(result) = atttypmod;
     220             : 
     221        5628 :     r = VARBITS(result);
     222        5628 :     if (bit_not_hex)
     223             :     {
     224             :         /* Parse the bit representation of the string */
     225             :         /* We know it fits, as bitlen was compared to atttypmod */
     226        2206 :         x = HIGHBIT;
     227       51422 :         for (; *sp; sp++)
     228             :         {
     229       49216 :             if (*sp == '1')
     230       24520 :                 *r |= x;
     231       24696 :             else if (*sp != '0')
     232           0 :                 ereport(ERROR,
     233             :                         (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
     234             :                          errmsg("\"%.*s\" is not a valid binary digit",
     235             :                                 pg_mblen(sp), sp)));
     236             : 
     237       49216 :             x >>= 1;
     238       49216 :             if (x == 0)
     239             :             {
     240        5684 :                 x = HIGHBIT;
     241        5684 :                 r++;
     242             :             }
     243             :         }
     244             :     }
     245             :     else
     246             :     {
     247             :         /* Parse the hex representation of the string */
     248       40818 :         for (bc = 0; *sp; sp++)
     249             :         {
     250       37396 :             if (*sp >= '0' && *sp <= '9')
     251       25466 :                 x = (bits8) (*sp - '0');
     252       11930 :             else if (*sp >= 'A' && *sp <= 'F')
     253         566 :                 x = (bits8) (*sp - 'A') + 10;
     254       11364 :             else if (*sp >= 'a' && *sp <= 'f')
     255       11364 :                 x = (bits8) (*sp - 'a') + 10;
     256             :             else
     257           0 :                 ereport(ERROR,
     258             :                         (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
     259             :                          errmsg("\"%.*s\" is not a valid hexadecimal digit",
     260             :                                 pg_mblen(sp), sp)));
     261             : 
     262       37396 :             if (bc)
     263             :             {
     264       18600 :                 *r++ |= x;
     265       18600 :                 bc = 0;
     266             :             }
     267             :             else
     268             :             {
     269       18796 :                 *r = x << 4;
     270       18796 :                 bc = 1;
     271             :             }
     272             :         }
     273             :     }
     274             : 
     275        5628 :     PG_RETURN_VARBIT_P(result);
     276             : }
     277             : 
     278             : 
     279             : Datum
     280        4226 : bit_out(PG_FUNCTION_ARGS)
     281             : {
     282             : #if 1
     283             :     /* same as varbit output */
     284        4226 :     return varbit_out(fcinfo);
     285             : #else
     286             : 
     287             :     /*
     288             :      * This is how one would print a hex string, in case someone wants to
     289             :      * write a formatting function.
     290             :      */
     291             :     VarBit     *s = PG_GETARG_VARBIT_P(0);
     292             :     char       *result,
     293             :                *r;
     294             :     bits8      *sp;
     295             :     int         i,
     296             :                 len,
     297             :                 bitlen;
     298             : 
     299             :     /* Assertion to help catch any bit functions that don't pad correctly */
     300             :     VARBIT_CORRECTLY_PADDED(s);
     301             : 
     302             :     bitlen = VARBITLEN(s);
     303             :     len = (bitlen + 3) / 4;
     304             :     result = (char *) palloc(len + 2);
     305             :     sp = VARBITS(s);
     306             :     r = result;
     307             :     *r++ = 'X';
     308             :     /* we cheat by knowing that we store full bytes zero padded */
     309             :     for (i = 0; i < len; i += 2, sp++)
     310             :     {
     311             :         *r++ = HEXDIG((*sp) >> 4);
     312             :         *r++ = HEXDIG((*sp) & 0xF);
     313             :     }
     314             : 
     315             :     /*
     316             :      * Go back one step if we printed a hex number that was not part of the
     317             :      * bitstring anymore
     318             :      */
     319             :     if (i > len)
     320             :         r--;
     321             :     *r = '\0';
     322             : 
     323             :     PG_RETURN_CSTRING(result);
     324             : #endif
     325             : }
     326             : 
     327             : /*
     328             :  *      bit_recv            - converts external binary format to bit
     329             :  */
     330             : Datum
     331           0 : bit_recv(PG_FUNCTION_ARGS)
     332             : {
     333           0 :     StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
     334             : 
     335             : #ifdef NOT_USED
     336             :     Oid         typelem = PG_GETARG_OID(1);
     337             : #endif
     338           0 :     int32       atttypmod = PG_GETARG_INT32(2);
     339             :     VarBit     *result;
     340             :     int         len,
     341             :                 bitlen;
     342             : 
     343           0 :     bitlen = pq_getmsgint(buf, sizeof(int32));
     344           0 :     if (bitlen < 0 || bitlen > VARBITMAXLEN)
     345           0 :         ereport(ERROR,
     346             :                 (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
     347             :                  errmsg("invalid length in external bit string")));
     348             : 
     349             :     /*
     350             :      * Sometimes atttypmod is not supplied. If it is supplied we need to make
     351             :      * sure that the bitstring fits.
     352             :      */
     353           0 :     if (atttypmod > 0 && bitlen != atttypmod)
     354           0 :         ereport(ERROR,
     355             :                 (errcode(ERRCODE_STRING_DATA_LENGTH_MISMATCH),
     356             :                  errmsg("bit string length %d does not match type bit(%d)",
     357             :                         bitlen, atttypmod)));
     358             : 
     359           0 :     len = VARBITTOTALLEN(bitlen);
     360           0 :     result = (VarBit *) palloc(len);
     361           0 :     SET_VARSIZE(result, len);
     362           0 :     VARBITLEN(result) = bitlen;
     363             : 
     364           0 :     pq_copymsgbytes(buf, (char *) VARBITS(result), VARBITBYTES(result));
     365             : 
     366             :     /* Make sure last byte is correctly zero-padded */
     367           0 :     VARBIT_PAD(result);
     368             : 
     369           0 :     PG_RETURN_VARBIT_P(result);
     370             : }
     371             : 
     372             : /*
     373             :  *      bit_send            - converts bit to binary format
     374             :  */
     375             : Datum
     376           0 : bit_send(PG_FUNCTION_ARGS)
     377             : {
     378             :     /* Exactly the same as varbit_send, so share code */
     379           0 :     return varbit_send(fcinfo);
     380             : }
     381             : 
     382             : /*
     383             :  * bit()
     384             :  * Converts a bit() type to a specific internal length.
     385             :  * len is the bitlength specified in the column definition.
     386             :  *
     387             :  * If doing implicit cast, raise error when source data is wrong length.
     388             :  * If doing explicit cast, silently truncate or zero-pad to specified length.
     389             :  */
     390             : Datum
     391         954 : bit(PG_FUNCTION_ARGS)
     392             : {
     393         954 :     VarBit     *arg = PG_GETARG_VARBIT_P(0);
     394         954 :     int32       len = PG_GETARG_INT32(1);
     395         954 :     bool        isExplicit = PG_GETARG_BOOL(2);
     396             :     VarBit     *result;
     397             :     int         rlen;
     398             : 
     399             :     /* No work if typmod is invalid or supplied data matches it already */
     400         954 :     if (len <= 0 || len > VARBITMAXLEN || len == VARBITLEN(arg))
     401         348 :         PG_RETURN_VARBIT_P(arg);
     402             : 
     403         606 :     if (!isExplicit)
     404          12 :         ereport(ERROR,
     405             :                 (errcode(ERRCODE_STRING_DATA_LENGTH_MISMATCH),
     406             :                  errmsg("bit string length %d does not match type bit(%d)",
     407             :                         VARBITLEN(arg), len)));
     408             : 
     409         594 :     rlen = VARBITTOTALLEN(len);
     410             :     /* set to 0 so that string is zero-padded */
     411         594 :     result = (VarBit *) palloc0(rlen);
     412         594 :     SET_VARSIZE(result, rlen);
     413         594 :     VARBITLEN(result) = len;
     414             : 
     415         594 :     memcpy(VARBITS(result), VARBITS(arg),
     416         594 :            Min(VARBITBYTES(result), VARBITBYTES(arg)));
     417             : 
     418             :     /*
     419             :      * Make sure last byte is zero-padded if needed.  This is useless but safe
     420             :      * if source data was shorter than target length (we assume the last byte
     421             :      * of the source data was itself correctly zero-padded).
     422             :      */
     423         594 :     VARBIT_PAD(result);
     424             : 
     425         594 :     PG_RETURN_VARBIT_P(result);
     426             : }
     427             : 
     428             : Datum
     429        2202 : bittypmodin(PG_FUNCTION_ARGS)
     430             : {
     431        2202 :     ArrayType  *ta = PG_GETARG_ARRAYTYPE_P(0);
     432             : 
     433        2202 :     PG_RETURN_INT32(anybit_typmodin(ta, "bit"));
     434             : }
     435             : 
     436             : Datum
     437         204 : bittypmodout(PG_FUNCTION_ARGS)
     438             : {
     439         204 :     int32       typmod = PG_GETARG_INT32(0);
     440             : 
     441         204 :     PG_RETURN_CSTRING(anybit_typmodout(typmod));
     442             : }
     443             : 
     444             : 
     445             : /*
     446             :  * varbit_in -
     447             :  *    converts a string to the internal representation of a bitstring.
     448             :  *      This is the same as bit_in except that atttypmod is taken as
     449             :  *      the maximum length, not the exact length to force the bitstring to.
     450             :  */
     451             : Datum
     452        1528 : varbit_in(PG_FUNCTION_ARGS)
     453             : {
     454        1528 :     char       *input_string = PG_GETARG_CSTRING(0);
     455             : 
     456             : #ifdef NOT_USED
     457             :     Oid         typelem = PG_GETARG_OID(1);
     458             : #endif
     459        1528 :     int32       atttypmod = PG_GETARG_INT32(2);
     460             :     VarBit     *result;         /* The resulting bit string           */
     461             :     char       *sp;             /* pointer into the character string  */
     462             :     bits8      *r;              /* pointer into the result */
     463             :     int         len,            /* Length of the whole data structure */
     464             :                 bitlen,         /* Number of bits in the bit string   */
     465             :                 slen;           /* Length of the input string         */
     466             :     bool        bit_not_hex;    /* false = hex string  true = bit string */
     467             :     int         bc;
     468        1528 :     bits8       x = 0;
     469             : 
     470             :     /* Check that the first character is a b or an x */
     471        1528 :     if (input_string[0] == 'b' || input_string[0] == 'B')
     472             :     {
     473           0 :         bit_not_hex = true;
     474           0 :         sp = input_string + 1;
     475             :     }
     476        1528 :     else if (input_string[0] == 'x' || input_string[0] == 'X')
     477             :     {
     478         120 :         bit_not_hex = false;
     479         120 :         sp = input_string + 1;
     480             :     }
     481             :     else
     482             :     {
     483        1408 :         bit_not_hex = true;
     484        1408 :         sp = input_string;
     485             :     }
     486             : 
     487             :     /*
     488             :      * Determine bitlength from input string.  MaxAllocSize ensures a regular
     489             :      * input is small enough, but we must check hex input.
     490             :      */
     491        1528 :     slen = strlen(sp);
     492        1528 :     if (bit_not_hex)
     493        1408 :         bitlen = slen;
     494             :     else
     495             :     {
     496         120 :         if (slen > VARBITMAXLEN / 4)
     497           0 :             ereport(ERROR,
     498             :                     (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
     499             :                      errmsg("bit string length exceeds the maximum allowed (%d)",
     500             :                             VARBITMAXLEN)));
     501         120 :         bitlen = slen * 4;
     502             :     }
     503             : 
     504             :     /*
     505             :      * Sometimes atttypmod is not supplied. If it is supplied we need to make
     506             :      * sure that the bitstring fits.
     507             :      */
     508        1528 :     if (atttypmod <= 0)
     509        1408 :         atttypmod = bitlen;
     510         120 :     else if (bitlen > atttypmod)
     511           0 :         ereport(ERROR,
     512             :                 (errcode(ERRCODE_STRING_DATA_RIGHT_TRUNCATION),
     513             :                  errmsg("bit string too long for type bit varying(%d)",
     514             :                         atttypmod)));
     515             : 
     516        1528 :     len = VARBITTOTALLEN(bitlen);
     517             :     /* set to 0 so that *r is always initialised and string is zero-padded */
     518        1528 :     result = (VarBit *) palloc0(len);
     519        1528 :     SET_VARSIZE(result, len);
     520        1528 :     VARBITLEN(result) = Min(bitlen, atttypmod);
     521             : 
     522        1528 :     r = VARBITS(result);
     523        1528 :     if (bit_not_hex)
     524             :     {
     525             :         /* Parse the bit representation of the string */
     526             :         /* We know it fits, as bitlen was compared to atttypmod */
     527        1408 :         x = HIGHBIT;
     528       65850 :         for (; *sp; sp++)
     529             :         {
     530       64442 :             if (*sp == '1')
     531       32058 :                 *r |= x;
     532       32384 :             else if (*sp != '0')
     533           0 :                 ereport(ERROR,
     534             :                         (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
     535             :                          errmsg("\"%.*s\" is not a valid binary digit",
     536             :                                 pg_mblen(sp), sp)));
     537             : 
     538       64442 :             x >>= 1;
     539       64442 :             if (x == 0)
     540             :             {
     541        7500 :                 x = HIGHBIT;
     542        7500 :                 r++;
     543             :             }
     544             :         }
     545             :     }
     546             :     else
     547             :     {
     548             :         /* Parse the hex representation of the string */
     549         480 :         for (bc = 0; *sp; sp++)
     550             :         {
     551         360 :             if (*sp >= '0' && *sp <= '9')
     552         258 :                 x = (bits8) (*sp - '0');
     553         102 :             else if (*sp >= 'A' && *sp <= 'F')
     554         102 :                 x = (bits8) (*sp - 'A') + 10;
     555           0 :             else if (*sp >= 'a' && *sp <= 'f')
     556           0 :                 x = (bits8) (*sp - 'a') + 10;
     557             :             else
     558           0 :                 ereport(ERROR,
     559             :                         (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
     560             :                          errmsg("\"%.*s\" is not a valid hexadecimal digit",
     561             :                                 pg_mblen(sp), sp)));
     562             : 
     563         360 :             if (bc)
     564             :             {
     565         180 :                 *r++ |= x;
     566         180 :                 bc = 0;
     567             :             }
     568             :             else
     569             :             {
     570         180 :                 *r = x << 4;
     571         180 :                 bc = 1;
     572             :             }
     573             :         }
     574             :     }
     575             : 
     576        1528 :     PG_RETURN_VARBIT_P(result);
     577             : }
     578             : 
     579             : /*
     580             :  * varbit_out -
     581             :  *    Prints the string as bits to preserve length accurately
     582             :  *
     583             :  * XXX varbit_recv() and hex input to varbit_in() can load a value that this
     584             :  * cannot emit.  Consider using hex output for such values.
     585             :  */
     586             : Datum
     587        6106 : varbit_out(PG_FUNCTION_ARGS)
     588             : {
     589        6106 :     VarBit     *s = PG_GETARG_VARBIT_P(0);
     590             :     char       *result,
     591             :                *r;
     592             :     bits8      *sp;
     593             :     bits8       x;
     594             :     int         i,
     595             :                 k,
     596             :                 len;
     597             : 
     598             :     /* Assertion to help catch any bit functions that don't pad correctly */
     599             :     VARBIT_CORRECTLY_PADDED(s);
     600             : 
     601        6106 :     len = VARBITLEN(s);
     602        6106 :     result = (char *) palloc(len + 1);
     603        6106 :     sp = VARBITS(s);
     604        6106 :     r = result;
     605       14422 :     for (i = 0; i <= len - BITS_PER_BYTE; i += BITS_PER_BYTE, sp++)
     606             :     {
     607             :         /* print full bytes */
     608        8316 :         x = *sp;
     609       74844 :         for (k = 0; k < BITS_PER_BYTE; k++)
     610             :         {
     611       66528 :             *r++ = IS_HIGHBIT_SET(x) ? '1' : '0';
     612       66528 :             x <<= 1;
     613             :         }
     614             :     }
     615        6106 :     if (i < len)
     616             :     {
     617             :         /* print the last partial byte */
     618        2884 :         x = *sp;
     619       14110 :         for (k = i; k < len; k++)
     620             :         {
     621       11226 :             *r++ = IS_HIGHBIT_SET(x) ? '1' : '0';
     622       11226 :             x <<= 1;
     623             :         }
     624             :     }
     625        6106 :     *r = '\0';
     626             : 
     627        6106 :     PG_RETURN_CSTRING(result);
     628             : }
     629             : 
     630             : /*
     631             :  *      varbit_recv         - converts external binary format to varbit
     632             :  *
     633             :  * External format is the bitlen as an int32, then the byte array.
     634             :  */
     635             : Datum
     636           0 : varbit_recv(PG_FUNCTION_ARGS)
     637             : {
     638           0 :     StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
     639             : 
     640             : #ifdef NOT_USED
     641             :     Oid         typelem = PG_GETARG_OID(1);
     642             : #endif
     643           0 :     int32       atttypmod = PG_GETARG_INT32(2);
     644             :     VarBit     *result;
     645             :     int         len,
     646             :                 bitlen;
     647             : 
     648           0 :     bitlen = pq_getmsgint(buf, sizeof(int32));
     649           0 :     if (bitlen < 0 || bitlen > VARBITMAXLEN)
     650           0 :         ereport(ERROR,
     651             :                 (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
     652             :                  errmsg("invalid length in external bit string")));
     653             : 
     654             :     /*
     655             :      * Sometimes atttypmod is not supplied. If it is supplied we need to make
     656             :      * sure that the bitstring fits.
     657             :      */
     658           0 :     if (atttypmod > 0 && bitlen > atttypmod)
     659           0 :         ereport(ERROR,
     660             :                 (errcode(ERRCODE_STRING_DATA_RIGHT_TRUNCATION),
     661             :                  errmsg("bit string too long for type bit varying(%d)",
     662             :                         atttypmod)));
     663             : 
     664           0 :     len = VARBITTOTALLEN(bitlen);
     665           0 :     result = (VarBit *) palloc(len);
     666           0 :     SET_VARSIZE(result, len);
     667           0 :     VARBITLEN(result) = bitlen;
     668             : 
     669           0 :     pq_copymsgbytes(buf, (char *) VARBITS(result), VARBITBYTES(result));
     670             : 
     671             :     /* Make sure last byte is correctly zero-padded */
     672           0 :     VARBIT_PAD(result);
     673             : 
     674           0 :     PG_RETURN_VARBIT_P(result);
     675             : }
     676             : 
     677             : /*
     678             :  *      varbit_send         - converts varbit to binary format
     679             :  */
     680             : Datum
     681           0 : varbit_send(PG_FUNCTION_ARGS)
     682             : {
     683           0 :     VarBit     *s = PG_GETARG_VARBIT_P(0);
     684             :     StringInfoData buf;
     685             : 
     686           0 :     pq_begintypsend(&buf);
     687           0 :     pq_sendint32(&buf, VARBITLEN(s));
     688           0 :     pq_sendbytes(&buf, (char *) VARBITS(s), VARBITBYTES(s));
     689           0 :     PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
     690             : }
     691             : 
     692             : /*
     693             :  * varbit_support()
     694             :  *
     695             :  * Planner support function for the varbit() length coercion function.
     696             :  *
     697             :  * Currently, the only interesting thing we can do is flatten calls that set
     698             :  * the new maximum length >= the previous maximum length.  We can ignore the
     699             :  * isExplicit argument, since that only affects truncation cases.
     700             :  */
     701             : Datum
     702         120 : varbit_support(PG_FUNCTION_ARGS)
     703             : {
     704         120 :     Node       *rawreq = (Node *) PG_GETARG_POINTER(0);
     705         120 :     Node       *ret = NULL;
     706             : 
     707         120 :     if (IsA(rawreq, SupportRequestSimplify))
     708             :     {
     709          60 :         SupportRequestSimplify *req = (SupportRequestSimplify *) rawreq;
     710          60 :         FuncExpr   *expr = req->fcall;
     711             :         Node       *typmod;
     712             : 
     713             :         Assert(list_length(expr->args) >= 2);
     714             : 
     715          60 :         typmod = (Node *) lsecond(expr->args);
     716             : 
     717          60 :         if (IsA(typmod, Const) && !((Const *) typmod)->constisnull)
     718             :         {
     719          60 :             Node       *source = (Node *) linitial(expr->args);
     720          60 :             int32       new_typmod = DatumGetInt32(((Const *) typmod)->constvalue);
     721          60 :             int32       old_max = exprTypmod(source);
     722          60 :             int32       new_max = new_typmod;
     723             : 
     724             :             /* Note: varbit() treats typmod 0 as invalid, so we do too */
     725          60 :             if (new_max <= 0 || (old_max > 0 && old_max <= new_max))
     726           0 :                 ret = relabel_to_typmod(source, new_typmod);
     727             :         }
     728             :     }
     729             : 
     730         120 :     PG_RETURN_POINTER(ret);
     731             : }
     732             : 
     733             : /*
     734             :  * varbit()
     735             :  * Converts a varbit() type to a specific internal length.
     736             :  * len is the maximum bitlength specified in the column definition.
     737             :  *
     738             :  * If doing implicit cast, raise error when source data is too long.
     739             :  * If doing explicit cast, silently truncate to max length.
     740             :  */
     741             : Datum
     742         978 : varbit(PG_FUNCTION_ARGS)
     743             : {
     744         978 :     VarBit     *arg = PG_GETARG_VARBIT_P(0);
     745         978 :     int32       len = PG_GETARG_INT32(1);
     746         978 :     bool        isExplicit = PG_GETARG_BOOL(2);
     747             :     VarBit     *result;
     748             :     int         rlen;
     749             : 
     750             :     /* No work if typmod is invalid or supplied data matches it already */
     751         978 :     if (len <= 0 || len >= VARBITLEN(arg))
     752         972 :         PG_RETURN_VARBIT_P(arg);
     753             : 
     754           6 :     if (!isExplicit)
     755           6 :         ereport(ERROR,
     756             :                 (errcode(ERRCODE_STRING_DATA_RIGHT_TRUNCATION),
     757             :                  errmsg("bit string too long for type bit varying(%d)",
     758             :                         len)));
     759             : 
     760           0 :     rlen = VARBITTOTALLEN(len);
     761           0 :     result = (VarBit *) palloc(rlen);
     762           0 :     SET_VARSIZE(result, rlen);
     763           0 :     VARBITLEN(result) = len;
     764             : 
     765           0 :     memcpy(VARBITS(result), VARBITS(arg), VARBITBYTES(result));
     766             : 
     767             :     /* Make sure last byte is correctly zero-padded */
     768           0 :     VARBIT_PAD(result);
     769             : 
     770           0 :     PG_RETURN_VARBIT_P(result);
     771             : }
     772             : 
     773             : Datum
     774         244 : varbittypmodin(PG_FUNCTION_ARGS)
     775             : {
     776         244 :     ArrayType  *ta = PG_GETARG_ARRAYTYPE_P(0);
     777             : 
     778         244 :     PG_RETURN_INT32(anybit_typmodin(ta, "varbit"));
     779             : }
     780             : 
     781             : Datum
     782         132 : varbittypmodout(PG_FUNCTION_ARGS)
     783             : {
     784         132 :     int32       typmod = PG_GETARG_INT32(0);
     785             : 
     786         132 :     PG_RETURN_CSTRING(anybit_typmodout(typmod));
     787             : }
     788             : 
     789             : 
     790             : /*
     791             :  * Comparison operators
     792             :  *
     793             :  * We only need one set of comparison operators for bitstrings, as the lengths
     794             :  * are stored in the same way for zero-padded and varying bit strings.
     795             :  *
     796             :  * Note that the standard is not unambiguous about the comparison between
     797             :  * zero-padded bit strings and varying bitstrings. If the same value is written
     798             :  * into a zero padded bitstring as into a varying bitstring, but the zero
     799             :  * padded bitstring has greater length, it will be bigger.
     800             :  *
     801             :  * Zeros from the beginning of a bitstring cannot simply be ignored, as they
     802             :  * may be part of a bit string and may be significant.
     803             :  *
     804             :  * Note: btree indexes need these routines not to leak memory; therefore,
     805             :  * be careful to free working copies of toasted datums.  Most places don't
     806             :  * need to be so careful.
     807             :  */
     808             : 
     809             : /*
     810             :  * bit_cmp
     811             :  *
     812             :  * Compares two bitstrings and returns <0, 0, >0 depending on whether the first
     813             :  * string is smaller, equal, or bigger than the second. All bits are considered
     814             :  * and additional zero bits may make one string smaller/larger than the other,
     815             :  * even if their zero-padded values would be the same.
     816             :  */
     817             : static int32
     818       37410 : bit_cmp(VarBit *arg1, VarBit *arg2)
     819             : {
     820             :     int         bitlen1,
     821             :                 bytelen1,
     822             :                 bitlen2,
     823             :                 bytelen2;
     824             :     int32       cmp;
     825             : 
     826       37410 :     bytelen1 = VARBITBYTES(arg1);
     827       37410 :     bytelen2 = VARBITBYTES(arg2);
     828             : 
     829       37410 :     cmp = memcmp(VARBITS(arg1), VARBITS(arg2), Min(bytelen1, bytelen2));
     830       37410 :     if (cmp == 0)
     831             :     {
     832        1112 :         bitlen1 = VARBITLEN(arg1);
     833        1112 :         bitlen2 = VARBITLEN(arg2);
     834        1112 :         if (bitlen1 != bitlen2)
     835          42 :             cmp = (bitlen1 < bitlen2) ? -1 : 1;
     836             :     }
     837       37410 :     return cmp;
     838             : }
     839             : 
     840             : Datum
     841        5240 : biteq(PG_FUNCTION_ARGS)
     842             : {
     843        5240 :     VarBit     *arg1 = PG_GETARG_VARBIT_P(0);
     844        5240 :     VarBit     *arg2 = PG_GETARG_VARBIT_P(1);
     845             :     bool        result;
     846             :     int         bitlen1,
     847             :                 bitlen2;
     848             : 
     849        5240 :     bitlen1 = VARBITLEN(arg1);
     850        5240 :     bitlen2 = VARBITLEN(arg2);
     851             : 
     852             :     /* fast path for different-length inputs */
     853        5240 :     if (bitlen1 != bitlen2)
     854        1502 :         result = false;
     855             :     else
     856        3738 :         result = (bit_cmp(arg1, arg2) == 0);
     857             : 
     858        5240 :     PG_FREE_IF_COPY(arg1, 0);
     859        5240 :     PG_FREE_IF_COPY(arg2, 1);
     860             : 
     861        5240 :     PG_RETURN_BOOL(result);
     862             : }
     863             : 
     864             : Datum
     865         944 : bitne(PG_FUNCTION_ARGS)
     866             : {
     867         944 :     VarBit     *arg1 = PG_GETARG_VARBIT_P(0);
     868         944 :     VarBit     *arg2 = PG_GETARG_VARBIT_P(1);
     869             :     bool        result;
     870             :     int         bitlen1,
     871             :                 bitlen2;
     872             : 
     873         944 :     bitlen1 = VARBITLEN(arg1);
     874         944 :     bitlen2 = VARBITLEN(arg2);
     875             : 
     876             :     /* fast path for different-length inputs */
     877         944 :     if (bitlen1 != bitlen2)
     878           0 :         result = true;
     879             :     else
     880         944 :         result = (bit_cmp(arg1, arg2) != 0);
     881             : 
     882         944 :     PG_FREE_IF_COPY(arg1, 0);
     883         944 :     PG_FREE_IF_COPY(arg2, 1);
     884             : 
     885         944 :     PG_RETURN_BOOL(result);
     886             : }
     887             : 
     888             : Datum
     889        7356 : bitlt(PG_FUNCTION_ARGS)
     890             : {
     891        7356 :     VarBit     *arg1 = PG_GETARG_VARBIT_P(0);
     892        7356 :     VarBit     *arg2 = PG_GETARG_VARBIT_P(1);
     893             :     bool        result;
     894             : 
     895        7356 :     result = (bit_cmp(arg1, arg2) < 0);
     896             : 
     897        7356 :     PG_FREE_IF_COPY(arg1, 0);
     898        7356 :     PG_FREE_IF_COPY(arg2, 1);
     899             : 
     900        7356 :     PG_RETURN_BOOL(result);
     901             : }
     902             : 
     903             : Datum
     904        8556 : bitle(PG_FUNCTION_ARGS)
     905             : {
     906        8556 :     VarBit     *arg1 = PG_GETARG_VARBIT_P(0);
     907        8556 :     VarBit     *arg2 = PG_GETARG_VARBIT_P(1);
     908             :     bool        result;
     909             : 
     910        8556 :     result = (bit_cmp(arg1, arg2) <= 0);
     911             : 
     912        8556 :     PG_FREE_IF_COPY(arg1, 0);
     913        8556 :     PG_FREE_IF_COPY(arg2, 1);
     914             : 
     915        8556 :     PG_RETURN_BOOL(result);
     916             : }
     917             : 
     918             : Datum
     919        7880 : bitgt(PG_FUNCTION_ARGS)
     920             : {
     921        7880 :     VarBit     *arg1 = PG_GETARG_VARBIT_P(0);
     922        7880 :     VarBit     *arg2 = PG_GETARG_VARBIT_P(1);
     923             :     bool        result;
     924             : 
     925        7880 :     result = (bit_cmp(arg1, arg2) > 0);
     926             : 
     927        7880 :     PG_FREE_IF_COPY(arg1, 0);
     928        7880 :     PG_FREE_IF_COPY(arg2, 1);
     929             : 
     930        7880 :     PG_RETURN_BOOL(result);
     931             : }
     932             : 
     933             : Datum
     934        8336 : bitge(PG_FUNCTION_ARGS)
     935             : {
     936        8336 :     VarBit     *arg1 = PG_GETARG_VARBIT_P(0);
     937        8336 :     VarBit     *arg2 = PG_GETARG_VARBIT_P(1);
     938             :     bool        result;
     939             : 
     940        8336 :     result = (bit_cmp(arg1, arg2) >= 0);
     941             : 
     942        8336 :     PG_FREE_IF_COPY(arg1, 0);
     943        8336 :     PG_FREE_IF_COPY(arg2, 1);
     944             : 
     945        8336 :     PG_RETURN_BOOL(result);
     946             : }
     947             : 
     948             : Datum
     949         600 : bitcmp(PG_FUNCTION_ARGS)
     950             : {
     951         600 :     VarBit     *arg1 = PG_GETARG_VARBIT_P(0);
     952         600 :     VarBit     *arg2 = PG_GETARG_VARBIT_P(1);
     953             :     int32       result;
     954             : 
     955         600 :     result = bit_cmp(arg1, arg2);
     956             : 
     957         600 :     PG_FREE_IF_COPY(arg1, 0);
     958         600 :     PG_FREE_IF_COPY(arg2, 1);
     959             : 
     960         600 :     PG_RETURN_INT32(result);
     961             : }
     962             : 
     963             : /*
     964             :  * bitcat
     965             :  * Concatenation of bit strings
     966             :  */
     967             : Datum
     968         162 : bitcat(PG_FUNCTION_ARGS)
     969             : {
     970         162 :     VarBit     *arg1 = PG_GETARG_VARBIT_P(0);
     971         162 :     VarBit     *arg2 = PG_GETARG_VARBIT_P(1);
     972             : 
     973         162 :     PG_RETURN_VARBIT_P(bit_catenate(arg1, arg2));
     974             : }
     975             : 
     976             : static VarBit *
     977         210 : bit_catenate(VarBit *arg1, VarBit *arg2)
     978             : {
     979             :     VarBit     *result;
     980             :     int         bitlen1,
     981             :                 bitlen2,
     982             :                 bytelen,
     983             :                 bit1pad,
     984             :                 bit2shift;
     985             :     bits8      *pr,
     986             :                *pa;
     987             : 
     988         210 :     bitlen1 = VARBITLEN(arg1);
     989         210 :     bitlen2 = VARBITLEN(arg2);
     990             : 
     991         210 :     if (bitlen1 > VARBITMAXLEN - bitlen2)
     992           0 :         ereport(ERROR,
     993             :                 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
     994             :                  errmsg("bit string length exceeds the maximum allowed (%d)",
     995             :                         VARBITMAXLEN)));
     996         210 :     bytelen = VARBITTOTALLEN(bitlen1 + bitlen2);
     997             : 
     998         210 :     result = (VarBit *) palloc(bytelen);
     999         210 :     SET_VARSIZE(result, bytelen);
    1000         210 :     VARBITLEN(result) = bitlen1 + bitlen2;
    1001             : 
    1002             :     /* Copy the first bitstring in */
    1003         210 :     memcpy(VARBITS(result), VARBITS(arg1), VARBITBYTES(arg1));
    1004             : 
    1005             :     /* Copy the second bit string */
    1006         210 :     bit1pad = VARBITPAD(arg1);
    1007         210 :     if (bit1pad == 0)
    1008             :     {
    1009          36 :         memcpy(VARBITS(result) + VARBITBYTES(arg1), VARBITS(arg2),
    1010          36 :                VARBITBYTES(arg2));
    1011             :     }
    1012         174 :     else if (bitlen2 > 0)
    1013             :     {
    1014             :         /* We need to shift all the bits to fit */
    1015         162 :         bit2shift = BITS_PER_BYTE - bit1pad;
    1016         162 :         pr = VARBITS(result) + VARBITBYTES(arg1) - 1;
    1017         378 :         for (pa = VARBITS(arg2); pa < VARBITEND(arg2); pa++)
    1018             :         {
    1019         216 :             *pr |= ((*pa >> bit2shift) & BITMASK);
    1020         216 :             pr++;
    1021         216 :             if (pr < VARBITEND(result))
    1022         138 :                 *pr = (*pa << bit1pad) & BITMASK;
    1023             :         }
    1024             :     }
    1025             : 
    1026             :     /* The pad bits should be already zero at this point */
    1027             : 
    1028         210 :     return result;
    1029             : }
    1030             : 
    1031             : /*
    1032             :  * bitsubstr
    1033             :  * retrieve a substring from the bit string.
    1034             :  * Note, s is 1-based.
    1035             :  * SQL draft 6.10 9)
    1036             :  */
    1037             : Datum
    1038         120 : bitsubstr(PG_FUNCTION_ARGS)
    1039             : {
    1040         120 :     PG_RETURN_VARBIT_P(bitsubstring(PG_GETARG_VARBIT_P(0),
    1041             :                                     PG_GETARG_INT32(1),
    1042             :                                     PG_GETARG_INT32(2),
    1043             :                                     false));
    1044             : }
    1045             : 
    1046             : Datum
    1047          42 : bitsubstr_no_len(PG_FUNCTION_ARGS)
    1048             : {
    1049          42 :     PG_RETURN_VARBIT_P(bitsubstring(PG_GETARG_VARBIT_P(0),
    1050             :                                     PG_GETARG_INT32(1),
    1051             :                                     -1, true));
    1052             : }
    1053             : 
    1054             : static VarBit *
    1055         210 : bitsubstring(VarBit *arg, int32 s, int32 l, bool length_not_specified)
    1056             : {
    1057             :     VarBit     *result;
    1058             :     int         bitlen,
    1059             :                 rbitlen,
    1060             :                 len,
    1061             :                 ishift,
    1062             :                 i;
    1063             :     int32       e,
    1064             :                 s1,
    1065             :                 e1;
    1066             :     bits8      *r,
    1067             :                *ps;
    1068             : 
    1069         210 :     bitlen = VARBITLEN(arg);
    1070         210 :     s1 = Max(s, 1);
    1071             :     /* If we do not have an upper bound, use end of string */
    1072         210 :     if (length_not_specified)
    1073             :     {
    1074          66 :         e1 = bitlen + 1;
    1075             :     }
    1076         144 :     else if (l < 0)
    1077             :     {
    1078             :         /* SQL99 says to throw an error for E < S, i.e., negative length */
    1079          12 :         ereport(ERROR,
    1080             :                 (errcode(ERRCODE_SUBSTRING_ERROR),
    1081             :                  errmsg("negative substring length not allowed")));
    1082             :         e1 = -1;                /* silence stupider compilers */
    1083             :     }
    1084         132 :     else if (pg_add_s32_overflow(s, l, &e))
    1085             :     {
    1086             :         /*
    1087             :          * L could be large enough for S + L to overflow, in which case the
    1088             :          * substring must run to end of string.
    1089             :          */
    1090          12 :         e1 = bitlen + 1;
    1091             :     }
    1092             :     else
    1093             :     {
    1094         120 :         e1 = Min(e, bitlen + 1);
    1095             :     }
    1096         198 :     if (s1 > bitlen || e1 <= s1)
    1097             :     {
    1098             :         /* Need to return a zero-length bitstring */
    1099          54 :         len = VARBITTOTALLEN(0);
    1100          54 :         result = (VarBit *) palloc(len);
    1101          54 :         SET_VARSIZE(result, len);
    1102          54 :         VARBITLEN(result) = 0;
    1103             :     }
    1104             :     else
    1105             :     {
    1106             :         /*
    1107             :          * OK, we've got a true substring starting at position s1-1 and ending
    1108             :          * at position e1-1
    1109             :          */
    1110         144 :         rbitlen = e1 - s1;
    1111         144 :         len = VARBITTOTALLEN(rbitlen);
    1112         144 :         result = (VarBit *) palloc(len);
    1113         144 :         SET_VARSIZE(result, len);
    1114         144 :         VARBITLEN(result) = rbitlen;
    1115         144 :         len -= VARHDRSZ + VARBITHDRSZ;
    1116             :         /* Are we copying from a byte boundary? */
    1117         144 :         if ((s1 - 1) % BITS_PER_BYTE == 0)
    1118             :         {
    1119             :             /* Yep, we are copying bytes */
    1120          42 :             memcpy(VARBITS(result), VARBITS(arg) + (s1 - 1) / BITS_PER_BYTE,
    1121             :                    len);
    1122             :         }
    1123             :         else
    1124             :         {
    1125             :             /* Figure out how much we need to shift the sequence by */
    1126         102 :             ishift = (s1 - 1) % BITS_PER_BYTE;
    1127         102 :             r = VARBITS(result);
    1128         102 :             ps = VARBITS(arg) + (s1 - 1) / BITS_PER_BYTE;
    1129         204 :             for (i = 0; i < len; i++)
    1130             :             {
    1131         102 :                 *r = (*ps << ishift) & BITMASK;
    1132         102 :                 if ((++ps) < VARBITEND(arg))
    1133          78 :                     *r |= *ps >> (BITS_PER_BYTE - ishift);
    1134         102 :                 r++;
    1135             :             }
    1136             :         }
    1137             : 
    1138             :         /* Make sure last byte is correctly zero-padded */
    1139         144 :         VARBIT_PAD(result);
    1140             :     }
    1141             : 
    1142         198 :     return result;
    1143             : }
    1144             : 
    1145             : /*
    1146             :  * bitoverlay
    1147             :  *  Replace specified substring of first string with second
    1148             :  *
    1149             :  * The SQL standard defines OVERLAY() in terms of substring and concatenation.
    1150             :  * This code is a direct implementation of what the standard says.
    1151             :  */
    1152             : Datum
    1153           6 : bitoverlay(PG_FUNCTION_ARGS)
    1154             : {
    1155           6 :     VarBit     *t1 = PG_GETARG_VARBIT_P(0);
    1156           6 :     VarBit     *t2 = PG_GETARG_VARBIT_P(1);
    1157           6 :     int         sp = PG_GETARG_INT32(2);    /* substring start position */
    1158           6 :     int         sl = PG_GETARG_INT32(3);    /* substring length */
    1159             : 
    1160           6 :     PG_RETURN_VARBIT_P(bit_overlay(t1, t2, sp, sl));
    1161             : }
    1162             : 
    1163             : Datum
    1164          18 : bitoverlay_no_len(PG_FUNCTION_ARGS)
    1165             : {
    1166          18 :     VarBit     *t1 = PG_GETARG_VARBIT_P(0);
    1167          18 :     VarBit     *t2 = PG_GETARG_VARBIT_P(1);
    1168          18 :     int         sp = PG_GETARG_INT32(2);    /* substring start position */
    1169             :     int         sl;
    1170             : 
    1171          18 :     sl = VARBITLEN(t2);         /* defaults to length(t2) */
    1172          18 :     PG_RETURN_VARBIT_P(bit_overlay(t1, t2, sp, sl));
    1173             : }
    1174             : 
    1175             : static VarBit *
    1176          24 : bit_overlay(VarBit *t1, VarBit *t2, int sp, int sl)
    1177             : {
    1178             :     VarBit     *result;
    1179             :     VarBit     *s1;
    1180             :     VarBit     *s2;
    1181             :     int         sp_pl_sl;
    1182             : 
    1183             :     /*
    1184             :      * Check for possible integer-overflow cases.  For negative sp, throw a
    1185             :      * "substring length" error because that's what should be expected
    1186             :      * according to the spec's definition of OVERLAY().
    1187             :      */
    1188          24 :     if (sp <= 0)
    1189           0 :         ereport(ERROR,
    1190             :                 (errcode(ERRCODE_SUBSTRING_ERROR),
    1191             :                  errmsg("negative substring length not allowed")));
    1192          24 :     if (pg_add_s32_overflow(sp, sl, &sp_pl_sl))
    1193           0 :         ereport(ERROR,
    1194             :                 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
    1195             :                  errmsg("integer out of range")));
    1196             : 
    1197          24 :     s1 = bitsubstring(t1, 1, sp - 1, false);
    1198          24 :     s2 = bitsubstring(t1, sp_pl_sl, -1, true);
    1199          24 :     result = bit_catenate(s1, t2);
    1200          24 :     result = bit_catenate(result, s2);
    1201             : 
    1202          24 :     return result;
    1203             : }
    1204             : 
    1205             : /*
    1206             :  * bit_count
    1207             :  *
    1208             :  * Returns the number of bits set in a bit string.
    1209             :  */
    1210             : Datum
    1211          12 : bit_bit_count(PG_FUNCTION_ARGS)
    1212             : {
    1213          12 :     VarBit     *arg = PG_GETARG_VARBIT_P(0);
    1214             : 
    1215          12 :     PG_RETURN_INT64(pg_popcount((char *) VARBITS(arg), VARBITBYTES(arg)));
    1216             : }
    1217             : 
    1218             : /*
    1219             :  * bitlength, bitoctetlength
    1220             :  * Return the length of a bit string
    1221             :  */
    1222             : Datum
    1223          42 : bitlength(PG_FUNCTION_ARGS)
    1224             : {
    1225          42 :     VarBit     *arg = PG_GETARG_VARBIT_P(0);
    1226             : 
    1227          42 :     PG_RETURN_INT32(VARBITLEN(arg));
    1228             : }
    1229             : 
    1230             : Datum
    1231           0 : bitoctetlength(PG_FUNCTION_ARGS)
    1232             : {
    1233           0 :     VarBit     *arg = PG_GETARG_VARBIT_P(0);
    1234             : 
    1235           0 :     PG_RETURN_INT32(VARBITBYTES(arg));
    1236             : }
    1237             : 
    1238             : /*
    1239             :  * bit_and
    1240             :  * perform a logical AND on two bit strings.
    1241             :  */
    1242             : Datum
    1243         138 : bit_and(PG_FUNCTION_ARGS)
    1244             : {
    1245         138 :     VarBit     *arg1 = PG_GETARG_VARBIT_P(0);
    1246         138 :     VarBit     *arg2 = PG_GETARG_VARBIT_P(1);
    1247             :     VarBit     *result;
    1248             :     int         len,
    1249             :                 bitlen1,
    1250             :                 bitlen2,
    1251             :                 i;
    1252             :     bits8      *p1,
    1253             :                *p2,
    1254             :                *r;
    1255             : 
    1256         138 :     bitlen1 = VARBITLEN(arg1);
    1257         138 :     bitlen2 = VARBITLEN(arg2);
    1258         138 :     if (bitlen1 != bitlen2)
    1259           6 :         ereport(ERROR,
    1260             :                 (errcode(ERRCODE_STRING_DATA_LENGTH_MISMATCH),
    1261             :                  errmsg("cannot AND bit strings of different sizes")));
    1262             : 
    1263         132 :     len = VARSIZE(arg1);
    1264         132 :     result = (VarBit *) palloc(len);
    1265         132 :     SET_VARSIZE(result, len);
    1266         132 :     VARBITLEN(result) = bitlen1;
    1267             : 
    1268         132 :     p1 = VARBITS(arg1);
    1269         132 :     p2 = VARBITS(arg2);
    1270         132 :     r = VARBITS(result);
    1271         354 :     for (i = 0; i < VARBITBYTES(arg1); i++)
    1272         222 :         *r++ = *p1++ & *p2++;
    1273             : 
    1274             :     /* Padding is not needed as & of 0 pads is 0 */
    1275             : 
    1276         132 :     PG_RETURN_VARBIT_P(result);
    1277             : }
    1278             : 
    1279             : /*
    1280             :  * bit_or
    1281             :  * perform a logical OR on two bit strings.
    1282             :  */
    1283             : Datum
    1284         168 : bit_or(PG_FUNCTION_ARGS)
    1285             : {
    1286         168 :     VarBit     *arg1 = PG_GETARG_VARBIT_P(0);
    1287         168 :     VarBit     *arg2 = PG_GETARG_VARBIT_P(1);
    1288             :     VarBit     *result;
    1289             :     int         len,
    1290             :                 bitlen1,
    1291             :                 bitlen2,
    1292             :                 i;
    1293             :     bits8      *p1,
    1294             :                *p2,
    1295             :                *r;
    1296             : 
    1297         168 :     bitlen1 = VARBITLEN(arg1);
    1298         168 :     bitlen2 = VARBITLEN(arg2);
    1299         168 :     if (bitlen1 != bitlen2)
    1300           6 :         ereport(ERROR,
    1301             :                 (errcode(ERRCODE_STRING_DATA_LENGTH_MISMATCH),
    1302             :                  errmsg("cannot OR bit strings of different sizes")));
    1303         162 :     len = VARSIZE(arg1);
    1304         162 :     result = (VarBit *) palloc(len);
    1305         162 :     SET_VARSIZE(result, len);
    1306         162 :     VARBITLEN(result) = bitlen1;
    1307             : 
    1308         162 :     p1 = VARBITS(arg1);
    1309         162 :     p2 = VARBITS(arg2);
    1310         162 :     r = VARBITS(result);
    1311         474 :     for (i = 0; i < VARBITBYTES(arg1); i++)
    1312         312 :         *r++ = *p1++ | *p2++;
    1313             : 
    1314             :     /* Padding is not needed as | of 0 pads is 0 */
    1315             : 
    1316         162 :     PG_RETURN_VARBIT_P(result);
    1317             : }
    1318             : 
    1319             : /*
    1320             :  * bitxor
    1321             :  * perform a logical XOR on two bit strings.
    1322             :  */
    1323             : Datum
    1324         138 : bitxor(PG_FUNCTION_ARGS)
    1325             : {
    1326         138 :     VarBit     *arg1 = PG_GETARG_VARBIT_P(0);
    1327         138 :     VarBit     *arg2 = PG_GETARG_VARBIT_P(1);
    1328             :     VarBit     *result;
    1329             :     int         len,
    1330             :                 bitlen1,
    1331             :                 bitlen2,
    1332             :                 i;
    1333             :     bits8      *p1,
    1334             :                *p2,
    1335             :                *r;
    1336             : 
    1337         138 :     bitlen1 = VARBITLEN(arg1);
    1338         138 :     bitlen2 = VARBITLEN(arg2);
    1339         138 :     if (bitlen1 != bitlen2)
    1340           6 :         ereport(ERROR,
    1341             :                 (errcode(ERRCODE_STRING_DATA_LENGTH_MISMATCH),
    1342             :                  errmsg("cannot XOR bit strings of different sizes")));
    1343             : 
    1344         132 :     len = VARSIZE(arg1);
    1345         132 :     result = (VarBit *) palloc(len);
    1346         132 :     SET_VARSIZE(result, len);
    1347         132 :     VARBITLEN(result) = bitlen1;
    1348             : 
    1349         132 :     p1 = VARBITS(arg1);
    1350         132 :     p2 = VARBITS(arg2);
    1351         132 :     r = VARBITS(result);
    1352         354 :     for (i = 0; i < VARBITBYTES(arg1); i++)
    1353         222 :         *r++ = *p1++ ^ *p2++;
    1354             : 
    1355             :     /* Padding is not needed as ^ of 0 pads is 0 */
    1356             : 
    1357         132 :     PG_RETURN_VARBIT_P(result);
    1358             : }
    1359             : 
    1360             : /*
    1361             :  * bitnot
    1362             :  * perform a logical NOT on a bit string.
    1363             :  */
    1364             : Datum
    1365         120 : bitnot(PG_FUNCTION_ARGS)
    1366             : {
    1367         120 :     VarBit     *arg = PG_GETARG_VARBIT_P(0);
    1368             :     VarBit     *result;
    1369             :     bits8      *p,
    1370             :                *r;
    1371             : 
    1372         120 :     result = (VarBit *) palloc(VARSIZE(arg));
    1373         120 :     SET_VARSIZE(result, VARSIZE(arg));
    1374         120 :     VARBITLEN(result) = VARBITLEN(arg);
    1375             : 
    1376         120 :     p = VARBITS(arg);
    1377         120 :     r = VARBITS(result);
    1378         330 :     for (; p < VARBITEND(arg); p++)
    1379         210 :         *r++ = ~*p;
    1380             : 
    1381             :     /* Must zero-pad the result, because extra bits are surely 1's here */
    1382         120 :     VARBIT_PAD_LAST(result, r);
    1383             : 
    1384         120 :     PG_RETURN_VARBIT_P(result);
    1385             : }
    1386             : 
    1387             : /*
    1388             :  * bitshiftleft
    1389             :  * do a left shift (i.e. towards the beginning of the string)
    1390             :  */
    1391             : Datum
    1392         696 : bitshiftleft(PG_FUNCTION_ARGS)
    1393             : {
    1394         696 :     VarBit     *arg = PG_GETARG_VARBIT_P(0);
    1395         696 :     int32       shft = PG_GETARG_INT32(1);
    1396             :     VarBit     *result;
    1397             :     int         byte_shift,
    1398             :                 ishift,
    1399             :                 len;
    1400             :     bits8      *p,
    1401             :                *r;
    1402             : 
    1403             :     /* Negative shift is a shift to the right */
    1404         696 :     if (shft < 0)
    1405             :     {
    1406             :         /* Prevent integer overflow in negation */
    1407           0 :         if (shft < -VARBITMAXLEN)
    1408           0 :             shft = -VARBITMAXLEN;
    1409           0 :         PG_RETURN_DATUM(DirectFunctionCall2(bitshiftright,
    1410             :                                             VarBitPGetDatum(arg),
    1411             :                                             Int32GetDatum(-shft)));
    1412             :     }
    1413             : 
    1414         696 :     result = (VarBit *) palloc(VARSIZE(arg));
    1415         696 :     SET_VARSIZE(result, VARSIZE(arg));
    1416         696 :     VARBITLEN(result) = VARBITLEN(arg);
    1417         696 :     r = VARBITS(result);
    1418             : 
    1419             :     /* If we shifted all the bits out, return an all-zero string */
    1420         696 :     if (shft >= VARBITLEN(arg))
    1421             :     {
    1422          24 :         MemSet(r, 0, VARBITBYTES(arg));
    1423          24 :         PG_RETURN_VARBIT_P(result);
    1424             :     }
    1425             : 
    1426         672 :     byte_shift = shft / BITS_PER_BYTE;
    1427         672 :     ishift = shft % BITS_PER_BYTE;
    1428         672 :     p = VARBITS(arg) + byte_shift;
    1429             : 
    1430         672 :     if (ishift == 0)
    1431             :     {
    1432             :         /* Special case: we can do a memcpy */
    1433         264 :         len = VARBITBYTES(arg) - byte_shift;
    1434         264 :         memcpy(r, p, len);
    1435         264 :         MemSet(r + len, 0, byte_shift);
    1436             :     }
    1437             :     else
    1438             :     {
    1439        1194 :         for (; p < VARBITEND(arg); r++)
    1440             :         {
    1441         786 :             *r = *p << ishift;
    1442         786 :             if ((++p) < VARBITEND(arg))
    1443         378 :                 *r |= *p >> (BITS_PER_BYTE - ishift);
    1444             :         }
    1445         408 :         for (; r < VARBITEND(result); r++)
    1446           0 :             *r = 0;
    1447             :     }
    1448             : 
    1449             :     /* The pad bits should be already zero at this point */
    1450             : 
    1451         672 :     PG_RETURN_VARBIT_P(result);
    1452             : }
    1453             : 
    1454             : /*
    1455             :  * bitshiftright
    1456             :  * do a right shift (i.e. towards the end of the string)
    1457             :  */
    1458             : Datum
    1459         876 : bitshiftright(PG_FUNCTION_ARGS)
    1460             : {
    1461         876 :     VarBit     *arg = PG_GETARG_VARBIT_P(0);
    1462         876 :     int32       shft = PG_GETARG_INT32(1);
    1463             :     VarBit     *result;
    1464             :     int         byte_shift,
    1465             :                 ishift,
    1466             :                 len;
    1467             :     bits8      *p,
    1468             :                *r;
    1469             : 
    1470             :     /* Negative shift is a shift to the left */
    1471         876 :     if (shft < 0)
    1472             :     {
    1473             :         /* Prevent integer overflow in negation */
    1474           0 :         if (shft < -VARBITMAXLEN)
    1475           0 :             shft = -VARBITMAXLEN;
    1476           0 :         PG_RETURN_DATUM(DirectFunctionCall2(bitshiftleft,
    1477             :                                             VarBitPGetDatum(arg),
    1478             :                                             Int32GetDatum(-shft)));
    1479             :     }
    1480             : 
    1481         876 :     result = (VarBit *) palloc(VARSIZE(arg));
    1482         876 :     SET_VARSIZE(result, VARSIZE(arg));
    1483         876 :     VARBITLEN(result) = VARBITLEN(arg);
    1484         876 :     r = VARBITS(result);
    1485             : 
    1486             :     /* If we shifted all the bits out, return an all-zero string */
    1487         876 :     if (shft >= VARBITLEN(arg))
    1488             :     {
    1489          24 :         MemSet(r, 0, VARBITBYTES(arg));
    1490          24 :         PG_RETURN_VARBIT_P(result);
    1491             :     }
    1492             : 
    1493         852 :     byte_shift = shft / BITS_PER_BYTE;
    1494         852 :     ishift = shft % BITS_PER_BYTE;
    1495         852 :     p = VARBITS(arg);
    1496             : 
    1497             :     /* Set the first part of the result to 0 */
    1498         852 :     MemSet(r, 0, byte_shift);
    1499         852 :     r += byte_shift;
    1500             : 
    1501         852 :     if (ishift == 0)
    1502             :     {
    1503             :         /* Special case: we can do a memcpy */
    1504         360 :         len = VARBITBYTES(arg) - byte_shift;
    1505         360 :         memcpy(r, p, len);
    1506         360 :         r += len;
    1507             :     }
    1508             :     else
    1509             :     {
    1510         492 :         if (r < VARBITEND(result))
    1511         492 :             *r = 0;             /* initialize first byte */
    1512        1428 :         for (; r < VARBITEND(result); p++)
    1513             :         {
    1514         936 :             *r |= *p >> ishift;
    1515         936 :             if ((++r) < VARBITEND(result))
    1516         444 :                 *r = (*p << (BITS_PER_BYTE - ishift)) & BITMASK;
    1517             :         }
    1518             :     }
    1519             : 
    1520             :     /* We may have shifted 1's into the pad bits, so fix that */
    1521         852 :     VARBIT_PAD_LAST(result, r);
    1522             : 
    1523         852 :     PG_RETURN_VARBIT_P(result);
    1524             : }
    1525             : 
    1526             : /*
    1527             :  * This is not defined in any standard. We retain the natural ordering of
    1528             :  * bits here, as it just seems more intuitive.
    1529             :  */
    1530             : Datum
    1531        2974 : bitfromint4(PG_FUNCTION_ARGS)
    1532             : {
    1533        2974 :     int32       a = PG_GETARG_INT32(0);
    1534        2974 :     int32       typmod = PG_GETARG_INT32(1);
    1535             :     VarBit     *result;
    1536             :     bits8      *r;
    1537             :     int         rlen;
    1538             :     int         destbitsleft,
    1539             :                 srcbitsleft;
    1540             : 
    1541        2974 :     if (typmod <= 0 || typmod > VARBITMAXLEN)
    1542           0 :         typmod = 1;             /* default bit length */
    1543             : 
    1544        2974 :     rlen = VARBITTOTALLEN(typmod);
    1545        2974 :     result = (VarBit *) palloc(rlen);
    1546        2974 :     SET_VARSIZE(result, rlen);
    1547        2974 :     VARBITLEN(result) = typmod;
    1548             : 
    1549        2974 :     r = VARBITS(result);
    1550        2974 :     destbitsleft = typmod;
    1551        2974 :     srcbitsleft = 32;
    1552             :     /* drop any input bits that don't fit */
    1553        2974 :     srcbitsleft = Min(srcbitsleft, destbitsleft);
    1554             :     /* sign-fill any excess bytes in output */
    1555        2974 :     while (destbitsleft >= srcbitsleft + 8)
    1556             :     {
    1557           0 :         *r++ = (bits8) ((a < 0) ? BITMASK : 0);
    1558           0 :         destbitsleft -= 8;
    1559             :     }
    1560             :     /* store first fractional byte */
    1561        2974 :     if (destbitsleft > srcbitsleft)
    1562             :     {
    1563           0 :         unsigned int val = (unsigned int) (a >> (destbitsleft - 8));
    1564             : 
    1565             :         /* Force sign-fill in case the compiler implements >> as zero-fill */
    1566           0 :         if (a < 0)
    1567           0 :             val |= ((unsigned int) -1) << (srcbitsleft + 8 - destbitsleft);
    1568           0 :         *r++ = (bits8) (val & BITMASK);
    1569           0 :         destbitsleft -= 8;
    1570             :     }
    1571             :     /* Now srcbitsleft and destbitsleft are the same, need not track both */
    1572             :     /* store whole bytes */
    1573       11570 :     while (destbitsleft >= 8)
    1574             :     {
    1575        8596 :         *r++ = (bits8) ((a >> (destbitsleft - 8)) & BITMASK);
    1576        8596 :         destbitsleft -= 8;
    1577             :     }
    1578             :     /* store last fractional byte */
    1579        2974 :     if (destbitsleft > 0)
    1580         660 :         *r = (bits8) ((a << (8 - destbitsleft)) & BITMASK);
    1581             : 
    1582        2974 :     PG_RETURN_VARBIT_P(result);
    1583             : }
    1584             : 
    1585             : Datum
    1586        1874 : bittoint4(PG_FUNCTION_ARGS)
    1587             : {
    1588        1874 :     VarBit     *arg = PG_GETARG_VARBIT_P(0);
    1589             :     uint32      result;
    1590             :     bits8      *r;
    1591             : 
    1592             :     /* Check that the bit string is not too long */
    1593        1874 :     if (VARBITLEN(arg) > sizeof(result) * BITS_PER_BYTE)
    1594           0 :         ereport(ERROR,
    1595             :                 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
    1596             :                  errmsg("integer out of range")));
    1597             : 
    1598        1874 :     result = 0;
    1599        9172 :     for (r = VARBITS(arg); r < VARBITEND(arg); r++)
    1600             :     {
    1601        7298 :         result <<= BITS_PER_BYTE;
    1602        7298 :         result |= *r;
    1603             :     }
    1604             :     /* Now shift the result to take account of the padding at the end */
    1605        1874 :     result >>= VARBITPAD(arg);
    1606             : 
    1607        1874 :     PG_RETURN_INT32(result);
    1608             : }
    1609             : 
    1610             : Datum
    1611        1660 : bitfromint8(PG_FUNCTION_ARGS)
    1612             : {
    1613        1660 :     int64       a = PG_GETARG_INT64(0);
    1614        1660 :     int32       typmod = PG_GETARG_INT32(1);
    1615             :     VarBit     *result;
    1616             :     bits8      *r;
    1617             :     int         rlen;
    1618             :     int         destbitsleft,
    1619             :                 srcbitsleft;
    1620             : 
    1621        1660 :     if (typmod <= 0 || typmod > VARBITMAXLEN)
    1622           0 :         typmod = 1;             /* default bit length */
    1623             : 
    1624        1660 :     rlen = VARBITTOTALLEN(typmod);
    1625        1660 :     result = (VarBit *) palloc(rlen);
    1626        1660 :     SET_VARSIZE(result, rlen);
    1627        1660 :     VARBITLEN(result) = typmod;
    1628             : 
    1629        1660 :     r = VARBITS(result);
    1630        1660 :     destbitsleft = typmod;
    1631        1660 :     srcbitsleft = 64;
    1632             :     /* drop any input bits that don't fit */
    1633        1660 :     srcbitsleft = Min(srcbitsleft, destbitsleft);
    1634             :     /* sign-fill any excess bytes in output */
    1635        1660 :     while (destbitsleft >= srcbitsleft + 8)
    1636             :     {
    1637           0 :         *r++ = (bits8) ((a < 0) ? BITMASK : 0);
    1638           0 :         destbitsleft -= 8;
    1639             :     }
    1640             :     /* store first fractional byte */
    1641        1660 :     if (destbitsleft > srcbitsleft)
    1642             :     {
    1643           0 :         unsigned int val = (unsigned int) (a >> (destbitsleft - 8));
    1644             : 
    1645             :         /* Force sign-fill in case the compiler implements >> as zero-fill */
    1646           0 :         if (a < 0)
    1647           0 :             val |= ((unsigned int) -1) << (srcbitsleft + 8 - destbitsleft);
    1648           0 :         *r++ = (bits8) (val & BITMASK);
    1649           0 :         destbitsleft -= 8;
    1650             :     }
    1651             :     /* Now srcbitsleft and destbitsleft are the same, need not track both */
    1652             :     /* store whole bytes */
    1653        8300 :     while (destbitsleft >= 8)
    1654             :     {
    1655        6640 :         *r++ = (bits8) ((a >> (destbitsleft - 8)) & BITMASK);
    1656        6640 :         destbitsleft -= 8;
    1657             :     }
    1658             :     /* store last fractional byte */
    1659        1660 :     if (destbitsleft > 0)
    1660           0 :         *r = (bits8) ((a << (8 - destbitsleft)) & BITMASK);
    1661             : 
    1662        1660 :     PG_RETURN_VARBIT_P(result);
    1663             : }
    1664             : 
    1665             : Datum
    1666        1394 : bittoint8(PG_FUNCTION_ARGS)
    1667             : {
    1668        1394 :     VarBit     *arg = PG_GETARG_VARBIT_P(0);
    1669             :     uint64      result;
    1670             :     bits8      *r;
    1671             : 
    1672             :     /* Check that the bit string is not too long */
    1673        1394 :     if (VARBITLEN(arg) > sizeof(result) * BITS_PER_BYTE)
    1674           0 :         ereport(ERROR,
    1675             :                 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
    1676             :                  errmsg("bigint out of range")));
    1677             : 
    1678        1394 :     result = 0;
    1679       12546 :     for (r = VARBITS(arg); r < VARBITEND(arg); r++)
    1680             :     {
    1681       11152 :         result <<= BITS_PER_BYTE;
    1682       11152 :         result |= *r;
    1683             :     }
    1684             :     /* Now shift the result to take account of the padding at the end */
    1685        1394 :     result >>= VARBITPAD(arg);
    1686             : 
    1687        1394 :     PG_RETURN_INT64(result);
    1688             : }
    1689             : 
    1690             : 
    1691             : /*
    1692             :  * Determines the position of S2 in the bitstring S1 (1-based string).
    1693             :  * If S2 does not appear in S1 this function returns 0.
    1694             :  * If S2 is of length 0 this function returns 1.
    1695             :  * Compatible in usage with POSITION() functions for other data types.
    1696             :  */
    1697             : Datum
    1698         612 : bitposition(PG_FUNCTION_ARGS)
    1699             : {
    1700         612 :     VarBit     *str = PG_GETARG_VARBIT_P(0);
    1701         612 :     VarBit     *substr = PG_GETARG_VARBIT_P(1);
    1702             :     int         substr_length,
    1703             :                 str_length,
    1704             :                 i,
    1705             :                 is;
    1706             :     bits8      *s,              /* pointer into substring */
    1707             :                *p;              /* pointer into str */
    1708             :     bits8       cmp,            /* shifted substring byte to compare */
    1709             :                 mask1,          /* mask for substring byte shifted right */
    1710             :                 mask2,          /* mask for substring byte shifted left */
    1711             :                 end_mask,       /* pad mask for last substring byte */
    1712             :                 str_mask;       /* pad mask for last string byte */
    1713             :     bool        is_match;
    1714             : 
    1715             :     /* Get the substring length */
    1716         612 :     substr_length = VARBITLEN(substr);
    1717         612 :     str_length = VARBITLEN(str);
    1718             : 
    1719             :     /* String has zero length or substring longer than string, return 0 */
    1720         612 :     if ((str_length == 0) || (substr_length > str_length))
    1721          24 :         PG_RETURN_INT32(0);
    1722             : 
    1723             :     /* zero-length substring means return 1 */
    1724         588 :     if (substr_length == 0)
    1725           6 :         PG_RETURN_INT32(1);
    1726             : 
    1727             :     /* Initialise the padding masks */
    1728         582 :     end_mask = BITMASK << VARBITPAD(substr);
    1729         582 :     str_mask = BITMASK << VARBITPAD(str);
    1730         936 :     for (i = 0; i < VARBITBYTES(str) - VARBITBYTES(substr) + 1; i++)
    1731             :     {
    1732        5136 :         for (is = 0; is < BITS_PER_BYTE; is++)
    1733             :         {
    1734        4782 :             is_match = true;
    1735        4782 :             p = VARBITS(str) + i;
    1736        4782 :             mask1 = BITMASK >> is;
    1737        4782 :             mask2 = ~mask1;
    1738        5340 :             for (s = VARBITS(substr);
    1739        5226 :                  is_match && s < VARBITEND(substr); s++)
    1740             :             {
    1741        4992 :                 cmp = *s >> is;
    1742        4992 :                 if (s == VARBITEND(substr) - 1)
    1743             :                 {
    1744        3774 :                     mask1 &= end_mask >> is;
    1745        3774 :                     if (p == VARBITEND(str) - 1)
    1746             :                     {
    1747             :                         /* Check that there is enough of str left */
    1748         990 :                         if (mask1 & ~str_mask)
    1749             :                         {
    1750          60 :                             is_match = false;
    1751          60 :                             break;
    1752             :                         }
    1753         930 :                         mask1 &= str_mask;
    1754             :                     }
    1755             :                 }
    1756        4932 :                 is_match = ((cmp ^ *p) & mask1) == 0;
    1757        4932 :                 if (!is_match)
    1758        4050 :                     break;
    1759             :                 /* Move on to the next byte */
    1760         882 :                 p++;
    1761         882 :                 if (p == VARBITEND(str))
    1762             :                 {
    1763         324 :                     mask2 = end_mask << (BITS_PER_BYTE - is);
    1764         324 :                     is_match = mask2 == 0;
    1765             : #if 0
    1766             :                     elog(DEBUG4, "S. %d %d em=%2x sm=%2x r=%d",
    1767             :                          i, is, end_mask, mask2, is_match);
    1768             : #endif
    1769         324 :                     break;
    1770             :                 }
    1771         558 :                 cmp = *s << (BITS_PER_BYTE - is);
    1772         558 :                 if (s == VARBITEND(substr) - 1)
    1773             :                 {
    1774         234 :                     mask2 &= end_mask << (BITS_PER_BYTE - is);
    1775         234 :                     if (p == VARBITEND(str) - 1)
    1776             :                     {
    1777         228 :                         if (mask2 & ~str_mask)
    1778             :                         {
    1779           0 :                             is_match = false;
    1780           0 :                             break;
    1781             :                         }
    1782         228 :                         mask2 &= str_mask;
    1783             :                     }
    1784             :                 }
    1785         558 :                 is_match = ((cmp ^ *p) & mask2) == 0;
    1786             :             }
    1787             :             /* Have we found a match? */
    1788        4782 :             if (is_match)
    1789         486 :                 PG_RETURN_INT32(i * BITS_PER_BYTE + is + 1);
    1790             :         }
    1791             :     }
    1792          96 :     PG_RETURN_INT32(0);
    1793             : }
    1794             : 
    1795             : 
    1796             : /*
    1797             :  * bitsetbit
    1798             :  *
    1799             :  * Given an instance of type 'bit' creates a new one with
    1800             :  * the Nth bit set to the given value.
    1801             :  *
    1802             :  * The bit location is specified left-to-right in a zero-based fashion
    1803             :  * consistent with the other get_bit and set_bit functions, but
    1804             :  * inconsistent with the standard substring, position, overlay functions
    1805             :  */
    1806             : Datum
    1807          12 : bitsetbit(PG_FUNCTION_ARGS)
    1808             : {
    1809          12 :     VarBit     *arg1 = PG_GETARG_VARBIT_P(0);
    1810          12 :     int32       n = PG_GETARG_INT32(1);
    1811          12 :     int32       newBit = PG_GETARG_INT32(2);
    1812             :     VarBit     *result;
    1813             :     int         len,
    1814             :                 bitlen;
    1815             :     bits8      *r,
    1816             :                *p;
    1817             :     int         byteNo,
    1818             :                 bitNo;
    1819             : 
    1820          12 :     bitlen = VARBITLEN(arg1);
    1821          12 :     if (n < 0 || n >= bitlen)
    1822           6 :         ereport(ERROR,
    1823             :                 (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
    1824             :                  errmsg("bit index %d out of valid range (0..%d)",
    1825             :                         n, bitlen - 1)));
    1826             : 
    1827             :     /*
    1828             :      * sanity check!
    1829             :      */
    1830           6 :     if (newBit != 0 && newBit != 1)
    1831           0 :         ereport(ERROR,
    1832             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    1833             :                  errmsg("new bit must be 0 or 1")));
    1834             : 
    1835           6 :     len = VARSIZE(arg1);
    1836           6 :     result = (VarBit *) palloc(len);
    1837           6 :     SET_VARSIZE(result, len);
    1838           6 :     VARBITLEN(result) = bitlen;
    1839             : 
    1840           6 :     p = VARBITS(arg1);
    1841           6 :     r = VARBITS(result);
    1842             : 
    1843           6 :     memcpy(r, p, VARBITBYTES(arg1));
    1844             : 
    1845           6 :     byteNo = n / BITS_PER_BYTE;
    1846           6 :     bitNo = BITS_PER_BYTE - 1 - (n % BITS_PER_BYTE);
    1847             : 
    1848             :     /*
    1849             :      * Update the byte.
    1850             :      */
    1851           6 :     if (newBit == 0)
    1852           0 :         r[byteNo] &= (~(1 << bitNo));
    1853             :     else
    1854           6 :         r[byteNo] |= (1 << bitNo);
    1855             : 
    1856           6 :     PG_RETURN_VARBIT_P(result);
    1857             : }
    1858             : 
    1859             : /*
    1860             :  * bitgetbit
    1861             :  *
    1862             :  * returns the value of the Nth bit of a bit array (0 or 1).
    1863             :  *
    1864             :  * The bit location is specified left-to-right in a zero-based fashion
    1865             :  * consistent with the other get_bit and set_bit functions, but
    1866             :  * inconsistent with the standard substring, position, overlay functions
    1867             :  */
    1868             : Datum
    1869           6 : bitgetbit(PG_FUNCTION_ARGS)
    1870             : {
    1871           6 :     VarBit     *arg1 = PG_GETARG_VARBIT_P(0);
    1872           6 :     int32       n = PG_GETARG_INT32(1);
    1873             :     int         bitlen;
    1874             :     bits8      *p;
    1875             :     int         byteNo,
    1876             :                 bitNo;
    1877             : 
    1878           6 :     bitlen = VARBITLEN(arg1);
    1879           6 :     if (n < 0 || n >= bitlen)
    1880           0 :         ereport(ERROR,
    1881             :                 (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
    1882             :                  errmsg("bit index %d out of valid range (0..%d)",
    1883             :                         n, bitlen - 1)));
    1884             : 
    1885           6 :     p = VARBITS(arg1);
    1886             : 
    1887           6 :     byteNo = n / BITS_PER_BYTE;
    1888           6 :     bitNo = BITS_PER_BYTE - 1 - (n % BITS_PER_BYTE);
    1889             : 
    1890           6 :     if (p[byteNo] & (1 << bitNo))
    1891           6 :         PG_RETURN_INT32(1);
    1892             :     else
    1893           0 :         PG_RETURN_INT32(0);
    1894             : }

Generated by: LCOV version 1.14