Tom Lane wrote:
>
> I have made a first cut at completing integration of Adriaan Joubert's
> BIT code into the backend. There are a couple little things left to
> do (for example, scalarltsel doesn't know what to do with BIT values)
> as well as some not-so-little things:
>
> 1. SQL92 mentions a bitwise position function, which we do not have.
Sorry, I have been very busy, so only got down to implementing a
position function last night. It's a bit messy (lots of masks and
bit-twiddling), but I feel fairly happy now that it is doing the right
thing. I tested it with my own loadable types, as the integration into
postgres proper stumped my somewhat. The next oid up for a bit function
is in use already. Anyway, the patches are attached, and I'm hoping that
some friendly sole will integrate the new position function into
postgres proper.
> 2. We don't handle <bit string> and <hex string> literals correctly;
> the scanner converts them into integers which seems quite at variance
> with the spec's semantics.
This is still a problem that needs to be fixed. Also, it the parser did
not seem to be too happy about the 'position' syntax, but I may have it
wrong of course. I don;t know how to attach the position function to a
piece of syntax such as (position <substr> in <field>) either, so I'm
hoping that somebody can pick this up.
Also, i have started putting together a file for regression testing. I
noticed that the substring syntax does not seem to work:
SELECT SUBSTRING(b FROM 2 FOR 4)
FROM ZPBIT_TABLE;
gives:
ERROR: Function 'substr(bit, int4, int4)' does not exist
Unable to identify a function that satisfies the given argument
types
You may need to add explicit typecasts
and similar for a varying bit argument.
If somebody with better knowledge of postgres could do the integration,
please, I will finish off a regression test.
Thanks!
Adriaan
*** src/backend/utils/adt/varbit.c.old Sun Oct 29 11:05:11 2000
--- src/backend/utils/adt/varbit.c Mon Oct 30 04:58:35 2000
***************
*** 1053,1060 ****
/* Negative shift is a shift to the left */
if (shft < 0)
PG_RETURN_DATUM(DirectFunctionCall2(bitshiftleft,
!
VarBitPGetDatum(arg),
!
Int32GetDatum(-shft)));
result = (VarBit *) palloc(VARSIZE(arg));
VARATT_SIZEP(result) = VARSIZE(arg);
--- 1053,1060 ----
/* Negative shift is a shift to the left */
if (shft < 0)
PG_RETURN_DATUM(DirectFunctionCall2(bitshiftleft,
! VarBitPGetDatum(arg),
! Int32GetDatum(-shft)));
result = (VarBit *) palloc(VARSIZE(arg));
VARATT_SIZEP(result) = VARSIZE(arg);
***************
*** 1145,1148 ****
--- 1145,1242 ----
result >>= VARBITPAD(arg);
PG_RETURN_INT32(result);
+ }
+
+ /* Determines the position of S1 in the bitstring S2 (1-based string).
+ * If S1 does not appear in S2 this function returns 0.
+ * If S1 is of length 0 this function returns 1.
+ */
+ Datum
+ bitposition(PG_FUNCTION_ARGS)
+ {
+ VarBit *substr = PG_GETARG_VARBIT_P(0);
+ VarBit *arg = PG_GETARG_VARBIT_P(1);
+ int substr_length,
+ arg_length,
+ i,
+ is;
+ bits8 *s, /* pointer into substring */
+ *p; /* pointer into arg */
+ bits8 cmp, /* shifted substring byte to compare
+*/
+ mask1, /* mask for substring byte shifted
+right */
+ mask2, /* mask for substring byte shifted
+left */
+ end_mask, /* pad mask for last substring byte */
+ arg_mask; /* pad mask for last argument
+byte */
+ bool is_match;
+
+ /* Get the substring length */
+ substr_length = VARBITLEN(substr);
+ arg_length = VARBITLEN(arg);
+
+ /* Argument has 0 length or substring longer than argument, return 0 */
+ if (arg_length == 0 || substr_length > arg_length)
+ PG_RETURN_INT32(0);
+
+ /* 0-length means return 1 */
+ if (substr_length == 0)
+ PG_RETURN_INT32(1);
+
+ /* Initialise the padding masks */
+ end_mask = BITMASK << VARBITPAD(substr);
+ arg_mask = BITMASK << VARBITPAD(arg);
+ for (i = 0; i < VARBITBYTES(arg) - VARBITBYTES(substr) + 1; i++)
+ {
+ for (is = 0; is < BITS_PER_BYTE; is++) {
+ is_match = true;
+ p = VARBITS(arg) + i;
+ mask1 = BITMASK >> is;
+ mask2 = ~mask1;
+ for (s = VARBITS(substr);
+ is_match && s < VARBITEND(substr); s++)
+ {
+ cmp = *s >> is;
+ if (s == VARBITEND(substr) - 1)
+ {
+ mask1 &= end_mask >> is;
+ if (p == VARBITEND(arg) - 1) {
+ /* Check that there is enough of arg
+left */
+ if (mask1 & ~arg_mask) {
+ is_match = false;
+ break;
+ }
+ mask1 &= arg_mask;
+ }
+ }
+ is_match = ((cmp ^ *p) & mask1) == 0;
+ if (!is_match)
+ break;
+ // Move on to the next byte
+ p++;
+ if (p == VARBITEND(arg)) {
+ mask2 = end_mask << (BITS_PER_BYTE - is);
+ is_match = mask2 == 0;
+ elog(NOTICE,"S. %d %d em=%2x sm=%2x r=%d",
+ i,is,end_mask,mask2,is_match);
+ break;
+ }
+ cmp = *s << (BITS_PER_BYTE - is);
+ if (s == VARBITEND(substr) - 1)
+ {
+ mask2 &= end_mask << (BITS_PER_BYTE - is);
+ if (p == VARBITEND(arg) - 1) {
+ if (mask2 & ~arg_mask) {
+ is_match = false;
+ break;
+ }
+ mask2 &= arg_mask;
+ }
+ }
+ is_match = ((cmp ^ *p) & mask2) == 0;
+ }
+ /* Have we found a match */
+ if (is_match)
+ PG_RETURN_INT32(i*BITS_PER_BYTE + is + 1);
+ }
+ }
+ PG_RETURN_INT32(0);
}
*** src/include/utils/varbit.h.old Sun Oct 29 11:04:58 2000
--- src/include/utils/varbit.h Sun Oct 29 11:05:58 2000
***************
*** 87,91 ****
--- 87,92 ----
extern Datum bitoctetlength(PG_FUNCTION_ARGS);
extern Datum bitfromint4(PG_FUNCTION_ARGS);
extern Datum bittoint4(PG_FUNCTION_ARGS);
+ extern Datum bitposition(PG_FUNCTION_ARGS);
#endif
