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