Hi,

    here is an updated version of the bit type with a bugfix and all the necessa
ry
SQL functions defined. This should replace what is currently in contrib. I'd
appreciate any comments on what is there.

Kind regards,

Adriaan

9 files changed, 423 insertions, 132 deletions

diff --git a/contrib/bit/Makefile b/contrib/bit/Makefile
index 9603cba27f8..96e751d0c18 100644
--- a/contrib/bit/Makefile
+++ b/contrib/bit/Makefile
@@ -1,10 +1,46 @@
-CFLAGS = -g
+ifndef PGDIR
+PGDIR= ../..
+PGDIR=/data/build/postgresql-7.0beta3
+endif
 
-varbit: vartest.o varbit.o
-	$(CC) $(CFLAGS) -o $@ $^
+SRCDIR= $(PGDIR)/src
 
-varbit.o: varbit.c varbit.h
-vartest.o: vartest.c varbit.h
+include $(SRCDIR)/Makefile.global
+
+TARGETS= varbit.sql varbit$(DLSUFFIX)
+# vartest
+SOURCE= varbit.c varbit_glue.c
+OBJ= $(SOURCE:.c=.o)
+CFLAGS += -g
+
+all:	$(TARGETS)
+
+varbit$(DLSUFFIX):	$(OBJ)
+	$(CC) $(CFLAGS) -shared -o varbit$(DLSUFFIX) $(SOURCE) $(CLIBS)
+
+vartest: varbit.o vartest.o
+	$(CC) -o $@ varbit.o vartest.o
+
+install:
+	$(MAKE) all
+	cp -p varbit$(DLSUFFIX) $(LIBDIR)/contrib
+	chmod 555 $(LIBDIR)/contrib/varbit$(DLSUFFIX)
+
+%.sql: %.source
+	echo $(SRCDIR)
+	if [ -z "$$USER" ]; then USER=$$LOGNAME; fi; \
+	if [ -z "$$USER" ]; then USER=`whoami`; fi; \
+	if [ -z "$$USER" ]; then echo 'Cannot deduce $$USER.'; exit 1; fi; \
+	rm -f $@; \
+	C=`pwd`; \
+	O=$C; \
+	if [ -d ${LIBDIR}/contrib ]; then O=${LIBDIR}/contrib; else \
+	echo "contrib directory does not exist."; fi; \
+	sed -e "s:_CWD_:$$C:g" \
+	    -e "s:_OBJWD_:$$O:g" \
+	    -e "s:_DLSUFFIX_:$(DLSUFFIX):g" \
+	    -e "s/_USER_/$$USER/g" < $< > $@
+
+clean: 
+	rm -f $(TARGETS) varbit.o
 
-clean:
-	rm -f *.o varbit
diff --git a/contrib/bit/README b/contrib/bit/README
index b2ddb904b30..18a1fe1820b 100644
--- a/contrib/bit/README
+++ b/contrib/bit/README
@@ -7,9 +7,6 @@ make this code as independent as possible of the byte length, but it
 is quite possible that there may be problems on machines that don't
 have 8 bits/byte (are there still any around?).
 
-In the input routines I have assumed that the parser eats the quotes
-in B'...' or X'...'.
-
 The SQL standard only defines comparison, SUBSTR and concatenation
 operators, and these have been implemented. In addition all logical
 operators have been implemented, i.e. ~,|,&,^,<< and >>. This is
diff --git a/contrib/bit/varbit.c b/contrib/bit/varbit.c
index 257f9766fd6..2a677ec6040 100644
--- a/contrib/bit/varbit.c
+++ b/contrib/bit/varbit.c
@@ -4,18 +4,14 @@
  *	  Functions for the built-in type bit() and varying bit().
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/contrib/bit/Attic/varbit.c,v 1.1 1999/11/29 22:34:36 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/contrib/bit/Attic/varbit.c,v 1.2 2000/04/03 20:56:40 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
-#include "postgres.h"
 #include "varbit.h"
-/*
 #include "access/htup.h"
-#include "catalog/pg_type.h"
-#include "utils/builtins.h"
-*/
-
+/*#include "catalog/pg_type.h" */
+/*#include "utils/builtins.h" */
 
 
 /* 
@@ -43,22 +39,22 @@
  *	  (XXX dummy is here because we pass typelem as the second argument 
  *        for array_in. copied this, no idea what it means??)
  */
-char *
+bits8 *
 zpbitin(char *s, int dummy,  int32 atttypmod)
 {
-  char *result, 
-    *sp;		/* pointer into the character string  */
+  bits8 *result;	/* the bits string that was read in   */ 
+  char  *sp;		/* pointer into the character string  */
   bits8 *r;
   int len,		/* Length of the whole data structure */
     bitlen,		/* Number of bits in the bit string   */
     slen;		/* Length of the input string         */
-  int bit_not_hex;      /* 0 = hex string  1=bit string       */
-  int i, bc, ipad;
-  bits8 x, y;
+  int bit_not_hex = 0;  /* 0 = hex string  1=bit string       */
+  int bc, ipad;
+  bits8 x = 0;
 
 
   if (s == NULL)
-    return NULL;
+    return (bits8 *) NULL;
 
   /* Check that the first character is a b or an x */
   if (s[0]=='b' || s[0]=='B') 
@@ -82,7 +78,8 @@ zpbitin(char *s, int dummy,  int32 atttypmod)
   if (atttypmod == -1)
     atttypmod = bitlen;
   else
-    if (bitlen>atttypmod && bit_not_hex || bitlen>atttypmod+3 && !bit_not_hex)
+    if ((bitlen>atttypmod && bit_not_hex) || 
+	(bitlen>atttypmod+3 && !bit_not_hex))
 	  elog(ERROR, "zpbitin: bit string of size %d cannot be written into bits(%d)",
 	       bitlen,atttypmod);
 
@@ -90,10 +87,10 @@ zpbitin(char *s, int dummy,  int32 atttypmod)
   len = VARBITDATALEN(atttypmod);
 
   if (len > MaxAttrSize)
-    elog(ERROR, "zpbitin: length of bit() must be less than %d",
+    elog(ERROR, "zpbitin: length of bit() must be less than %ld",
 	 (MaxAttrSize-VARHDRSZ-VARBITHDRSZ)*BITSPERBYTE);
 
-  result = (char *) palloc(len);
+  result = (bits8 *) palloc(len);
   /* set to 0 so that *r is always initialised and strin is zero-padded */
   memset(result, 0, len);
   VARSIZE(result) = len;
@@ -103,7 +100,7 @@ zpbitin(char *s, int dummy,  int32 atttypmod)
      significant byte first. s points to the byte before the beginning
      of the bitstring */
   sp = s+1;
-  r = (bits8 *) VARBITS(result);
+  r = VARBITS(result);
   if (bit_not_hex) 
     {
       /* Parse the bit representation of the string */
@@ -166,10 +163,10 @@ zpbitin(char *s, int dummy,  int32 atttypmod)
  *    for long strings
  */
 char *
-zpbitout(char *s)
+zpbitout(bits8 *s)
 {
   char	   *result, *r;
-  VarBit   sp;
+  bits8    *sp;
   int	   i, len, bitlen;
   
   if (s == NULL)
@@ -183,7 +180,7 @@ zpbitout(char *s)
       bitlen = VARBITLEN(s);
       len = bitlen/4 + (bitlen%4>0 ? 1 : 0);
       result = (char *) palloc(len + 4);
-      sp = (bits8 *) VARBITS(s);
+      sp = VARBITS(s);
       r = result;
       *r++ = 'X';
       *r++ = '\'';
@@ -206,10 +203,10 @@ zpbitout(char *s)
  *    Prints the string a bits
  */
 char *
-zpbitsout(char *s)
+zpbitsout(bits8 *s)
 {
   char	   *result, *r;
-  VarBit   sp;
+  bits8    *sp;
   bits8    x;
   int	   i, k, len;
   
@@ -223,7 +220,7 @@ zpbitsout(char *s)
     {
       len = VARBITLEN(s);
       result = (char *) palloc(len + 4);
-      sp = (bits8 *) VARBITS(s);
+      sp = VARBITS(s);
       r = result;
       *r++ = 'B';
       *r++ = '\'';
@@ -252,22 +249,22 @@ zpbitsout(char *s)
  * varbitin -
  *	  converts a string to the internal representation of a bitstring.
 */
-char *
+bits8 *
 varbitin(char *s, int dummy,  int32 atttypmod)
 {
-  char *result, 
-    *sp;		/* pointer into the character string  */
+  bits8 *result;	/* The resulting bit string           */
+  char *sp;		/* pointer into the character string  */
   bits8 *r;
   int len,		/* Length of the whole data structure */
     bitlen,		/* Number of bits in the bit string   */
     slen;		/* Length of the input string         */
-  int bit_not_hex;
-  int i, bc, ipad;
-  bits8 x, y;
+  int bit_not_hex = 0;
+  int bc, ipad;
+  bits8 x = 0;
 
 
   if (s == NULL)
-    return NULL;
+    return (bits8 *) NULL;
 
   /* Check that the first character is a b or an x */
   if (s[0]=='b' || s[0]=='B') 
@@ -289,7 +286,8 @@ varbitin(char *s, int dummy,  int32 atttypmod)
      reading a hex string and not by more than 3 bits, as a hex string gives 
      and accurate length upto 4 bits */
   if (atttypmod > -1)
-    if (bitlen>atttypmod && bit_not_hex || bitlen>atttypmod+3 && !bit_not_hex)
+    if ((bitlen>atttypmod && bit_not_hex) || 
+	(bitlen>atttypmod+3 && !bit_not_hex))
 	  elog(ERROR, "varbitin: bit string of size %d cannot be written into varying bits(%d)",
 	       bitlen,atttypmod);
 
@@ -297,10 +295,10 @@ varbitin(char *s, int dummy,  int32 atttypmod)
   len = VARBITDATALEN(bitlen);
 
   if (len > MaxAttrSize)
-    elog(ERROR, "varbitin: length of bit() must be less than %d",
+    elog(ERROR, "varbitin: length of bit() must be less than %ld",
 	 (MaxAttrSize-VARHDRSZ-VARBITHDRSZ)*BITSPERBYTE);
 
-  result = (char *) palloc(len);
+  result = (bits8 *) palloc(len);
   /* set to 0 so that *r is always initialised and strin is zero-padded */
   memset(result, 0, len);
   VARSIZE(result) = len;
@@ -310,7 +308,7 @@ varbitin(char *s, int dummy,  int32 atttypmod)
      significant byte first. s points to the byte before the beginning
      of the bitstring */
   sp = s + 1;
-  r = (VarBit) VARBITS(result);
+  r = VARBITS(result);
   if (bit_not_hex) 
     {
       /* Parse the bit representation of the string */
@@ -383,11 +381,10 @@ varbitin(char *s, int dummy,  int32 atttypmod)
  */
 
 bool
-biteq (char *arg1, char *arg2)
+biteq (bits8 *arg1, bits8 *arg2)
 {
   int bitlen1,
     bitlen2;
-  bits8 *p1, *p2;
 
   if (!PointerIsValid(arg1) || !PointerIsValid(arg2))
     return (bool) 0;
@@ -402,11 +399,10 @@ biteq (char *arg1, char *arg2)
 }
 
 bool
-bitne (char *arg1, char *arg2)
+bitne (bits8 *arg1, bits8 *arg2)
 {
   int bitlen1,
     bitlen2;
-  bits8 *p1, *p2;
 
   if (!PointerIsValid(arg1) || !PointerIsValid(arg2))
     return (bool) 0;
@@ -429,11 +425,10 @@ bitne (char *arg1, char *arg2)
  *   Anything is equal to undefined.
  */
 int 
-bitcmp (char *arg1, char *arg2)
+bitcmp (bits8 *arg1, bits8 *arg2)
 {
   int bitlen1, bytelen1,
     bitlen2, bytelen2;
-  bits8 *p1, *p2;
   int cmp;
 
   if (!PointerIsValid(arg1) || !PointerIsValid(arg2))
@@ -452,25 +447,25 @@ bitcmp (char *arg1, char *arg2)
 }
 
 bool
-bitlt (char *arg1, char *arg2)
+bitlt (bits8 *arg1, bits8 *arg2)
 {
   return (bool) (bitcmp(arg1,arg2) == -1);
 }
 
 bool
-bitle (char *arg1, char *arg2)
+bitle (bits8 *arg1, bits8 *arg2)
 {
   return (bool) (bitcmp(arg1,arg2) <= 0);
 }
 
 bool
-bitge (char *arg1, char *arg2)
+bitge (bits8 *arg1, bits8 *arg2)
 {
   return (bool) (bitcmp(arg1,arg2) >= 0);
 }
 
 bool
-bitgt (char *arg1, char *arg2)
+bitgt (bits8 *arg1, bits8 *arg2)
 {
   return (bool) (bitcmp(arg1,arg2) == 1);
 }
@@ -478,11 +473,11 @@ bitgt (char *arg1, char *arg2)
 /* bitcat
  * Concatenation of bit strings
  */
-char *
-bitcat (char *arg1, char *arg2)
+bits8 *
+bitcat (bits8 *arg1, bits8 *arg2)
 {
   int bitlen1, bitlen2, bytelen, bit1pad, bit2shift;
-  char *result;
+  bits8 *result;
   bits8 *pr, *pa;
 
   if (!PointerIsValid(arg1) || !PointerIsValid(arg2))
@@ -493,7 +488,7 @@ bitcat (char *arg1, char *arg2)
 
   bytelen = VARBITDATALEN(bitlen1+bitlen2);
   
-  result = (char *) palloc(bytelen*sizeof(bits8));
+  result = (bits8 *) palloc(bytelen*sizeof(bits8));
   VARSIZE(result) = bytelen;
   VARBITLEN(result) = bitlen1+bitlen2;
   printf("%d %d %d \n",VARBITBYTES(arg1),VARBITLEN(arg1),VARBITPAD(arg1));
@@ -510,10 +505,10 @@ bitcat (char *arg1, char *arg2)
     {
       /* We need to shift all the results to fit */
       bit2shift = BITSPERBYTE - bit1pad;
-      pa = (VarBit) VARBITS(arg2);
-      pr = (VarBit) VARBITS(result)+VARBITBYTES(arg1)-1;
+      pa = VARBITS(arg2);
+      pr = VARBITS(result)+VARBITBYTES(arg1)-1;
       for ( ; pa < VARBITEND(arg2); pa++) {
-	*pr = *pr | ((*pa >> bit2shift) & BITMASK);
+	*pr |= ((*pa >> bit2shift) & BITMASK);
 	pr++;
 	if (pr < VARBITEND(result))
 	  *pr = (*pa << bit1pad) & BITMASK;
@@ -528,17 +523,17 @@ bitcat (char *arg1, char *arg2)
  * Note, s is 1-based.
  * SQL draft 6.10 9)
  */
-char * 
-bitsubstr (char *arg, int32 s, int32 l)
+bits8 * 
+bitsubstr (bits8 *arg, int32 s, int32 l)
 {
   int bitlen,
     rbitlen,
     len,
-    ipad,
+    ipad = 0,
     ishift,
     i;
   int e, s1, e1;
-  char * result;
+  bits8 * result;
   bits8 mask, *r, *ps;
 
   if (!PointerIsValid(arg))
@@ -552,7 +547,7 @@ bitsubstr (char *arg, int32 s, int32 l)
     {
       /* Need to return a null string */
       len = VARBITDATALEN(0);
-      result = (char *) palloc(len);
+      result = (bits8 *) palloc(len);
       VARBITLEN(result) = 0;
       VARSIZE(result) = len;
     } 
@@ -562,22 +557,22 @@ bitsubstr (char *arg, int32 s, int32 l)
 	 ending at position e1-1 */
       rbitlen = e1-s1;
       len = VARBITDATALEN(rbitlen);
-      result = (char *) palloc(len);
+      result = (bits8 *) palloc(len);
       VARBITLEN(result) = rbitlen;
       VARSIZE(result) = len;
+      len -= VARHDRSZ + VARBITHDRSZ;
       /* Are we copying from a byte boundary? */
       if ((s1-1)%BITSPERBYTE==0) 
 	{
 	  /* Yep, we are copying bytes */
-	  len -= VARHDRSZ + VARBITHDRSZ;
 	  memcpy(VARBITS(result),VARBITS(arg)+(s1-1)/BITSPERBYTE,len);
 	} 
       else 
 	{
 	  /* Figure out how much we need to shift the sequence by */
 	  ishift = (s1-1)%BITSPERBYTE;
-	  r = (VarBit) VARBITS(result);
-	  ps = (VarBit) VARBITS(arg) + (s1-1)/BITSPERBYTE;
+	  r = VARBITS(result);
+	  ps = VARBITS(arg) + (s1-1)/BITSPERBYTE;
 	  for (i=0; i<len; i++) 
 	    {
 	      *r = (*ps <<ishift) & BITMASK;
@@ -602,12 +597,12 @@ bitsubstr (char *arg, int32 s, int32 l)
  * perform a logical AND on two bit strings. The result is automatically
  * truncated to the shorter bit string
  */
-char *
-bitand (char * arg1, char * arg2)
+bits8 *
+bitand (bits8 * arg1, bits8 * arg2)
 {
   int len,
     i;
-  char *result;
+  bits8 *result;
   bits8 *p1, 
     *p2, 
     *r;
@@ -616,7 +611,7 @@ bitand (char * arg1, char * arg2)
     return (bool) 0;
 
   len = Min(VARSIZE(arg1),VARSIZE(arg2));
-  result = (char *) palloc(len);
+  result = (bits8 *) palloc(len);
   VARSIZE(result) = len;
   VARBITLEN(result) = Min(VARBITLEN(arg1),VARBITLEN(arg2));
 
@@ -635,12 +630,12 @@ bitand (char * arg1, char * arg2)
  * perform a logical OR on two bit strings. The result is automatically
  * truncated to the shorter bit string.
  */
-char *
-bitor (char * arg1, char * arg2)
+bits8 *
+bitor (bits8 * arg1, bits8 * arg2)
 {
   int len,
     i;
-  char *result;
+  bits8 *result;
   bits8 *p1, 
     *p2, 
     *r;
@@ -650,7 +645,7 @@ bitor (char * arg1, char * arg2)
     return (bool) 0;
 
   len = Min(VARSIZE(arg1),VARSIZE(arg2));
-  result = (char *) palloc(len);
+  result = (bits8 *) palloc(len);
   VARSIZE(result) = len;
   VARBITLEN(result) = Min(VARBITLEN(arg1),VARBITLEN(arg2));
 
@@ -671,12 +666,12 @@ bitor (char * arg1, char * arg2)
  * perform a logical XOR on two bit strings. The result is automatically
  * truncated to the shorter bit string.
  */
-char *
-bitxor (char * arg1, char * arg2)
+bits8 *
+bitxor (bits8 * arg1, bits8 * arg2)
 {
   int len,
     i;
-  char *result;
+  bits8 *result;
   bits8 *p1, 
     *p2, 
     *r;
@@ -686,7 +681,7 @@ bitxor (char * arg1, char * arg2)
     return (bool) 0;
 
   len = Min(VARSIZE(arg1),VARSIZE(arg2));
-  result = (char *) palloc(len);
+  result = (bits8 *) palloc(len);
   VARSIZE(result) = len;
   VARBITLEN(result) = Min(VARBITLEN(arg1),VARBITLEN(arg2));
 
@@ -708,11 +703,10 @@ bitxor (char * arg1, char * arg2)
 /* bitnot
  * perform a logical NOT on a bit strings.
  */
-char *
-bitnot (char * arg)
+bits8 *
+bitnot (bits8 * arg)
 {
-  int len;
-  char *result;
+  bits8 *result;
   bits8 *p, 
     *r;
   bits8 mask;
@@ -720,7 +714,7 @@ bitnot (char * arg)
   if (!PointerIsValid(arg))
     return (bool) 0;
 
-  result = (char *) palloc(VARSIZE(arg));
+  result = (bits8 *) palloc(VARSIZE(arg));
   VARSIZE(result) = VARSIZE(arg);
   VARBITLEN(result) = VARBITLEN(arg);
 
@@ -739,11 +733,11 @@ bitnot (char * arg)
 /* bitshiftleft
  * do a left shift (i.e. to the beginning of the string) of the bit string
  */
-char *
-bitshiftleft (char * arg, int shft)
+bits8 *
+bitshiftleft (bits8 * arg, int shft)
 {
   int byte_shift, ishift, len;
-  char *result;
+  bits8 *result;
   bits8 *p, 
     *r;
 
@@ -754,7 +748,7 @@ bitshiftleft (char * arg, int shft)
   if (shft < 0) 
     return bitshiftright(arg, -shft);
 
-  result = (char *) palloc(VARSIZE(arg));
+  result = (bits8 *) palloc(VARSIZE(arg));
   VARSIZE(result) = VARSIZE(arg);
   VARBITLEN(result) = VARBITLEN(arg);
   r = (bits8 *) VARBITS(result);
@@ -784,22 +778,22 @@ bitshiftleft (char * arg, int shft)
 /* bitshiftright
  * do a right shift (i.e. to the beginning of the string) of the bit string
  */
-char *
-bitshiftright (char * arg, int shft)
+bits8 *
+bitshiftright (bits8 * arg, int shft)
 {
   int byte_shift, ishift, len;
-  char *result;
+  bits8 *result;
   bits8 *p, 
     *r;
 
   if (!PointerIsValid(arg))
-    return (bool) 0;
+    return (bits8 *) 0;
 
   /* Negative shift is a shift to the left */
   if (shft < 0) 
     return bitshiftleft(arg, -shft);
 
-  result = (char *) palloc(VARSIZE(arg));
+  result = (bits8 *) palloc(VARSIZE(arg));
   VARSIZE(result) = VARSIZE(arg);
   VARBITLEN(result) = VARBITLEN(arg);
   r = (bits8 *) VARBITS(result);
diff --git a/contrib/bit/varbit.demo.sql b/contrib/bit/varbit.demo.sql
new file mode 100644
index 00000000000..2b2bf661d35
--- /dev/null
+++ b/contrib/bit/varbit.demo.sql
@@ -0,0 +1,29 @@
+create table bit_example (a bits, b bits);
+copy bit_example from stdin;
+X0F	X10
+X1F	X11
+X2F	X12
+X3F	X13
+X8F	X04
+X000F	X0010
+X0123	XFFFF
+X2468	X2468
+XFA50	X05AF
+X12345	XFFF
+\.
+
+select a,b,a||b as "a||b", bitsubstr(a,4,4) as "sub(a,4,4)", 
+	bitsubstr(b,2,4) as "sub(b,2,4)", 
+	bitsubstr(b,5,5) as "sub(b,5,5)"
+	from bit_example;
+select a,b,~a as "~ a",~b as "~ b",a & b as "a & b", 
+	a|b as "a | b", a^b as "a ^ b" from bit_example;
+select a,b,a<b as "a<b",a<=b as "a<=b",a=b as "a=b",
+        a>=b as "a>=b",a>b as "a>b",a<=>b as "a<=>b" from bit_example;
+select a,a<<4 as "a<<4",b,b>>2 as "b>>2" from bit_example;
+select a,b,a||b as "a||b", bitsubstr(a,4,4) as "sub(a,4,4)", 
+	bitsubstr(b,2,4) as "sub(b,2,4)", 
+	bitsubstr(b,5,5) as "sub(b,5,5)"
+	from bit_example;
+
+drop table bit_example;
diff --git a/contrib/bit/varbit.drop.sql b/contrib/bit/varbit.drop.sql
new file mode 100644
index 00000000000..54b831ea2dc
--- /dev/null
+++ b/contrib/bit/varbit.drop.sql
@@ -0,0 +1,36 @@
+DROP FUNCTION biteq(bits,bits);
+DROP OPERATOR = (bits,bits);
+DROP FUNCTION bitne(bits,bits);
+DROP OPERATOR <> (bits,bits);
+DROP FUNCTION bitlt(bits,bits);
+DROP OPERATOR < (bits,bits);
+DROP FUNCTION bitle(bits,bits);
+DROP OPERATOR <= (bits,bits);
+DROP FUNCTION bitgt(bits,bits);
+DROP OPERATOR > (bits,bits);
+DROP FUNCTION bitge(bits,bits);
+DROP OPERATOR >= (bits,bits);
+DROP FUNCTION bitcmp(bits,bits);
+DROP OPERATOR <=> (bits,bits);
+
+DROP FUNCTION bitor(bits,bits);
+DROP OPERATOR | (bits,bits);
+DROP FUNCTION bitand(bits,bits);
+DROP OPERATOR & (bits,bits);
+DROP FUNCTION bitxor(bits,bits);
+DROP OPERATOR ^ (bits,bits);
+DROP FUNCTION bitnot(bits);
+DROP OPERATOR ~ (none,bits);
+
+DROP FUNCTION bitshiftleft(bits,int4);
+DROP OPERATOR << (bits,int4);
+DROP FUNCTION bitshiftright(bits,int4);
+DROP OPERATOR >> (bits,int4);
+
+DROP FUNCTION bitsubstr(bits,integer,integer);
+DROP OPERATOR || (bits,bits);
+DROP FUNCTION bitcat(bits,bits);
+
+DROP FUNCTION varbit_in(opaque);
+DROP FUNCTION varbit_out(opaque);
+DROP TYPE bits;
diff --git a/contrib/bit/varbit.h b/contrib/bit/varbit.h
index af55f486ea3..44007ad10a9 100644
--- a/contrib/bit/varbit.h
+++ b/contrib/bit/varbit.h
@@ -1,17 +1,21 @@
+#include "c.h"
 #include "postgres.h"
 
-typedef bits8  *VarBit;
-typedef uint32 BitIndex;
-
 #define HEXDIG(z)    (z)<10 ? ((z)+'0') : ((z)-10+'A')
 
+/* Modeled on struct varlena from postgres.h, bu data type is bits8 */
+struct varbita
+{
+	int32		vl_len;
+	bits8		vl_dat[1];
+};
 
 #define BITSPERBYTE		8
 #define VARBITHDRSZ		sizeof(int32)
 /* Number of bits in this bit string */
-#define VARBITLEN(PTR)		(((struct varlena *)VARDATA(PTR))->vl_len)
+#define VARBITLEN(PTR)		(((struct varbita *)VARDATA(PTR))->vl_len)
 /* Pointer tp the first byte containing bit string data */
-#define VARBITS(PTR)		(((struct varlena *)VARDATA(PTR))->vl_dat)
+#define VARBITS(PTR)		(((struct varbita *)VARDATA(PTR))->vl_dat)
 /* Number of bytes in the data section of a bit string */
 #define VARBITBYTES(PTR)	(VARSIZE(PTR) - VARHDRSZ - VARBITHDRSZ)
 /* Padding of the bit string at the end */
@@ -27,22 +31,22 @@ typedef uint32 BitIndex;
 #define BITHIGH                 0x80
 
 
-char * zpbitin(char *s, int dummy,  int32 atttypmod);
-char * zpbitout(char *s);
-char * zpbitsout(char *s);
-char * varbitin(char *s, int dummy,  int32 atttypmod);
-bool biteq (char *arg1, char *arg2);
-bool bitne (char *arg1, char *arg2);
-bool bitge (char *arg1, char *arg2);
-bool bitgt (char *arg1, char *arg2);
-bool bitle (char *arg1, char *arg2);
-bool bitlt (char *arg1, char *arg2);
-int bitcmp (char *arg1, char *arg2);
-char * bitand (char * arg1, char * arg2);
-char * bitor (char * arg1, char * arg2);
-char * bitxor (char * arg1, char * arg2);
-char * bitnot (char * arg);
-char * bitshiftright (char * arg, int shft);
-char * bitshiftleft (char * arg, int shft);
-char * bitcat (char *arg1, char *arg2);
-char * bitsubstr (char *arg, int32 s, int32 l);
+bits8 * zpbitin(char *s, int dummy,  int32 atttypmod);
+char * zpbitout(bits8 *s);
+char * zpbitsout(bits8 *s);
+bits8 * varbitin(char *s, int dummy,  int32 atttypmod);
+bool biteq (bits8 *arg1, bits8 *arg2);
+bool bitne (bits8 *arg1, bits8 *arg2);
+bool bitge (bits8 *arg1, bits8 *arg2);
+bool bitgt (bits8 *arg1, bits8 *arg2);
+bool bitle (bits8 *arg1, bits8 *arg2);
+bool bitlt (bits8 *arg1, bits8 *arg2);
+int bitcmp (bits8 *arg1, bits8 *arg2);
+bits8 * bitand (bits8 * arg1, bits8 * arg2);
+bits8 * bitor (bits8 * arg1, bits8 * arg2);
+bits8 * bitxor (bits8 * arg1, bits8 * arg2);
+bits8 * bitnot (bits8 * arg);
+bits8 * bitshiftright (bits8 * arg, int shft);
+bits8 * bitshiftleft (bits8 * arg, int shft);
+bits8 * bitcat (bits8 *arg1, bits8 *arg2);
+bits8 * bitsubstr (bits8 *arg, int32 s, int32 l);
diff --git a/contrib/bit/varbit.source b/contrib/bit/varbit.source
new file mode 100644
index 00000000000..8b9dc29aab5
--- /dev/null
+++ b/contrib/bit/varbit.source
@@ -0,0 +1,171 @@
+LOAD '_OBJWD_/varbit.so';
+
+CREATE FUNCTION varbit_in(opaque)
+   RETURNS bit
+   AS '_OBJWD_/varbit.so'
+   LANGUAGE 'c';
+
+CREATE FUNCTION varbit_out(opaque)
+   RETURNS opaque
+   AS '_OBJWD_/varbit.so'
+   LANGUAGE 'c';
+
+CREATE TYPE bits (
+   internallength = -1,
+   input = varbit_in,
+   output = varbit_out
+);
+
+CREATE FUNCTION bitcat(bits,bits) RETURNS bits
+  AS '_OBJWD_/varbit.so'
+  LANGUAGE 'C';
+
+CREATE OPERATOR || (
+  leftarg = bits,
+  rightarg = bits,
+  procedure = bitcat
+);
+
+CREATE FUNCTION bitsubstr(bits,integer,integer) RETURNS bits
+  AS '_OBJWD_/varbit.so'
+  LANGUAGE 'C';
+
+CREATE FUNCTION biteq(bits,bits) RETURNS bool
+  AS '_OBJWD_/varbit.so'
+  LANGUAGE 'C';
+
+CREATE OPERATOR = (
+  leftarg = bits,
+  rightarg = bits,
+  procedure = biteq,
+  negator = <>,
+  commutator = =
+); 
+
+CREATE FUNCTION bitne(bits,bits) RETURNS bool
+  AS '_OBJWD_/varbit.so'
+  LANGUAGE 'C';
+
+CREATE OPERATOR <> (
+  leftarg = bits,
+  rightarg = bits,
+  procedure = bitne,
+  negator = =,
+  commutator = <>
+); 
+
+CREATE FUNCTION bitlt(bits,bits) RETURNS bool
+  AS '_OBJWD_/varbit.so'
+  LANGUAGE 'C';
+
+CREATE OPERATOR < (
+  leftarg = bits,
+  rightarg = bits,
+  procedure = bitlt
+); 
+
+CREATE FUNCTION bitle(bits,bits) RETURNS bool
+  AS '_OBJWD_/varbit.so'
+  LANGUAGE 'C';
+
+CREATE OPERATOR <= (
+  leftarg = bits,
+  rightarg = bits,
+  procedure = bitle
+); 
+
+CREATE FUNCTION bitgt(bits,bits) RETURNS bool
+  AS '_OBJWD_/varbit.so'
+  LANGUAGE 'C';
+
+CREATE OPERATOR > (
+  leftarg = bits,
+  rightarg = bits,
+  procedure = bitgt,
+  negator = <=,
+  commutator = <
+); 
+
+CREATE FUNCTION bitge(bits,bits) RETURNS bool
+  as '_OBJWD_/varbit.so'
+  language 'C';
+
+CREATE OPERATOR >= (
+  leftarg = bits,
+  rightarg = bits,
+  procedure = bitge,
+  negator = <,
+  commutator = <=
+); 
+
+CREATE FUNCTION bitcmp(bits,bits) RETURNS int4
+  AS '_OBJWD_/varbit.so'
+  LANGUAGE 'C';
+
+CREATE OPERATOR <=> (
+  leftarg = bits,
+  rightarg = bits,
+  procedure = bitcmp
+); 
+
+CREATE FUNCTION bitor(bits,bits) RETURNS bits
+  AS '_OBJWD_/varbit.so'
+  LANGUAGE 'C';
+
+CREATE OPERATOR | (
+  leftarg = bits,
+  rightarg = bits,
+  procedure = bitor,
+  commutator = |
+); 
+
+CREATE FUNCTION bitand(bits,bits) RETURNS bits
+  AS '_OBJWD_/varbit.so'
+  LANGUAGE 'C';
+
+CREATE OPERATOR & (
+  leftarg = bits,
+  rightarg = bits,
+  procedure = bitand,
+  commutator = &
+); 
+
+
+CREATE FUNCTION bitxor(bits,bits) RETURNS bits
+  AS '_OBJWD_/varbit.so'
+  LANGUAGE 'C';
+
+CREATE OPERATOR ^ (
+  leftarg = bits,
+  rightarg = bits,
+  procedure = bitxor
+); 
+
+CREATE FUNCTION bitnot(bits) RETURNS bits
+  AS '_OBJWD_/varbit.so'
+  LANGUAGE 'C';
+
+CREATE OPERATOR ~ (
+  rightarg = bits,
+  procedure = bitnot
+); 
+
+CREATE FUNCTION bitshiftleft(bits,int4) RETURNS bits
+  AS '_OBJWD_/varbit.so'
+  LANGUAGE 'C';
+
+CREATE OPERATOR << (
+  leftarg = bits,
+  rightarg = int4,
+  procedure = bitshiftleft
+);
+
+CREATE FUNCTION bitshiftright(bits,int4) RETURNS bits
+  AS '_OBJWD_/varbit.so'
+  LANGUAGE 'C';
+
+CREATE OPERATOR >> (
+  leftarg = bits,
+  rightarg = int4,
+  procedure = bitshiftright
+);
diff --git a/contrib/bit/varbit_glue.c b/contrib/bit/varbit_glue.c
new file mode 100644
index 00000000000..29b7debd03c
--- /dev/null
+++ b/contrib/bit/varbit_glue.c
@@ -0,0 +1,22 @@
+/* Glue file to use varbit before it is properly integrated with postgres */
+
+#include "varbit.h"
+
+bits8 * varbit_in (char * s);
+char * varbit_out (bits8 *s);
+
+bits8 *
+varbit_in (char * s) {
+  return varbitin (s, 0, -1);
+}
+
+/*char * 
+varbit_out (bits8 *s) {
+  return zpbitout(s);
+}
+*/
+
+char * 
+varbit_out (bits8 *s) {
+  return zpbitsout(s);
+}
diff --git a/contrib/bit/vartest.c b/contrib/bit/vartest.c
index 732141e8df4..f07f5c5b833 100644
--- a/contrib/bit/vartest.c
+++ b/contrib/bit/vartest.c
@@ -2,6 +2,8 @@
 #include "varbit.h"
 #include <stdio.h>
 
+void print_details (unsigned char *s);
+
 const int numb = 8;
 /*
 const char *b[] = { "B0010", "B11011011", "B0001", "X3F12", "X27", "B",
@@ -23,13 +25,13 @@ void print_details (unsigned char *s)
   printf("\n");
 }
 
-void
+int
 main () 
 {
   int i, j;
   char *s[numb];
 
-    for (i=0; i<numb; i++) {
+  for (i=0; i<numb; i++) {
     printf ("Input: %s\n",b[i]);
     s[i] = zpbitin(b[i], 0, atttypmod[i]);
     //print_details(s[i]);
@@ -53,13 +55,13 @@ main ()
 	 zpbitsout(bitsubstr(s[3],1,8)));
   printf("%s (%d,%d) => %s\n",zpbitsout(s[3]),9,8,
 	 zpbitsout(bitsubstr(s[3],9,8)));
- printf("%s (%d,%d) => %s\n",zpbitsout(s[3]),1,9,
+  printf("%s (%d,%d) => %s\n",zpbitsout(s[3]),1,9,
 	 zpbitsout(bitsubstr(s[3],1,9)));
- printf("%s (%d,%d) => %s\n",zpbitsout(s[3]),3,5,
+  printf("%s (%d,%d) => %s\n",zpbitsout(s[3]),3,5,
 	 zpbitsout(bitsubstr(s[3],3,5)));
- printf("%s (%d,%d) => %s\n",zpbitsout(s[3]),3,9,
+  printf("%s (%d,%d) => %s\n",zpbitsout(s[3]),3,9,
 	 zpbitsout(bitsubstr(s[3],3,9)));
- printf("%s (%d,%d) => %s\n",zpbitsout(s[3]),3,17,
+  printf("%s (%d,%d) => %s\n",zpbitsout(s[3]),3,17,
 	 zpbitsout(bitsubstr(s[3],3,17)));
   printf ("\nLOGICAL AND:\n");
   for (i=0; i<numb; i++)
@@ -124,14 +126,14 @@ main ()
 	 zpbitsout(bitsubstr(s[3],1,8)));
   printf("%s (%d,%d) => %s\n",zpbitsout(s[3]),9,8,
 	 zpbitsout(bitsubstr(s[3],9,8)));
- printf("%s (%d,%d) => %s\n",zpbitsout(s[3]),1,9,
+  printf("%s (%d,%d) => %s\n",zpbitsout(s[3]),1,9,
 	 zpbitsout(bitsubstr(s[3],1,9)));
- printf("%s (%d,%d) => %s\n",zpbitsout(s[3]),3,5,
+  printf("%s (%d,%d) => %s\n",zpbitsout(s[3]),3,5,
 	 zpbitsout(bitsubstr(s[3],3,5)));
- printf("%s (%d,%d) => %s\n",zpbitsout(s[3]),3,9,
+  printf("%s (%d,%d) => %s\n",zpbitsout(s[3]),3,9,
 	 zpbitsout(bitsubstr(s[3],3,9)));
- printf("%s (%d,%d) => %s\n",zpbitsout(s[3]),3,17,
-	 zpbitsout(bitsubstr(s[3],3,17)));
+  printf("%s (%d,%d) => %s (%s)\n",zpbitsout(s[3]),3,17,
+	 zpbitsout(bitsubstr(s[3],3,17)),zpbitsout(bitsubstr(s[3],3,17)));
   printf ("\nLOGICAL AND:\n");
   for (i=0; i<numb; i++)
     for (j=i+1; j<numb; j++)