{
return array_iterator((Oid) 25, /* text */
(Oid) 67, /* texteq */
- 0, /* logical or */
+ 0, /* logical or */
array, (Datum) value);
}
{
return array_iterator((Oid) 25, /* text */
(Oid) 67, /* texteq */
- 1, /* logical and */
+ 1, /* logical and */
array, (Datum) value);
}
{
return array_iterator((Oid) 25, /* text */
(Oid) 1254, /* textregexeq */
- 0, /* logical or */
+ 0, /* logical or */
array, (Datum) value);
}
{
return array_iterator((Oid) 25, /* text */
(Oid) 1254, /* textregexeq */
- 1, /* logical and */
+ 1, /* logical and */
array, (Datum) value);
}
{
return array_iterator((Oid) 1043, /* varchar */
(Oid) 1070, /* varchareq */
- 0, /* logical or */
+ 0, /* logical or */
array, (Datum) value);
}
{
return array_iterator((Oid) 1043, /* varchar */
(Oid) 1070, /* varchareq */
- 1, /* logical and */
+ 1, /* logical and */
array, (Datum) value);
}
{
return array_iterator((Oid) 1043, /* varchar */
(Oid) 1254, /* textregexeq */
- 0, /* logical or */
+ 0, /* logical or */
array, (Datum) value);
}
{
return array_iterator((Oid) 1043, /* varchar */
(Oid) 1254, /* textregexeq */
- 1, /* logical and */
+ 1, /* logical and */
array, (Datum) value);
}
{
return array_iterator((Oid) 1042, /* bpchar */
(Oid) 1048, /* bpchareq */
- 0, /* logical or */
+ 0, /* logical or */
array, (Datum) value);
}
{
return array_iterator((Oid) 1042, /* bpchar */
(Oid) 1048, /* bpchareq */
- 1, /* logical and */
+ 1, /* logical and */
array, (Datum) value);
}
{
return array_iterator((Oid) 1042, /* bpchar */
(Oid) 1254, /* textregexeq */
- 0, /* logical or */
+ 0, /* logical or */
array, (Datum) value);
}
{
return array_iterator((Oid) 1042, /* bpchar */
(Oid) 1254, /* textregexeq */
- 1, /* logical and */
+ 1, /* logical and */
array, (Datum) value);
}
{
return array_iterator((Oid) 23, /* int4 */
(Oid) 65, /* int4eq */
- 0, /* logical or */
+ 0, /* logical or */
array, (Datum) value);
}
{
return array_iterator((Oid) 23, /* int4 */
(Oid) 65, /* int4eq */
- 1, /* logical and */
+ 1, /* logical and */
array, (Datum) value);
}
{
return array_iterator((Oid) 23, /* int4 */
(Oid) 144, /* int4ne */
- 0, /* logical or */
+ 0, /* logical or */
array, (Datum) value);
}
{
return array_iterator((Oid) 23, /* int4 */
(Oid) 144, /* int4ne */
- 1, /* logical and */
+ 1, /* logical and */
array, (Datum) value);
}
{
return array_iterator((Oid) 23, /* int4 */
(Oid) 147, /* int4gt */
- 0, /* logical or */
+ 0, /* logical or */
array, (Datum) value);
}
{
return array_iterator((Oid) 23, /* int4 */
(Oid) 147, /* int4gt */
- 1, /* logical and */
+ 1, /* logical and */
array, (Datum) value);
}
{
return array_iterator((Oid) 23, /* int4 */
(Oid) 150, /* int4ge */
- 0, /* logical or */
+ 0, /* logical or */
array, (Datum) value);
}
{
return array_iterator((Oid) 23, /* int4 */
(Oid) 150, /* int4ge */
- 1, /* logical and */
+ 1, /* logical and */
array, (Datum) value);
}
{
return array_iterator((Oid) 23, /* int4 */
(Oid) 66, /* int4lt */
- 0, /* logical or */
+ 0, /* logical or */
array, (Datum) value);
}
{
return array_iterator((Oid) 23, /* int4 */
(Oid) 66, /* int4lt */
- 1, /* logical and */
+ 1, /* logical and */
array, (Datum) value);
}
{
return array_iterator((Oid) 23, /* int4 */
(Oid) 149, /* int4le */
- 0, /* logical or */
+ 0, /* logical or */
array, (Datum) value);
}
{
return array_iterator((Oid) 23, /* int4 */
(Oid) 149, /* int4le */
- 1, /* logical and */
+ 1, /* logical and */
array, (Datum) value);
}
{
return array_iterator((Oid) 26, /* oid */
(Oid) 184, /* oideq */
- 0, /* logical or */
+ 0, /* logical or */
array, (Datum) value);
}
{
return array_iterator((Oid) 26, /* int4 */
(Oid) 185, /* oidne */
- 1, /* logical and */
+ 1, /* logical and */
array, (Datum) value);
}
/*
* Local Variables:
- * tab-width: 4
- * c-indent-level: 4
- * c-basic-offset: 4
+ * tab-width: 4
+ * c-indent-level: 4
+ * c-basic-offset: 4
* End:
*/
#define ARRAY_ITERATOR_H
static int32 array_iterator(Oid elemtype, Oid proc, int and,
- ArrayType *array, Datum value);
+ ArrayType *array, Datum value);
int32 array_texteq(ArrayType *array, char *value);
int32 array_all_texteq(ArrayType *array, char *value);
int32 array_int4le(ArrayType *array, int4 value);
int32 array_all_int4le(ArrayType *array, int4 value);
-int32 array_oideq(ArrayType *array, Oid value);
-int32 array_all_oidne(ArrayType *array, Oid value);
+int32 array_oideq(ArrayType *array, Oid value);
+int32 array_all_oidne(ArrayType *array, Oid value);
+
#endif
/*
* Local Variables:
- * tab-width: 4
- * c-indent-level: 4
- * c-basic-offset: 4
+ * tab-width: 4
+ * c-indent-level: 4
+ * c-basic-offset: 4
* End:
*/
* Functions for the built-in type bit() and varying bit().
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/contrib/bit/Attic/varbit.c,v 1.2 2000/04/03 20:56:40 momjian Exp $
+ * $Header: /cvsroot/pgsql/contrib/bit/Attic/varbit.c,v 1.3 2000/04/12 17:14:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*#include "utils/builtins.h" */
-/*
+/*
Prefixes:
- zp -- zero-padded fixed length bit string
- var -- varying bit string
+ zp -- zero-padded fixed length bit string
+ var -- varying bit string
attypmod -- contains the length of the bit string in bits, or for
- varying bits the maximum length.
+ varying bits the maximum length.
The data structure contains the following elements:
- header -- length of the whole data structure (incl header)
- in bytes. (as with all varying length datatypes)
- data section -- private data section for the bits data structures
- bitlength -- lenght of the bit string in bits
+ header -- length of the whole data structure (incl header)
+ in bytes. (as with all varying length datatypes)
+ data section -- private data section for the bits data structures
+ bitlength -- lenght of the bit string in bits
bitdata -- least significant byte first string
*/
* zpbitin -
* converts a string to the internal representation of a bitstring.
- * The length is determined by the number of bits required plus
- * VARHDRSZ bytes or from atttypmod.
- * (XXX dummy is here because we pass typelem as the second argument
- * for array_in. copied this, no idea what it means??)
+ * The length is determined by the number of bits required plus
+ * VARHDRSZ bytes or from atttypmod.
+ * (XXX dummy is here because we pass typelem as the second argument
+ * for array_in. copied this, no idea what it means??)
*/
bits8 *
-zpbitin(char *s, int dummy, int32 atttypmod)
+zpbitin(char *s, int dummy, int32 atttypmod)
{
- 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; /* 0 = hex string 1=bit string */
- int bc, ipad;
- bits8 x = 0;
-
-
- if (s == NULL)
- return (bits8 *) NULL;
-
- /* Check that the first character is a b or an x */
- if (s[0]=='b' || s[0]=='B')
- bit_not_hex = 1;
- else if (s[0]=='x' || s[0]=='X')
- bit_not_hex = 0;
- else
- elog(ERROR, "zpbitin: %s is not a valid bitstring",s);
-
- slen = strlen(s) - 1;
- /* Determine bitlength from input string */
- bitlen = slen;
- if (!bit_not_hex)
- bitlen *= 4;
-
- /* Sometimes atttypmod is not supplied. If it is supplied we need to make
- sure that the bitstring fits. Note that the number of infered bits can
- be larger than the number of actual bits needed, but only if we are
- 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)
- atttypmod = bitlen;
- else
- 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);
-
-
- len = VARBITDATALEN(atttypmod);
-
- if (len > MaxAttrSize)
- elog(ERROR, "zpbitin: length of bit() must be less than %ld",
- (MaxAttrSize-VARHDRSZ-VARBITHDRSZ)*BITSPERBYTE);
-
- 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;
- VARBITLEN(result) = atttypmod;
-
- /* We need to read the bitstring from the end, as we store it least
- significant byte first. s points to the byte before the beginning
- of the bitstring */
- sp = s+1;
- r = VARBITS(result);
- if (bit_not_hex)
- {
- /* Parse the bit representation of the string */
- /* We know it fits, as bitlen was compared to atttypmod */
- x = BITHIGH;
- for (bc = 0; sp != s+slen+1; sp++, bc++)
+ 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;/* 0 = hex string 1=bit string */
+ int bc,
+ ipad;
+ bits8 x = 0;
+
+
+ if (s == NULL)
+ return (bits8 *) NULL;
+
+ /* Check that the first character is a b or an x */
+ if (s[0] == 'b' || s[0] == 'B')
+ bit_not_hex = 1;
+ else if (s[0] == 'x' || s[0] == 'X')
+ bit_not_hex = 0;
+ else
+ elog(ERROR, "zpbitin: %s is not a valid bitstring", s);
+
+ slen = strlen(s) - 1;
+ /* Determine bitlength from input string */
+ bitlen = slen;
+ if (!bit_not_hex)
+ bitlen *= 4;
+
+ /*
+ * Sometimes atttypmod is not supplied. If it is supplied we need to
+ * make sure that the bitstring fits. Note that the number of infered
+ * bits can be larger than the number of actual bits needed, but only
+ * if we are 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)
+ atttypmod = bitlen;
+ else 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);
+
+
+ len = VARBITDATALEN(atttypmod);
+
+ if (len > MaxAttrSize)
+ elog(ERROR, "zpbitin: length of bit() must be less than %ld",
+ (MaxAttrSize - VARHDRSZ - VARBITHDRSZ) * BITSPERBYTE);
+
+ 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;
+ VARBITLEN(result) = atttypmod;
+
+ /*
+ * We need to read the bitstring from the end, as we store it least
+ * significant byte first. s points to the byte before the beginning
+ * of the bitstring
+ */
+ sp = s + 1;
+ r = VARBITS(result);
+ if (bit_not_hex)
+ {
+ /* Parse the bit representation of the string */
+ /* We know it fits, as bitlen was compared to atttypmod */
+ x = BITHIGH;
+ for (bc = 0; sp != s + slen + 1; sp++, bc++)
+ {
+ if (*sp == '1')
+ *r |= x;
+ if (bc == 7)
+ {
+ bc = 0;
+ x = BITHIGH;
+ r++;
+ }
+ else
+ x >>= 1;
+ }
+ }
+ else
{
- if (*sp=='1')
- *r |= x;
- if (bc==7) {
- bc = 0;
- x = BITHIGH;
- r++;
- } else
- x >>= 1;
+ /* Parse the hex representation of the string */
+ for (bc = 0; sp != s + slen + 1; sp++)
+ {
+ if (*sp >= '0' && *sp <= '9')
+ x = (bits8) (*sp - '0');
+ else if (*sp >= 'A' && *sp <= 'F')
+ x = (bits8) (*sp - 'A') + 10;
+ else if (*sp >= 'a' && *sp <= 'f')
+ x = (bits8) (*sp - 'a') + 10;
+ else
+ elog(ERROR, "Cannot parse %c as a hex digit", *sp);
+ if (bc)
+ {
+ bc = 0;
+ *r++ |= x;
+ }
+ else
+ {
+ bc++;
+ *r = x << 4;
+ }
+ }
}
- }
- else
- {
- /* Parse the hex representation of the string */
- for (bc = 0; sp != s+slen+1; sp++)
+
+ if (bitlen > atttypmod)
{
- if (*sp>='0' && *sp<='9')
- x = (bits8) (*sp - '0');
- else if (*sp>='A' && *sp<='F')
- x = (bits8) (*sp - 'A') + 10;
- else if (*sp>='a' && *sp<='f')
- x = (bits8) (*sp - 'a') + 10;
- else
- elog(ERROR,"Cannot parse %c as a hex digit",*sp);
- if (bc) {
- bc = 0;
- *r++ |= x;
- } else {
- bc++;
- *r = x<<4;
- }
+ /* Check that this fitted */
+ r = (bits8 *) (result + len - 1);
+ ipad = VARBITPAD(result);
+
+ /*
+ * The bottom ipad bits of the byte pointed to by r need to be
+ * zero
+ */
+
+ /*
+ * printf("Byte %X shift %X %d\n",*r,(*r << (8-ipad)) & BITMASK,
+ * (*r << (8-ipad)) & BITMASK > 0);
+ */
+ if (((*r << (BITSPERBYTE - ipad)) & BITMASK) > 0)
+ elog(ERROR, "zpbitin: bit string too large for bit(%d) data type",
+ atttypmod);
}
- }
-
- if (bitlen > atttypmod) {
- /* Check that this fitted */
- r = (bits8 *) (result + len - 1);
- ipad = VARBITPAD(result);
- /* The bottom ipad bits of the byte pointed to by r need to be zero */
- /* printf("Byte %X shift %X %d\n",*r,(*r << (8-ipad)) & BITMASK,
- (*r << (8-ipad)) & BITMASK > 0);
- */
- if (((*r << (BITSPERBYTE-ipad)) & BITMASK) > 0)
- elog(ERROR, "zpbitin: bit string too large for bit(%d) data type",
- atttypmod);
- }
-
- return result;
+
+ return result;
}
/* zpbitout -
- * for the time being we print everything as hex strings, as this is likely
- * to be more compact than bit strings, and consequently much more efficient
- * for long strings
+ * for the time being we print everything as hex strings, as this is likely
+ * to be more compact than bit strings, and consequently much more efficient
+ * for long strings
*/
char *
zpbitout(bits8 *s)
{
- char *result, *r;
- bits8 *sp;
- int i, len, bitlen;
-
- if (s == NULL)
- {
- result = (char *) palloc(2);
- result[0] = '-';
- result[1] = '\0';
- }
- else
- {
- bitlen = VARBITLEN(s);
- len = bitlen/4 + (bitlen%4>0 ? 1 : 0);
- result = (char *) palloc(len + 4);
- sp = VARBITS(s);
- r = result;
- *r++ = 'X';
- *r++ = '\'';
- /* we cheat by knowing that we store full bytes zero padded */
- for (i=0; i<len; i+=2, sp++) {
- *r++ = HEXDIG((*sp)>>4);
- *r++ = HEXDIG((*sp) & 0xF);
- }
- /* Go back one step if we printed a hex number that was not part
- of the bitstring anymore */
- if (i==len+1)
- r--;
- *r++ = '\'';
- *r = '\0';
- }
- return result;
+ char *result,
+ *r;
+ bits8 *sp;
+ int i,
+ len,
+ bitlen;
+
+ if (s == NULL)
+ {
+ result = (char *) palloc(2);
+ result[0] = '-';
+ result[1] = '\0';
+ }
+ else
+ {
+ bitlen = VARBITLEN(s);
+ len = bitlen / 4 + (bitlen % 4 > 0 ? 1 : 0);
+ result = (char *) palloc(len + 4);
+ sp = VARBITS(s);
+ r = result;
+ *r++ = 'X';
+ *r++ = '\'';
+ /* we cheat by knowing that we store full bytes zero padded */
+ for (i = 0; i < len; i += 2, sp++)
+ {
+ *r++ = HEXDIG((*sp) >> 4);
+ *r++ = HEXDIG((*sp) & 0xF);
+ }
+
+ /*
+ * Go back one step if we printed a hex number that was not part
+ * of the bitstring anymore
+ */
+ if (i == len + 1)
+ r--;
+ *r++ = '\'';
+ *r = '\0';
+ }
+ return result;
}
/* zpbitsout -
- * Prints the string a bits
+ * Prints the string a bits
*/
char *
zpbitsout(bits8 *s)
{
- char *result, *r;
- bits8 *sp;
- bits8 x;
- int i, k, len;
-
- if (s == NULL)
- {
- result = (char *) palloc(2);
- result[0] = '-';
- result[1] = '\0';
- }
- else
- {
- len = VARBITLEN(s);
- result = (char *) palloc(len + 4);
- sp = VARBITS(s);
- r = result;
- *r++ = 'B';
- *r++ = '\'';
- for (i=0; i<len-BITSPERBYTE; i+=BITSPERBYTE, sp++) {
- x = *sp;
- for (k=0; k<BITSPERBYTE; k++)
- {
- *r++ = (x & BITHIGH) ? '1' : '0';
- x <<= 1;
- }
- }
- x = *sp;
- for (k=i; k<len; k++)
+ char *result,
+ *r;
+ bits8 *sp;
+ bits8 x;
+ int i,
+ k,
+ len;
+
+ if (s == NULL)
{
- *r++ = (x & BITHIGH) ? '1' : '0';
- x <<= 1;
+ result = (char *) palloc(2);
+ result[0] = '-';
+ result[1] = '\0';
}
- *r++ = '\'';
- *r = '\0';
- }
- return result;
+ else
+ {
+ len = VARBITLEN(s);
+ result = (char *) palloc(len + 4);
+ sp = VARBITS(s);
+ r = result;
+ *r++ = 'B';
+ *r++ = '\'';
+ for (i = 0; i < len - BITSPERBYTE; i += BITSPERBYTE, sp++)
+ {
+ x = *sp;
+ for (k = 0; k < BITSPERBYTE; k++)
+ {
+ *r++ = (x & BITHIGH) ? '1' : '0';
+ x <<= 1;
+ }
+ }
+ x = *sp;
+ for (k = i; k < len; k++)
+ {
+ *r++ = (x & BITHIGH) ? '1' : '0';
+ x <<= 1;
+ }
+ *r++ = '\'';
+ *r = '\0';
+ }
+ return result;
}
* converts a string to the internal representation of a bitstring.
*/
bits8 *
-varbitin(char *s, int dummy, int32 atttypmod)
+varbitin(char *s, int dummy, int32 atttypmod)
{
- 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 = 0;
- int bc, ipad;
- bits8 x = 0;
-
-
- if (s == NULL)
- return (bits8 *) NULL;
-
- /* Check that the first character is a b or an x */
- if (s[0]=='b' || s[0]=='B')
- bit_not_hex = 1;
- else if (s[0]=='x' || s[0]=='X')
- bit_not_hex = 0;
- else
- elog(ERROR, "zpbitin: %s is not a valid bitstring",s);
-
- slen = strlen(s) - 1;
- /* Determine bitlength from input string */
- bitlen = slen;
- if (!bit_not_hex)
- bitlen *= 4;
-
- /* Sometimes atttypmod is not supplied. If it is supplied we need to make
- sure that the bitstring fits. Note that the number of infered bits can
- be larger than the number of actual bits needed, but only if we are
- 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))
- elog(ERROR, "varbitin: bit string of size %d cannot be written into varying bits(%d)",
- bitlen,atttypmod);
-
-
- len = VARBITDATALEN(bitlen);
-
- if (len > MaxAttrSize)
- elog(ERROR, "varbitin: length of bit() must be less than %ld",
- (MaxAttrSize-VARHDRSZ-VARBITHDRSZ)*BITSPERBYTE);
-
- 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;
- VARBITLEN(result) = bitlen;
-
- /* We need to read the bitstring from the end, as we store it least
- significant byte first. s points to the byte before the beginning
- of the bitstring */
- sp = s + 1;
- r = VARBITS(result);
- if (bit_not_hex)
- {
- /* Parse the bit representation of the string */
- x = BITHIGH;
- for (bc = 0; sp != s+slen+1; sp++, bc++)
+ 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 = 0;
+ int bc,
+ ipad;
+ bits8 x = 0;
+
+
+ if (s == NULL)
+ return (bits8 *) NULL;
+
+ /* Check that the first character is a b or an x */
+ if (s[0] == 'b' || s[0] == 'B')
+ bit_not_hex = 1;
+ else if (s[0] == 'x' || s[0] == 'X')
+ bit_not_hex = 0;
+ else
+ elog(ERROR, "zpbitin: %s is not a valid bitstring", s);
+
+ slen = strlen(s) - 1;
+ /* Determine bitlength from input string */
+ bitlen = slen;
+ if (!bit_not_hex)
+ bitlen *= 4;
+
+ /*
+ * Sometimes atttypmod is not supplied. If it is supplied we need to
+ * make sure that the bitstring fits. Note that the number of infered
+ * bits can be larger than the number of actual bits needed, but only
+ * if we are 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))
+ elog(ERROR, "varbitin: bit string of size %d cannot be written into varying bits(%d)",
+ bitlen, atttypmod);
+
+
+ len = VARBITDATALEN(bitlen);
+
+ if (len > MaxAttrSize)
+ elog(ERROR, "varbitin: length of bit() must be less than %ld",
+ (MaxAttrSize - VARHDRSZ - VARBITHDRSZ) * BITSPERBYTE);
+
+ 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;
+ VARBITLEN(result) = bitlen;
+
+ /*
+ * We need to read the bitstring from the end, as we store it least
+ * significant byte first. s points to the byte before the beginning
+ * of the bitstring
+ */
+ sp = s + 1;
+ r = VARBITS(result);
+ if (bit_not_hex)
+ {
+ /* Parse the bit representation of the string */
+ x = BITHIGH;
+ for (bc = 0; sp != s + slen + 1; sp++, bc++)
+ {
+ if (*sp == '1')
+ *r |= x;
+ if (bc == 7)
+ {
+ bc = 0;
+ x = BITHIGH;
+ r++;
+ }
+ else
+ x >>= 1;
+ }
+ }
+ else
{
- if (*sp=='1')
- *r |= x;
- if (bc==7) {
- bc = 0;
- x = BITHIGH;
- r++;
- } else
- x >>= 1;
+ for (bc = 0; sp != s + slen + 1; sp++)
+ {
+ if (*sp >= '0' && *sp <= '9')
+ x = (bits8) (*sp - '0');
+ else if (*sp >= 'A' && *sp <= 'F')
+ x = (bits8) (*sp - 'A') + 10;
+ else if (*sp >= 'a' && *sp <= 'f')
+ x = (bits8) (*sp - 'a') + 10;
+ else
+ elog(ERROR, "Cannot parse %c as a hex digit", *sp);
+ if (bc)
+ {
+ bc = 0;
+ *r++ |= x;
+ }
+ else
+ {
+ bc++;
+ *r = x << 4;
+ }
+ }
}
- }
- else
- {
- for (bc = 0; sp != s+slen+1; sp++)
+
+ if (bitlen > atttypmod)
{
- if (*sp>='0' && *sp<='9')
- x = (bits8) (*sp - '0');
- else if (*sp>='A' && *sp<='F')
- x = (bits8) (*sp - 'A') + 10;
- else if (*sp>='a' && *sp<='f')
- x = (bits8) (*sp - 'a') + 10;
- else
- elog(ERROR,"Cannot parse %c as a hex digit",*sp);
- if (bc) {
- bc = 0;
- *r++ |= x;
- } else {
- bc++;
- *r = x<<4;
- }
+ /* Check that this fitted */
+ r = (bits8 *) (result + len - 1);
+ ipad = VARBITPAD(result);
+
+ /*
+ * The bottom ipad bits of the byte pointed to by r need to be
+ * zero
+ */
+ if (((*r << (BITSPERBYTE - ipad)) & BITMASK) > 0)
+ elog(ERROR, "varbitin: bit string too large for varying bit(%d) data type",
+ atttypmod);
}
- }
-
- if (bitlen > atttypmod) {
- /* Check that this fitted */
- r = (bits8 *) (result + len - 1);
- ipad = VARBITPAD(result);
- /* The bottom ipad bits of the byte pointed to by r need to be zero */
- if (((*r << (BITSPERBYTE-ipad)) & BITMASK) > 0)
- elog(ERROR, "varbitin: bit string too large for varying bit(%d) data type",
- atttypmod);
- }
-
- return result;
+
+ return result;
}
/*
- the zpbitout routines are fine for varying bits as well
+ the zpbitout routines are fine for varying bits as well
*/
* Comparison operators
*
* We only need one set of comparison operators for bitstrings, as the lengths
- * are stored in the same way for zero-padded and varying bit strings.
+ * are stored in the same way for zero-padded and varying bit strings.
*
- * Note that the standard is not unambiguous about the comparison between
+ * Note that the standard is not unambiguous about the comparison between
* zero-padded bit strings and varying bitstrings. If the same value is written
- * into a zero padded bitstring as into a varying bitstring, but the zero
- * padded bitstring has greater length, it will be bigger.
+ * into a zero padded bitstring as into a varying bitstring, but the zero
+ * padded bitstring has greater length, it will be bigger.
*
* Zeros from the beginning of a bitstring cannot simply be ignored, as they
* may be part of a bit string and may be significant.
*/
bool
-biteq (bits8 *arg1, bits8 *arg2)
+biteq(bits8 *arg1, bits8 *arg2)
{
- int bitlen1,
- bitlen2;
-
- if (!PointerIsValid(arg1) || !PointerIsValid(arg2))
- return (bool) 0;
- bitlen1 = VARBITLEN(arg1);
- bitlen2 = VARBITLEN(arg2);
- if (bitlen1 != bitlen2)
- return (bool) 0;
-
- /* bit strings are always stored in a full number of bytes */
- return memcmp((void *)VARBITS(arg1),(void *)VARBITS(arg2),
- VARBITBYTES(arg1)) == 0;
+ int bitlen1,
+ bitlen2;
+
+ if (!PointerIsValid(arg1) || !PointerIsValid(arg2))
+ return (bool) 0;
+ bitlen1 = VARBITLEN(arg1);
+ bitlen2 = VARBITLEN(arg2);
+ if (bitlen1 != bitlen2)
+ return (bool) 0;
+
+ /* bit strings are always stored in a full number of bytes */
+ return memcmp((void *) VARBITS(arg1), (void *) VARBITS(arg2),
+ VARBITBYTES(arg1)) == 0;
}
bool
-bitne (bits8 *arg1, bits8 *arg2)
+bitne(bits8 *arg1, bits8 *arg2)
{
- int bitlen1,
- bitlen2;
-
- if (!PointerIsValid(arg1) || !PointerIsValid(arg2))
- return (bool) 0;
- bitlen1 = VARBITLEN(arg1);
- bitlen2 = VARBITLEN(arg2);
- if (bitlen1 != bitlen2)
- return (bool) 1;
-
- /* bit strings are always stored in a full number of bytes */
- return memcmp((void *)VARBITS(arg1),(void *)VARBITS(arg2),
- VARBITBYTES(arg1)) != 0;
+ int bitlen1,
+ bitlen2;
+
+ if (!PointerIsValid(arg1) || !PointerIsValid(arg2))
+ return (bool) 0;
+ bitlen1 = VARBITLEN(arg1);
+ bitlen2 = VARBITLEN(arg2);
+ if (bitlen1 != bitlen2)
+ return (bool) 1;
+
+ /* bit strings are always stored in a full number of bytes */
+ return memcmp((void *) VARBITS(arg1), (void *) VARBITS(arg2),
+ VARBITBYTES(arg1)) != 0;
}
/* bitcmp
- *
+ *
* Compares two bitstrings and returns -1, 0, 1 depending on whether the first
* string is smaller, equal, or bigger than the second. All bits are considered
* and additional zero bits may make one string smaller/larger than the other,
* even if their zero-padded values would be the same.
- * Anything is equal to undefined.
+ * Anything is equal to undefined.
*/
-int
-bitcmp (bits8 *arg1, bits8 *arg2)
+int
+bitcmp(bits8 *arg1, bits8 *arg2)
{
- int bitlen1, bytelen1,
- bitlen2, bytelen2;
- int cmp;
-
- if (!PointerIsValid(arg1) || !PointerIsValid(arg2))
- return (bool) 0;
- bytelen1 = VARBITBYTES(arg1);
- bytelen2 = VARBITBYTES(arg2);
-
- cmp = memcmp(VARBITS(arg1),VARBITS(arg2),Min(bytelen1,bytelen2));
- if (cmp==0) {
- bitlen1 = VARBITLEN(arg1);
- bitlen2 = VARBITLEN(arg2);
- if (bitlen1 != bitlen2)
- return bitlen1 < bitlen2 ? -1 : 1;
- }
- return cmp;
+ int bitlen1,
+ bytelen1,
+ bitlen2,
+ bytelen2;
+ int cmp;
+
+ if (!PointerIsValid(arg1) || !PointerIsValid(arg2))
+ return (bool) 0;
+ bytelen1 = VARBITBYTES(arg1);
+ bytelen2 = VARBITBYTES(arg2);
+
+ cmp = memcmp(VARBITS(arg1), VARBITS(arg2), Min(bytelen1, bytelen2));
+ if (cmp == 0)
+ {
+ bitlen1 = VARBITLEN(arg1);
+ bitlen2 = VARBITLEN(arg2);
+ if (bitlen1 != bitlen2)
+ return bitlen1 < bitlen2 ? -1 : 1;
+ }
+ return cmp;
}
bool
-bitlt (bits8 *arg1, bits8 *arg2)
+bitlt(bits8 *arg1, bits8 *arg2)
{
- return (bool) (bitcmp(arg1,arg2) == -1);
+ return (bool) (bitcmp(arg1, arg2) == -1);
}
bool
-bitle (bits8 *arg1, bits8 *arg2)
+bitle(bits8 *arg1, bits8 *arg2)
{
- return (bool) (bitcmp(arg1,arg2) <= 0);
+ return (bool) (bitcmp(arg1, arg2) <= 0);
}
bool
-bitge (bits8 *arg1, bits8 *arg2)
+bitge(bits8 *arg1, bits8 *arg2)
{
- return (bool) (bitcmp(arg1,arg2) >= 0);
+ return (bool) (bitcmp(arg1, arg2) >= 0);
}
bool
-bitgt (bits8 *arg1, bits8 *arg2)
+bitgt(bits8 *arg1, bits8 *arg2)
{
- return (bool) (bitcmp(arg1,arg2) == 1);
+ return (bool) (bitcmp(arg1, arg2) == 1);
}
/* bitcat
* Concatenation of bit strings
*/
bits8 *
-bitcat (bits8 *arg1, bits8 *arg2)
+bitcat(bits8 *arg1, bits8 *arg2)
{
- int bitlen1, bitlen2, bytelen, bit1pad, bit2shift;
- bits8 *result;
- bits8 *pr, *pa;
-
- if (!PointerIsValid(arg1) || !PointerIsValid(arg2))
- return NULL;
-
- bitlen1 = VARBITLEN(arg1);
- bitlen2 = VARBITLEN(arg2);
-
- bytelen = VARBITDATALEN(bitlen1+bitlen2);
-
- result = (bits8 *) palloc(bytelen*sizeof(bits8));
- VARSIZE(result) = bytelen;
- VARBITLEN(result) = bitlen1+bitlen2;
- printf("%d %d %d \n",VARBITBYTES(arg1),VARBITLEN(arg1),VARBITPAD(arg1));
- /* Copy the first bitstring in */
- memcpy(VARBITS(result),VARBITS(arg1),VARBITBYTES(arg1));
- /* Copy the second bit string */
- bit1pad = VARBITPAD(arg1);
- if (bit1pad==0)
- {
- memcpy(VARBITS(result)+VARBITBYTES(arg1),VARBITS(arg2),
- VARBITBYTES(arg2));
- }
- else if (bitlen2>0)
- {
- /* We need to shift all the results to fit */
- bit2shift = BITSPERBYTE - bit1pad;
- pa = VARBITS(arg2);
- pr = VARBITS(result)+VARBITBYTES(arg1)-1;
- for ( ; pa < VARBITEND(arg2); pa++) {
- *pr |= ((*pa >> bit2shift) & BITMASK);
- pr++;
- if (pr < VARBITEND(result))
- *pr = (*pa << bit1pad) & BITMASK;
- }
- }
-
- return result;
+ int bitlen1,
+ bitlen2,
+ bytelen,
+ bit1pad,
+ bit2shift;
+ bits8 *result;
+ bits8 *pr,
+ *pa;
+
+ if (!PointerIsValid(arg1) || !PointerIsValid(arg2))
+ return NULL;
+
+ bitlen1 = VARBITLEN(arg1);
+ bitlen2 = VARBITLEN(arg2);
+
+ bytelen = VARBITDATALEN(bitlen1 + bitlen2);
+
+ result = (bits8 *) palloc(bytelen * sizeof(bits8));
+ VARSIZE(result) = bytelen;
+ VARBITLEN(result) = bitlen1 + bitlen2;
+ printf("%d %d %d \n", VARBITBYTES(arg1), VARBITLEN(arg1), VARBITPAD(arg1));
+ /* Copy the first bitstring in */
+ memcpy(VARBITS(result), VARBITS(arg1), VARBITBYTES(arg1));
+ /* Copy the second bit string */
+ bit1pad = VARBITPAD(arg1);
+ if (bit1pad == 0)
+ {
+ memcpy(VARBITS(result) + VARBITBYTES(arg1), VARBITS(arg2),
+ VARBITBYTES(arg2));
+ }
+ else if (bitlen2 > 0)
+ {
+ /* We need to shift all the results to fit */
+ bit2shift = BITSPERBYTE - bit1pad;
+ pa = VARBITS(arg2);
+ pr = VARBITS(result) + VARBITBYTES(arg1) - 1;
+ for (; pa < VARBITEND(arg2); pa++)
+ {
+ *pr |= ((*pa >> bit2shift) & BITMASK);
+ pr++;
+ if (pr < VARBITEND(result))
+ *pr = (*pa << bit1pad) & BITMASK;
+ }
+ }
+
+ return result;
}
/* bitsubstr
- * retrieve a substring from the bit string.
+ * retrieve a substring from the bit string.
* Note, s is 1-based.
* SQL draft 6.10 9)
*/
-bits8 *
-bitsubstr (bits8 *arg, int32 s, int32 l)
+bits8 *
+bitsubstr(bits8 *arg, int32 s, int32 l)
{
- int bitlen,
- rbitlen,
- len,
- ipad = 0,
- ishift,
- i;
- int e, s1, e1;
- bits8 * result;
- bits8 mask, *r, *ps;
-
- if (!PointerIsValid(arg))
- return NULL;
-
- bitlen = VARBITLEN(arg);
- e = s+l;
- s1 = Max(s,1);
- e1 = Min(e,bitlen+1);
- if (s1>bitlen || e1<1)
- {
- /* Need to return a null string */
- len = VARBITDATALEN(0);
- result = (bits8 *) palloc(len);
- VARBITLEN(result) = 0;
- VARSIZE(result) = len;
- }
- else
- {
- /* OK, we've got a true substring starting at position s1-1 and
- ending at position e1-1 */
- rbitlen = e1-s1;
- len = VARBITDATALEN(rbitlen);
- 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)
+ int bitlen,
+ rbitlen,
+ len,
+ ipad = 0,
+ ishift,
+ i;
+ int e,
+ s1,
+ e1;
+ bits8 *result;
+ bits8 mask,
+ *r,
+ *ps;
+
+ if (!PointerIsValid(arg))
+ return NULL;
+
+ bitlen = VARBITLEN(arg);
+ e = s + l;
+ s1 = Max(s, 1);
+ e1 = Min(e, bitlen + 1);
+ if (s1 > bitlen || e1 < 1)
{
- /* Yep, we are copying bytes */
- 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 = VARBITS(result);
- ps = VARBITS(arg) + (s1-1)/BITSPERBYTE;
- for (i=0; i<len; i++)
- {
- *r = (*ps <<ishift) & BITMASK;
- if ((++ps) < VARBITEND(arg))
- *r |= *ps >>(BITSPERBYTE-ishift);
- r++;
- }
+ /* Need to return a null string */
+ len = VARBITDATALEN(0);
+ result = (bits8 *) palloc(len);
+ VARBITLEN(result) = 0;
+ VARSIZE(result) = len;
}
- /* Do we need to pad at the end? */
- ipad = VARBITPAD(result);
- if (ipad > 0)
+ else
{
- mask = BITMASK << ipad;
- *(VARBITS(result) + len - 1) &= mask;
+
+ /*
+ * OK, we've got a true substring starting at position s1-1 and
+ * ending at position e1-1
+ */
+ rbitlen = e1 - s1;
+ len = VARBITDATALEN(rbitlen);
+ 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 */
+ 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 = VARBITS(result);
+ ps = VARBITS(arg) + (s1 - 1) / BITSPERBYTE;
+ for (i = 0; i < len; i++)
+ {
+ *r = (*ps << ishift) & BITMASK;
+ if ((++ps) < VARBITEND(arg))
+ *r |= *ps >> (BITSPERBYTE - ishift);
+ r++;
+ }
+ }
+ /* Do we need to pad at the end? */
+ ipad = VARBITPAD(result);
+ if (ipad > 0)
+ {
+ mask = BITMASK << ipad;
+ *(VARBITS(result) + len - 1) &= mask;
+ }
}
- }
- return result;
+ return result;
}
/* bitand
* truncated to the shorter bit string
*/
bits8 *
-bitand (bits8 * arg1, bits8 * arg2)
+bitand(bits8 *arg1, bits8 *arg2)
{
- int len,
- i;
- bits8 *result;
- bits8 *p1,
- *p2,
- *r;
-
- if (!PointerIsValid(arg1) || !PointerIsValid(arg2))
- return (bool) 0;
-
- len = Min(VARSIZE(arg1),VARSIZE(arg2));
- result = (bits8 *) palloc(len);
- VARSIZE(result) = len;
- VARBITLEN(result) = Min(VARBITLEN(arg1),VARBITLEN(arg2));
-
- p1 = (bits8 *) VARBITS(arg1);
- p2 = (bits8 *) VARBITS(arg2);
- r = (bits8 *) VARBITS(result);
- for (i=0; i<Min(VARBITBYTES(arg1),VARBITBYTES(arg2)); i++)
- *r++ = *p1++ & *p2++;
-
- /* Padding is not needed as & of 0 pad is 0 */
-
- return result;
+ int len,
+ i;
+ bits8 *result;
+ bits8 *p1,
+ *p2,
+ *r;
+
+ if (!PointerIsValid(arg1) || !PointerIsValid(arg2))
+ return (bool) 0;
+
+ len = Min(VARSIZE(arg1), VARSIZE(arg2));
+ result = (bits8 *) palloc(len);
+ VARSIZE(result) = len;
+ VARBITLEN(result) = Min(VARBITLEN(arg1), VARBITLEN(arg2));
+
+ p1 = (bits8 *) VARBITS(arg1);
+ p2 = (bits8 *) VARBITS(arg2);
+ r = (bits8 *) VARBITS(result);
+ for (i = 0; i < Min(VARBITBYTES(arg1), VARBITBYTES(arg2)); i++)
+ *r++ = *p1++ & *p2++;
+
+ /* Padding is not needed as & of 0 pad is 0 */
+
+ return result;
}
/* bitor
* truncated to the shorter bit string.
*/
bits8 *
-bitor (bits8 * arg1, bits8 * arg2)
+bitor(bits8 *arg1, bits8 *arg2)
{
- int len,
- i;
- bits8 *result;
- bits8 *p1,
- *p2,
- *r;
- bits8 mask;
-
- if (!PointerIsValid(arg1) || !PointerIsValid(arg2))
- return (bool) 0;
-
- len = Min(VARSIZE(arg1),VARSIZE(arg2));
- result = (bits8 *) palloc(len);
- VARSIZE(result) = len;
- VARBITLEN(result) = Min(VARBITLEN(arg1),VARBITLEN(arg2));
-
- p1 = (bits8 *) VARBITS(arg1);
- p2 = (bits8 *) VARBITS(arg2);
- r = (bits8 *) VARBITS(result);
- for (i=0; i<Min(VARBITBYTES(arg1),VARBITBYTES(arg2)); i++)
- *r++ = *p1++ | *p2++;
-
- /* Pad the result */
- mask = BITMASK << VARBITPAD(result);
- *r &= mask;
-
- return result;
+ int len,
+ i;
+ bits8 *result;
+ bits8 *p1,
+ *p2,
+ *r;
+ bits8 mask;
+
+ if (!PointerIsValid(arg1) || !PointerIsValid(arg2))
+ return (bool) 0;
+
+ len = Min(VARSIZE(arg1), VARSIZE(arg2));
+ result = (bits8 *) palloc(len);
+ VARSIZE(result) = len;
+ VARBITLEN(result) = Min(VARBITLEN(arg1), VARBITLEN(arg2));
+
+ p1 = (bits8 *) VARBITS(arg1);
+ p2 = (bits8 *) VARBITS(arg2);
+ r = (bits8 *) VARBITS(result);
+ for (i = 0; i < Min(VARBITBYTES(arg1), VARBITBYTES(arg2)); i++)
+ *r++ = *p1++ | *p2++;
+
+ /* Pad the result */
+ mask = BITMASK << VARBITPAD(result);
+ *r &= mask;
+
+ return result;
}
/* bitxor
* truncated to the shorter bit string.
*/
bits8 *
-bitxor (bits8 * arg1, bits8 * arg2)
+bitxor(bits8 *arg1, bits8 *arg2)
{
- int len,
- i;
- bits8 *result;
- bits8 *p1,
- *p2,
- *r;
- bits8 mask;
-
- if (!PointerIsValid(arg1) || !PointerIsValid(arg2))
- return (bool) 0;
-
- len = Min(VARSIZE(arg1),VARSIZE(arg2));
- result = (bits8 *) palloc(len);
- VARSIZE(result) = len;
- VARBITLEN(result) = Min(VARBITLEN(arg1),VARBITLEN(arg2));
-
- p1 = (bits8 *) VARBITS(arg1);
- p2 = (bits8 *) VARBITS(arg2);
- r = (bits8 *) VARBITS(result);
- for (i=0; i<Min(VARBITBYTES(arg1),VARBITBYTES(arg2)); i++)
- {
- *r++ = *p1++ ^ *p2++;
- }
-
- /* Pad the result */
- mask = BITMASK << VARBITPAD(result);
- *r &= mask;
-
- return result;
+ int len,
+ i;
+ bits8 *result;
+ bits8 *p1,
+ *p2,
+ *r;
+ bits8 mask;
+
+ if (!PointerIsValid(arg1) || !PointerIsValid(arg2))
+ return (bool) 0;
+
+ len = Min(VARSIZE(arg1), VARSIZE(arg2));
+ result = (bits8 *) palloc(len);
+ VARSIZE(result) = len;
+ VARBITLEN(result) = Min(VARBITLEN(arg1), VARBITLEN(arg2));
+
+ p1 = (bits8 *) VARBITS(arg1);
+ p2 = (bits8 *) VARBITS(arg2);
+ r = (bits8 *) VARBITS(result);
+ for (i = 0; i < Min(VARBITBYTES(arg1), VARBITBYTES(arg2)); i++)
+ *r++ = *p1++ ^ *p2++;
+
+ /* Pad the result */
+ mask = BITMASK << VARBITPAD(result);
+ *r &= mask;
+
+ return result;
}
/* bitnot
* perform a logical NOT on a bit strings.
*/
bits8 *
-bitnot (bits8 * arg)
+bitnot(bits8 *arg)
{
- bits8 *result;
- bits8 *p,
- *r;
- bits8 mask;
-
- if (!PointerIsValid(arg))
- return (bool) 0;
-
- result = (bits8 *) palloc(VARSIZE(arg));
- VARSIZE(result) = VARSIZE(arg);
- VARBITLEN(result) = VARBITLEN(arg);
-
- p = (bits8 *) VARBITS(arg);
- r = (bits8 *) VARBITS(result);
- for ( ; p < VARBITEND(arg); p++, r++)
- *r = ~*p;
-
- /* Pad the result */
- mask = BITMASK << VARBITPAD(result);
- *r &= mask;
-
- return result;
+ bits8 *result;
+ bits8 *p,
+ *r;
+ bits8 mask;
+
+ if (!PointerIsValid(arg))
+ return (bool) 0;
+
+ result = (bits8 *) palloc(VARSIZE(arg));
+ VARSIZE(result) = VARSIZE(arg);
+ VARBITLEN(result) = VARBITLEN(arg);
+
+ p = (bits8 *) VARBITS(arg);
+ r = (bits8 *) VARBITS(result);
+ for (; p < VARBITEND(arg); p++, r++)
+ *r = ~*p;
+
+ /* Pad the result */
+ mask = BITMASK << VARBITPAD(result);
+ *r &= mask;
+
+ return result;
}
/* bitshiftleft
* do a left shift (i.e. to the beginning of the string) of the bit string
*/
bits8 *
-bitshiftleft (bits8 * arg, int shft)
+bitshiftleft(bits8 *arg, int shft)
{
- int byte_shift, ishift, len;
- bits8 *result;
- bits8 *p,
- *r;
-
- if (!PointerIsValid(arg))
- return (bool) 0;
-
- /* Negative shift is a shift to the right */
- if (shft < 0)
- return bitshiftright(arg, -shft);
-
- result = (bits8 *) palloc(VARSIZE(arg));
- VARSIZE(result) = VARSIZE(arg);
- VARBITLEN(result) = VARBITLEN(arg);
- r = (bits8 *) VARBITS(result);
-
- byte_shift = shft/BITSPERBYTE;
- ishift = shft % BITSPERBYTE;
- p = ((bits8 *) VARBITS(arg)) + byte_shift;
-
- if (ishift == 0) {
- /* Special case: we can do a memcpy */
- len = VARBITBYTES(arg) - byte_shift;
- memcpy(r, p, len);
- memset(r+len, 0, byte_shift);
- } else {
- for ( ; p < VARBITEND(arg); r++) {
- *r = *p <<ishift;
- if ((++p) < VARBITEND(arg))
- *r |= *p >>(BITSPERBYTE-ishift);
- }
- for ( ; r < VARBITEND(result) ; r++ )
- *r = (bits8) 0;
- }
-
- return result;
+ int byte_shift,
+ ishift,
+ len;
+ bits8 *result;
+ bits8 *p,
+ *r;
+
+ if (!PointerIsValid(arg))
+ return (bool) 0;
+
+ /* Negative shift is a shift to the right */
+ if (shft < 0)
+ return bitshiftright(arg, -shft);
+
+ result = (bits8 *) palloc(VARSIZE(arg));
+ VARSIZE(result) = VARSIZE(arg);
+ VARBITLEN(result) = VARBITLEN(arg);
+ r = (bits8 *) VARBITS(result);
+
+ byte_shift = shft / BITSPERBYTE;
+ ishift = shft % BITSPERBYTE;
+ p = ((bits8 *) VARBITS(arg)) + byte_shift;
+
+ if (ishift == 0)
+ {
+ /* Special case: we can do a memcpy */
+ len = VARBITBYTES(arg) - byte_shift;
+ memcpy(r, p, len);
+ memset(r + len, 0, byte_shift);
+ }
+ else
+ {
+ for (; p < VARBITEND(arg); r++)
+ {
+ *r = *p << ishift;
+ if ((++p) < VARBITEND(arg))
+ *r |= *p >> (BITSPERBYTE - ishift);
+ }
+ for (; r < VARBITEND(result); r++)
+ *r = (bits8) 0;
+ }
+
+ return result;
}
/* bitshiftright
* do a right shift (i.e. to the beginning of the string) of the bit string
*/
bits8 *
-bitshiftright (bits8 * arg, int shft)
+bitshiftright(bits8 *arg, int shft)
{
- int byte_shift, ishift, len;
- bits8 *result;
- bits8 *p,
- *r;
-
- if (!PointerIsValid(arg))
- return (bits8 *) 0;
-
- /* Negative shift is a shift to the left */
- if (shft < 0)
- return bitshiftleft(arg, -shft);
-
- result = (bits8 *) palloc(VARSIZE(arg));
- VARSIZE(result) = VARSIZE(arg);
- VARBITLEN(result) = VARBITLEN(arg);
- r = (bits8 *) VARBITS(result);
-
- byte_shift = shft/BITSPERBYTE;
- ishift = shft % BITSPERBYTE;
- p = (bits8 *) VARBITS(arg);
-
- /* Set the first part of the result to 0 */
- memset(r, 0, byte_shift);
-
- if (ishift == 0)
- {
- /* Special case: we can do a memcpy */
- len = VARBITBYTES(arg) - byte_shift;
- memcpy(r+byte_shift, p, len);
- }
- else
- {
- r += byte_shift;
- *r = 0; /* Initialise first byte */
- for ( ; r < VARBITEND(result); p++) {
- *r |= *p >> ishift;
- if ((++r) < VARBITEND(result))
- *r = (*p <<(BITSPERBYTE-ishift)) & BITMASK;
- }
- }
-
- return result;
+ int byte_shift,
+ ishift,
+ len;
+ bits8 *result;
+ bits8 *p,
+ *r;
+
+ if (!PointerIsValid(arg))
+ return (bits8 *) 0;
+
+ /* Negative shift is a shift to the left */
+ if (shft < 0)
+ return bitshiftleft(arg, -shft);
+
+ result = (bits8 *) palloc(VARSIZE(arg));
+ VARSIZE(result) = VARSIZE(arg);
+ VARBITLEN(result) = VARBITLEN(arg);
+ r = (bits8 *) VARBITS(result);
+
+ byte_shift = shft / BITSPERBYTE;
+ ishift = shft % BITSPERBYTE;
+ p = (bits8 *) VARBITS(arg);
+
+ /* Set the first part of the result to 0 */
+ memset(r, 0, byte_shift);
+
+ if (ishift == 0)
+ {
+ /* Special case: we can do a memcpy */
+ len = VARBITBYTES(arg) - byte_shift;
+ memcpy(r + byte_shift, p, len);
+ }
+ else
+ {
+ r += byte_shift;
+ *r = 0; /* Initialise first byte */
+ for (; r < VARBITEND(result); p++)
+ {
+ *r |= *p >> ishift;
+ if ((++r) < VARBITEND(result))
+ *r = (*p << (BITSPERBYTE - ishift)) & BITMASK;
+ }
+ }
+
+ return result;
}
#include <ctype.h>
#include <errno.h>
-#include <float.h> /* faked on sunos4 */
+#include <float.h> /* faked on sunos4 */
#include <math.h>
#ifdef HAVE_LIMITS_H
#include <limits.h>
#ifndef MAXINT
-#define MAXINT INT_MAX
+#define MAXINT INT_MAX
#endif
#else
#ifdef HAVE_VALUES_H
#include "utils/builtins.h"
-#define HEXDIG(z) (z)<10 ? ((z)+'0') : ((z)-10+'A')
+#define HEXDIG(z) (z)<10 ? ((z)+'0') : ((z)-10+'A')
/* Modeled on struct varlena from postgres.h, bu data type is bits8 */
struct varbita
#define VARBITEND(PTR) ((bits8 *) (PTR + VARSIZE(PTR)))
/* Mask that will cover exactly one byte, i.e. BITSPERBYTE bits */
#define BITMASK 0xFF
-#define BITHIGH 0x80
+#define BITHIGH 0x80
-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);
+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);
#include "varbit.h"
-bits8 * varbit_in (char * s);
-char * varbit_out (bits8 *s);
+bits8 *varbit_in(char *s);
+char *varbit_out(bits8 *s);
bits8 *
-varbit_in (char * s) {
- return varbitin (s, 0, -1);
+varbit_in(char *s)
+{
+ return varbitin(s, 0, -1);
}
-/*char *
+/*char *
varbit_out (bits8 *s) {
return zpbitout(s);
}
*/
-char *
-varbit_out (bits8 *s) {
- return zpbitsout(s);
+char *
+varbit_out(bits8 *s)
+{
+ return zpbitsout(s);
}
#include "varbit.h"
#include <stdio.h>
-void print_details (unsigned char *s);
+void print_details(unsigned char *s);
+
+const int numb = 8;
-const int numb = 8;
/*
const char *b[] = { "B0010", "B11011011", "B0001", "X3F12", "X27", "B",
- "X11", "B100111"};
+ "X11", "B100111"};
int atttypmod[] = {-1, -1, -1,-1,-1,-1,-1,-1 };
*/
-const char *b[] = { "B0010", "B11011011", "B10001", "X3D12", "X27", "B",
- "X11", "B100111"};
-int atttypmod[] = { 7, 9, 6, 18, 11, 6, -1, -1 };
+const char *b[] = {"B0010", "B11011011", "B10001", "X3D12", "X27", "B",
+"X11", "B100111"};
+int atttypmod[] = {7, 9, 6, 18, 11, 6, -1, -1};
-void print_details (unsigned char *s)
+void
+print_details(unsigned char *s)
{
- int i;
- printf ("Length in bytes : %d\n",VARSIZE(s));
- printf ("Length of bitstring: %d\n",VARBITLEN(s));
- for (i=8; i<VARSIZE(s); i++)
- printf ("%X%X ",s[i]>>4,s[i]&0xF);
- printf("\n");
+ int i;
+
+ printf("Length in bytes : %d\n", VARSIZE(s));
+ printf("Length of bitstring: %d\n", VARBITLEN(s));
+ for (i = 8; i < VARSIZE(s); i++)
+ printf("%X%X ", s[i] >> 4, s[i] & 0xF);
+ printf("\n");
}
int
-main ()
+main()
{
- int i, j;
- char *s[numb];
-
- for (i=0; i<numb; i++) {
- printf ("Input: %s\n",b[i]);
- s[i] = zpbitin(b[i], 0, atttypmod[i]);
- //print_details(s[i]);
- printf ("%s = %s\n",zpbitout(s[i]),zpbitsout(s[i]));
- }
-
- printf ("\nCOMPARISONS:\n");
- for (i=0; i<numb; i++)
- for (j=i+1; j<numb; j++)
- printf("%s <=> %s = %d\n",zpbitsout(s[i]),zpbitsout(s[j]),
- bitcmp(s[i],s[j]));
-
- printf ("\nCONCATENATION:\n");
- for (i=0; i<numb; i++)
- for (j=i+1; j<numb; j++)
- printf("%s || %s = %s\n",zpbitsout(s[i]),zpbitsout(s[j]),
- zpbitsout(bitcat(s[i],s[j])));
-
- printf("\nSUBSTR:\n");
- printf("%s (%d,%d) => %s\n",zpbitsout(s[3]),1,8,
- 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,
- zpbitsout(bitsubstr(s[3],1,9)));
- 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,
- zpbitsout(bitsubstr(s[3],3,9)));
- 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++)
- for (j=i+1; j<numb; j++)
- printf("%s & %s = %s\n",zpbitsout(s[i]),zpbitsout(s[j]),
- zpbitsout(bitand(s[i],s[j])));
-
- printf ("\nLOGICAL OR:\n");
- for (i=0; i<numb; i++)
- for (j=i+1; j<numb; j++)
- printf("%s | %s = %s\n",zpbitsout(s[i]),zpbitsout(s[j]),
- zpbitsout(bitor(s[i],s[j])));
-
- printf ("\nLOGICAL XOR:\n");
- for (i=0; i<numb; i++)
- for (j=i+1; j<numb; j++)
- printf("%s ^ %s = %s\n",zpbitsout(s[i]),zpbitsout(s[j]),
- zpbitsout(bitxor(s[i],s[j])));
-
- printf ("\nLOGICAL NOT:\n");
- for (i=0; i<numb; i++)
- printf("~%s = %s\n",zpbitsout(s[i]),zpbitsout(bitnot(s[i])));
-
-
- printf ("\nSHIFT LEFT:\n");
- for (i=0; i<numb; i++) {
- printf("%s\n",zpbitsout(s[i]));
- for (j=0; j<=VARBITLEN(s[i]); j++)
- printf("\t%3d\t%s\n",j,zpbitsout(bitshiftleft(s[i],j)));
- }
-
- printf ("\nSHIFT RIGHT:\n");
- for (i=0; i<numb; i++) {
- printf("%s\n",zpbitsout(s[i]));
- for (j=0; j<=VARBITLEN(s[i]); j++)
- printf("\t%3d\t%s\n",j,zpbitsout(bitshiftright(s[i],j)));
- }
-
- printf ("\n\n ********** VARYING **********\n");
- for (i=0; i<numb; i++) {
- printf ("Input: %s\n",b[i]);
- s[i] = varbitin(b[i], 0, atttypmod[i]);
- /*print_details(s);*/
- printf ("%s\n",zpbitout(s[i]));
- printf ("%s\n",zpbitsout(s[i]));
- }
-
- printf ("\nCOMPARISONS:\n");
- for (i=0; i<numb; i++)
- for (j=i+1; j<numb; j++)
- printf("%s <=> %s = %d\n",zpbitsout(s[i]),zpbitsout(s[j]),
- bitcmp(s[i],s[j]));
-
- printf ("\nCONCATENATION:\n");
- for (i=0; i<numb; i++)
- for (j=i+1; j<numb; j++)
- printf("%s || %s = %s\n",zpbitsout(s[i]),zpbitsout(s[j]),
- zpbitsout(bitcat(s[i],s[j])));
-
- printf("\nSUBSTR:\n");
- printf("%s (%d,%d) => %s\n",zpbitsout(s[3]),1,8,
- 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,
- zpbitsout(bitsubstr(s[3],1,9)));
- 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,
- zpbitsout(bitsubstr(s[3],3,9)));
- 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++)
- printf("%s & %s = %s\n",zpbitsout(s[i]),zpbitsout(s[j]),
- zpbitsout(bitand(s[i],s[j])));
-
- printf ("\nLOGICAL OR:\n");
- for (i=0; i<numb; i++)
- for (j=i+1; j<numb; j++)
- printf("%s | %s = %s\n",zpbitsout(s[i]),zpbitsout(s[j]),
- zpbitsout(bitor(s[i],s[j])));
-
- printf ("\nLOGICAL XOR:\n");
- for (i=0; i<numb; i++)
- for (j=i+1; j<numb; j++)
- printf("%s ^ %s = %s\n",zpbitsout(s[i]),zpbitsout(s[j]),
- zpbitsout(bitxor(s[i],s[j])));
-
- printf ("\nLOGICAL NOT:\n");
- for (i=0; i<numb; i++)
- printf("~%s = %s\n",zpbitsout(s[i]),zpbitsout(bitnot(s[i])));
-
-
- printf ("\nSHIFT LEFT:\n");
- for (i=0; i<numb; i++) {
- printf("%s\n",zpbitsout(s[i]));
- for (j=0; j<=VARBITLEN(s[i]); j++)
- printf("\t%3d\t%s\n",j,zpbitsout(bitshiftleft(s[i],j)));
- }
-
- printf ("\nSHIFT RIGHT:\n");
- for (i=0; i<numb; i++) {
- printf("%s\n",zpbitsout(s[i]));
- for (j=0; j<=VARBITLEN(s[i]); j++)
- printf("\t%3d\t%s\n",j,zpbitsout(bitshiftright(s[i],j)));
- }
+ int i,
+ j;
+ char *s[numb];
+
+ for (i = 0; i < numb; i++)
+ {
+ printf("Input: %s\n", b[i]);
+ s[i] = zpbitin(b[i], 0, atttypmod[i]);
+ //print_details(s[i]);
+ printf("%s = %s\n", zpbitout(s[i]), zpbitsout(s[i]));
+ }
+
+ printf("\nCOMPARISONS:\n");
+ for (i = 0; i < numb; i++)
+ for (j = i + 1; j < numb; j++)
+ printf("%s <=> %s = %d\n", zpbitsout(s[i]), zpbitsout(s[j]),
+ bitcmp(s[i], s[j]));
+
+ printf("\nCONCATENATION:\n");
+ for (i = 0; i < numb; i++)
+ for (j = i + 1; j < numb; j++)
+ printf("%s || %s = %s\n", zpbitsout(s[i]), zpbitsout(s[j]),
+ zpbitsout(bitcat(s[i], s[j])));
+
+ printf("\nSUBSTR:\n");
+ printf("%s (%d,%d) => %s\n", zpbitsout(s[3]), 1, 8,
+ 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,
+ zpbitsout(bitsubstr(s[3], 1, 9)));
+ 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,
+ zpbitsout(bitsubstr(s[3], 3, 9)));
+ 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++)
+ for (j = i + 1; j < numb; j++)
+ printf("%s & %s = %s\n", zpbitsout(s[i]), zpbitsout(s[j]),
+ zpbitsout(bitand(s[i], s[j])));
+
+ printf("\nLOGICAL OR:\n");
+ for (i = 0; i < numb; i++)
+ for (j = i + 1; j < numb; j++)
+ printf("%s | %s = %s\n", zpbitsout(s[i]), zpbitsout(s[j]),
+ zpbitsout(bitor(s[i], s[j])));
+
+ printf("\nLOGICAL XOR:\n");
+ for (i = 0; i < numb; i++)
+ for (j = i + 1; j < numb; j++)
+ printf("%s ^ %s = %s\n", zpbitsout(s[i]), zpbitsout(s[j]),
+ zpbitsout(bitxor(s[i], s[j])));
+
+ printf("\nLOGICAL NOT:\n");
+ for (i = 0; i < numb; i++)
+ printf("~%s = %s\n", zpbitsout(s[i]), zpbitsout(bitnot(s[i])));
+
+
+ printf("\nSHIFT LEFT:\n");
+ for (i = 0; i < numb; i++)
+ {
+ printf("%s\n", zpbitsout(s[i]));
+ for (j = 0; j <= VARBITLEN(s[i]); j++)
+ printf("\t%3d\t%s\n", j, zpbitsout(bitshiftleft(s[i], j)));
+ }
+
+ printf("\nSHIFT RIGHT:\n");
+ for (i = 0; i < numb; i++)
+ {
+ printf("%s\n", zpbitsout(s[i]));
+ for (j = 0; j <= VARBITLEN(s[i]); j++)
+ printf("\t%3d\t%s\n", j, zpbitsout(bitshiftright(s[i], j)));
+ }
+
+ printf("\n\n ********** VARYING **********\n");
+ for (i = 0; i < numb; i++)
+ {
+ printf("Input: %s\n", b[i]);
+ s[i] = varbitin(b[i], 0, atttypmod[i]);
+ /* print_details(s); */
+ printf("%s\n", zpbitout(s[i]));
+ printf("%s\n", zpbitsout(s[i]));
+ }
+
+ printf("\nCOMPARISONS:\n");
+ for (i = 0; i < numb; i++)
+ for (j = i + 1; j < numb; j++)
+ printf("%s <=> %s = %d\n", zpbitsout(s[i]), zpbitsout(s[j]),
+ bitcmp(s[i], s[j]));
+
+ printf("\nCONCATENATION:\n");
+ for (i = 0; i < numb; i++)
+ for (j = i + 1; j < numb; j++)
+ printf("%s || %s = %s\n", zpbitsout(s[i]), zpbitsout(s[j]),
+ zpbitsout(bitcat(s[i], s[j])));
+
+ printf("\nSUBSTR:\n");
+ printf("%s (%d,%d) => %s\n", zpbitsout(s[3]), 1, 8,
+ 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,
+ zpbitsout(bitsubstr(s[3], 1, 9)));
+ 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,
+ zpbitsout(bitsubstr(s[3], 3, 9)));
+ 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++)
+ printf("%s & %s = %s\n", zpbitsout(s[i]), zpbitsout(s[j]),
+ zpbitsout(bitand(s[i], s[j])));
+
+ printf("\nLOGICAL OR:\n");
+ for (i = 0; i < numb; i++)
+ for (j = i + 1; j < numb; j++)
+ printf("%s | %s = %s\n", zpbitsout(s[i]), zpbitsout(s[j]),
+ zpbitsout(bitor(s[i], s[j])));
+
+ printf("\nLOGICAL XOR:\n");
+ for (i = 0; i < numb; i++)
+ for (j = i + 1; j < numb; j++)
+ printf("%s ^ %s = %s\n", zpbitsout(s[i]), zpbitsout(s[j]),
+ zpbitsout(bitxor(s[i], s[j])));
+
+ printf("\nLOGICAL NOT:\n");
+ for (i = 0; i < numb; i++)
+ printf("~%s = %s\n", zpbitsout(s[i]), zpbitsout(bitnot(s[i])));
+
+
+ printf("\nSHIFT LEFT:\n");
+ for (i = 0; i < numb; i++)
+ {
+ printf("%s\n", zpbitsout(s[i]));
+ for (j = 0; j <= VARBITLEN(s[i]); j++)
+ printf("\t%3d\t%s\n", j, zpbitsout(bitshiftleft(s[i], j)));
+ }
+
+ printf("\nSHIFT RIGHT:\n");
+ for (i = 0; i < numb; i++)
+ {
+ printf("%s\n", zpbitsout(s[i]));
+ for (j = 0; j <= VARBITLEN(s[i]); j++)
+ printf("\t%3d\t%s\n", j, zpbitsout(bitshiftright(s[i], j)));
+ }
}
* Decode time string 00:00:00 through 24:00:00.
*/
static int
-decode_24h_time(char *str, struct tm *tm, double *fsec)
+decode_24h_time(char *str, struct tm * tm, double *fsec)
{
char *cp;
*fsec = 0;
}
else if (*cp != ':')
- {
return -1;
- }
else
{
str = cp + 1;
}
/* do a sanity check */
- if ( (tm->tm_hour < 0) || (tm->tm_hour > 24)
- || (tm->tm_min < 0) || (tm->tm_min > 59)
- || (tm->tm_sec < 0) || (tm->tm_sec > 59)
- || (*fsec < 0) )
+ if ((tm->tm_hour < 0) || (tm->tm_hour > 24)
+ || (tm->tm_min < 0) || (tm->tm_min > 59)
+ || (tm->tm_sec < 0) || (tm->tm_sec > 59)
+ || (*fsec < 0))
return -1;
return 0;
int4
date2mjd(DateADT val)
{
- int result;
+ int result;
result = val + JDATE_2000 - 2400000.5;
/*
* Local Variables:
- * tab-width: 4
- * c-indent-level: 4
- * c-basic-offset: 4
+ * tab-width: 4
+ * c-indent-level: 4
+ * c-basic-offset: 4
* End:
*/
/*
* Local Variables:
- * tab-width: 4
- * c-indent-level: 4
- * c-basic-offset: 4
+ * tab-width: 4
+ * c-indent-level: 4
+ * c-basic-offset: 4
* End:
*/
#ifdef ASSERT_CHECKING_TEST
extern int assertEnable(int val);
+
#endif
int
ScanKeyData key;
Datum d;
bool isnull;
- int len, pid;
+ int len,
+ pid;
int count = 0;
int ourpid = getpid();
char listen_name[NAMEDATALEN];
lRel = heap_openr(ListenerRelationName, AccessShareLock);
tdesc = RelationGetDescr(lRel);
- if (relname && (VARSIZE(relname) > VARHDRSZ)) {
- len = MIN(VARSIZE(relname)-VARHDRSZ, NAMEDATALEN-1);
+ if (relname && (VARSIZE(relname) > VARHDRSZ))
+ {
+ len = MIN(VARSIZE(relname) - VARHDRSZ, NAMEDATALEN - 1);
strncpy(listen_name, VARDATA(relname), len);
listen_name[len] = '\0';
ScanKeyEntryInitialize(&key, 0,
F_NAMEEQ,
PointerGetDatum(listen_name));
sRel = heap_beginscan(lRel, 0, SnapshotNow, 1, &key);
- } else {
- sRel = heap_beginscan(lRel, 0, SnapshotNow, 0, (ScanKey)NULL);
}
+ else
+ sRel = heap_beginscan(lRel, 0, SnapshotNow, 0, (ScanKey) NULL);
while (HeapTupleIsValid(lTuple = heap_getnext(sRel, 0)))
{
d = heap_getattr(lTuple, Anum_pg_listener_pid, tdesc, &isnull);
pid = DatumGetInt32(d);
- if ((pid == ourpid) || (kill(pid, SIGTSTP) == 0)) {
+ if ((pid == ourpid) || (kill(pid, SIGTSTP) == 0))
+ {
/* elog(NOTICE, "%d ok", pid); */
count++;
}
{
return assertTest(val);
}
+
#endif
#endif
/*
* Local Variables:
- * tab-width: 4
- * c-indent-level: 4
- * c-basic-offset: 4
+ * tab-width: 4
+ * c-indent-level: 4
+ * c-basic-offset: 4
* End:
*/
#ifdef USE_ASSERT_CHECKING
int assert_enable(int val);
+
#ifdef ASSERT_CHECKING_TEST
int assert_test(int val);
+
#endif
#endif
/*
* Local Variables:
- * tab-width: 4
- * c-indent-level: 4
- * c-basic-offset: 4
+ * tab-width: 4
+ * c-indent-level: 4
+ * c-basic-offset: 4
* End:
*/
* DEF_PGPORT is the TCP port number on which the Postmaster listens by
* default. This can be overriden by command options, environment variables,
* and the postconfig hook. (set by build script)
- */\r
+ */\r
\r
#define DEF_PGPORT "5432"\r
\r
/*
- * $Header: /cvsroot/pgsql/contrib/pgbench/pgbench.c,v 1.2 2000/04/08 18:32:24 tgl Exp $
+ * $Header: /cvsroot/pgsql/contrib/pgbench/pgbench.c,v 1.3 2000/04/12 17:14:27 momjian Exp $
*
* pgbench: a simple TPC-B like benchmark program for PostgreSQL
* written by Tatsuo Ishii
/********************************************************************
* some configurable parameters */
-#define MAXCLIENTS 1024 /* max number of clients allowed */
+#define MAXCLIENTS 1024 /* max number of clients allowed */
-int nclients = 1; /* default number of simulated clients */
-int nxacts = 10; /* default number of transactions per clients */
+int nclients = 1; /* default number of simulated clients */
+int nxacts = 10; /* default number of transactions per
+ * clients */
/*
* scaling factor. for example, tps = 10 will make 1000000 tuples of
* accounts table.
*/
-int tps = 1;
+int tps = 1;
/*
* end of configurable parameters
#define nbranches 1
#define ntellers 10
-#define naccounts 100000
-
-int remains; /* number of remained clients */
-
-typedef struct {
- PGconn *con; /* connection handle to DB */
- int state; /* state No. */
- int cnt; /* xacts count */
- int ecnt; /* error count */
- int listen; /* none 0 indicates that an async query has been sent */
- int aid; /* account id for this transaction */
- int bid; /* branch id for this transaction */
- int tid; /* teller id for this transaction */
- int delta;
- int abalance;
-} CState;
-
-static void usage() {
- fprintf(stderr,"usage: pgbench [-h hostname][-p port][-c nclients][-t ntransactions][-s scaling_factor][-n][-v][-S][-d][dbname]\n");
- fprintf(stderr,"(initialize mode): pgbench -i [-h hostname][-p port][-s scaling_factor][-d][dbname]\n");
+#define naccounts 100000
+
+int remains; /* number of remained clients */
+
+typedef struct
+{
+ PGconn *con; /* connection handle to DB */
+ int state; /* state No. */
+ int cnt; /* xacts count */
+ int ecnt; /* error count */
+ int listen; /* none 0 indicates that an async query
+ * has been sent */
+ int aid; /* account id for this transaction */
+ int bid; /* branch id for this transaction */
+ int tid; /* teller id for this transaction */
+ int delta;
+ int abalance;
+} CState;
+
+static void
+usage()
+{
+ fprintf(stderr, "usage: pgbench [-h hostname][-p port][-c nclients][-t ntransactions][-s scaling_factor][-n][-v][-S][-d][dbname]\n");
+ fprintf(stderr, "(initialize mode): pgbench -i [-h hostname][-p port][-s scaling_factor][-d][dbname]\n");
}
/* random number generator */
-static int getrand(int min, int max) {
- return(min+(int)(max*1.0*rand()/(RAND_MAX+1.0)));
+static int
+getrand(int min, int max)
+{
+ return (min + (int) (max * 1.0 * rand() / (RAND_MAX + 1.0)));
}
/* throw away response from backend */
-static void discard_response(CState *state) {
- PGresult *res;
- do {
- res = PQgetResult(state->con);
- if (res)
- PQclear(res);
- } while(res);
+static void
+discard_response(CState * state)
+{
+ PGresult *res;
+
+ do
+ {
+ res = PQgetResult(state->con);
+ if (res)
+ PQclear(res);
+ } while (res);
}
-static int check(CState *state, PGresult *res, int n, int good)
+static int
+check(CState * state, PGresult *res, int n, int good)
{
- CState *st = &state[n];
-
- if (res && PQresultStatus(res) != good) {
- fprintf(stderr,"Client %d aborted in state %d: %s",n,st->state,PQerrorMessage(st->con));
- remains--; /* I've aborted */
- PQfinish(st->con);
- st->con = NULL;
- return(-1);
- }
- return(0);
+ CState *st = &state[n];
+
+ if (res && PQresultStatus(res) != good)
+ {
+ fprintf(stderr, "Client %d aborted in state %d: %s", n, st->state, PQerrorMessage(st->con));
+ remains--; /* I've aborted */
+ PQfinish(st->con);
+ st->con = NULL;
+ return (-1);
+ }
+ return (0);
}
/* process a transaction */
-static void doOne(CState *state, int n, int debug) {
- char sql[256];
- PGresult *res;
- CState *st = &state[n];
-
- if (st->listen) { /* are we receiver? */
- if (debug) {
- fprintf(stderr,"client %d receiving\n",n);
- }
- while (PQisBusy(st->con) == TRUE) {
- if (!PQconsumeInput(st->con)) { /* there's something wrong */
- fprintf(stderr, "Client %d aborted in state %d. Probably the backend died while processing.\n",n, st->state);
- remains--; /* I've aborted */
- PQfinish(st->con);
- st->con = NULL;
- return;
- }
- }
-
- switch (st->state) {
- case 0: /* response to "begin" */
- res = PQgetResult(st->con);
- if (check(state, res, n, PGRES_COMMAND_OK)) {
- return;
- }
- PQclear(res);
- discard_response(st);
- break;
- case 1: /* response to "update accounts..." */
- res = PQgetResult(st->con);
- if (check(state, res, n, PGRES_COMMAND_OK)) {
- return;
- }
- PQclear(res);
- discard_response(st);
- break;
- case 2: /* response to "select abalance ..." */
- res = PQgetResult(st->con);
- if (check(state, res, n, PGRES_TUPLES_OK)) {
- return;
- }
- PQclear(res);
- discard_response(st);
- break;
- case 3: /* response to "update tellers ..." */
- res = PQgetResult(st->con);
- if (check(state, res, n, PGRES_COMMAND_OK)) {
- return;
- }
- PQclear(res);
- discard_response(st);
- break;
- case 4: /* response to "update branches ..." */
- res = PQgetResult(st->con);
- if (check(state, res, n, PGRES_COMMAND_OK)) {
- return;
- }
- PQclear(res);
- discard_response(st);
- break;
- case 5: /* response to "insert into history ..." */
- res = PQgetResult(st->con);
- if (check(state, res, n, PGRES_COMMAND_OK)) {
- return;
- }
- PQclear(res);
- discard_response(st);
- break;
- case 6: /* response to "end" */
- res = PQgetResult(st->con);
- if (check(state, res, n, PGRES_COMMAND_OK)) {
- return;
- }
- PQclear(res);
- discard_response(st);
-
- if (++st->cnt >= nxacts) {
- remains--; /* I've done */
- PQfinish(st->con);
- st->con = NULL;
- return;
- }
- break;
- }
-
- /* increment state counter */
- st->state++;
- if (st->state > 6) {
- st->state = 0;
- }
- }
-
- switch (st->state) {
- case 0: /* about to start */
- strcpy(sql,"begin");
- st->aid = getrand(1,naccounts*tps);
- st->bid = getrand(1,nbranches*tps);
- st->tid = getrand(1,ntellers*tps);
- st->delta = getrand(1,1000);
- break;
- case 1:
- sprintf(sql,"update accounts set abalance = abalance + %d where aid = %d\n",st->delta,st->aid);
- break;
- case 2:
- sprintf(sql,"select abalance from accounts where aid = %d",st->aid);
- break;
- case 3:
- sprintf(sql,"update tellers set tbalance = tbalance + %d where tid = %d\n",
- st->delta,st->tid);
- break;
- case 4:
- sprintf(sql,"update branches set bbalance = bbalance + %d where bid = %d",st->delta,st->bid);
- break;
- case 5:
- sprintf(sql,"insert into history(tid,bid,aid,delta,time) values(%d,%d,%d,%d,'now')",
- st->tid,st->bid,st->aid,st->delta);
- break;
- case 6:
- strcpy(sql,"end");
- break;
- }
-
- if (debug) {
- fprintf(stderr,"client %d sending %s\n",n,sql);
- }
- if (PQsendQuery(st->con, sql) == 0) {
- if (debug) {
- fprintf(stderr, "PQsendQuery(%s)failed\n",sql);
- }
- st->ecnt++;
- } else {
- st->listen++; /* flags that should be listned */
- }
+static void
+doOne(CState * state, int n, int debug)
+{
+ char sql[256];
+ PGresult *res;
+ CState *st = &state[n];
+
+ if (st->listen)
+ { /* are we receiver? */
+ if (debug)
+ fprintf(stderr, "client %d receiving\n", n);
+ while (PQisBusy(st->con) == TRUE)
+ {
+ if (!PQconsumeInput(st->con))
+ { /* there's something wrong */
+ fprintf(stderr, "Client %d aborted in state %d. Probably the backend died while processing.\n", n, st->state);
+ remains--; /* I've aborted */
+ PQfinish(st->con);
+ st->con = NULL;
+ return;
+ }
+ }
+
+ switch (st->state)
+ {
+ case 0: /* response to "begin" */
+ res = PQgetResult(st->con);
+ if (check(state, res, n, PGRES_COMMAND_OK))
+ return;
+ PQclear(res);
+ discard_response(st);
+ break;
+ case 1: /* response to "update accounts..." */
+ res = PQgetResult(st->con);
+ if (check(state, res, n, PGRES_COMMAND_OK))
+ return;
+ PQclear(res);
+ discard_response(st);
+ break;
+ case 2: /* response to "select abalance ..." */
+ res = PQgetResult(st->con);
+ if (check(state, res, n, PGRES_TUPLES_OK))
+ return;
+ PQclear(res);
+ discard_response(st);
+ break;
+ case 3: /* response to "update tellers ..." */
+ res = PQgetResult(st->con);
+ if (check(state, res, n, PGRES_COMMAND_OK))
+ return;
+ PQclear(res);
+ discard_response(st);
+ break;
+ case 4: /* response to "update branches ..." */
+ res = PQgetResult(st->con);
+ if (check(state, res, n, PGRES_COMMAND_OK))
+ return;
+ PQclear(res);
+ discard_response(st);
+ break;
+ case 5: /* response to "insert into history ..." */
+ res = PQgetResult(st->con);
+ if (check(state, res, n, PGRES_COMMAND_OK))
+ return;
+ PQclear(res);
+ discard_response(st);
+ break;
+ case 6: /* response to "end" */
+ res = PQgetResult(st->con);
+ if (check(state, res, n, PGRES_COMMAND_OK))
+ return;
+ PQclear(res);
+ discard_response(st);
+
+ if (++st->cnt >= nxacts)
+ {
+ remains--; /* I've done */
+ PQfinish(st->con);
+ st->con = NULL;
+ return;
+ }
+ break;
+ }
+
+ /* increment state counter */
+ st->state++;
+ if (st->state > 6)
+ st->state = 0;
+ }
+
+ switch (st->state)
+ {
+ case 0: /* about to start */
+ strcpy(sql, "begin");
+ st->aid = getrand(1, naccounts * tps);
+ st->bid = getrand(1, nbranches * tps);
+ st->tid = getrand(1, ntellers * tps);
+ st->delta = getrand(1, 1000);
+ break;
+ case 1:
+ sprintf(sql, "update accounts set abalance = abalance + %d where aid = %d\n", st->delta, st->aid);
+ break;
+ case 2:
+ sprintf(sql, "select abalance from accounts where aid = %d", st->aid);
+ break;
+ case 3:
+ sprintf(sql, "update tellers set tbalance = tbalance + %d where tid = %d\n",
+ st->delta, st->tid);
+ break;
+ case 4:
+ sprintf(sql, "update branches set bbalance = bbalance + %d where bid = %d", st->delta, st->bid);
+ break;
+ case 5:
+ sprintf(sql, "insert into history(tid,bid,aid,delta,time) values(%d,%d,%d,%d,'now')",
+ st->tid, st->bid, st->aid, st->delta);
+ break;
+ case 6:
+ strcpy(sql, "end");
+ break;
+ }
+
+ if (debug)
+ fprintf(stderr, "client %d sending %s\n", n, sql);
+ if (PQsendQuery(st->con, sql) == 0)
+ {
+ if (debug)
+ fprintf(stderr, "PQsendQuery(%s)failed\n", sql);
+ st->ecnt++;
+ }
+ else
+ {
+ st->listen++; /* flags that should be listned */
+ }
}
/* process a select only transaction */
-static void doSelectOnly(CState *state, int n, int debug) {
- char sql[256];
- PGresult *res;
- CState *st = &state[n];
-
- if (st->listen) { /* are we receiver? */
- if (debug) {
- fprintf(stderr,"client %d receiving\n",n);
- }
- while (PQisBusy(st->con) == TRUE) {
- if (!PQconsumeInput(st->con)) { /* there's something wrong */
- fprintf(stderr, "Client %d aborted in state %d. Probably the backend died while processing.\n",n, st->state);
- remains--; /* I've aborted */
- PQfinish(st->con);
- st->con = NULL;
- return;
- }
- }
-
- switch (st->state) {
- case 0: /* response to "select abalance ..." */
- res = PQgetResult(st->con);
- if (check(state, res, n, PGRES_TUPLES_OK)) {
- return;
- }
- PQclear(res);
- discard_response(st);
-
- if (++st->cnt >= nxacts) {
- remains--; /* I've done */
- PQfinish(st->con);
- st->con = NULL;
- return;
- }
- break;
- }
-
- /* increment state counter */
- st->state++;
- if (st->state > 0) {
- st->state = 0;
- }
- }
-
- switch (st->state) {
- case 0:
- st->aid = getrand(1,naccounts*tps);
- sprintf(sql,"select abalance from accounts where aid = %d",st->aid);
- break;
- }
-
- if (debug) {
- fprintf(stderr,"client %d sending %s\n",n,sql);
- }
-
- if (PQsendQuery(st->con, sql) == 0) {
- if (debug) {
- fprintf(stderr, "PQsendQuery(%s)failed\n",sql);
- }
- st->ecnt++;
- } else {
- st->listen++; /* flags that should be listned */
- }
+static void
+doSelectOnly(CState * state, int n, int debug)
+{
+ char sql[256];
+ PGresult *res;
+ CState *st = &state[n];
+
+ if (st->listen)
+ { /* are we receiver? */
+ if (debug)
+ fprintf(stderr, "client %d receiving\n", n);
+ while (PQisBusy(st->con) == TRUE)
+ {
+ if (!PQconsumeInput(st->con))
+ { /* there's something wrong */
+ fprintf(stderr, "Client %d aborted in state %d. Probably the backend died while processing.\n", n, st->state);
+ remains--; /* I've aborted */
+ PQfinish(st->con);
+ st->con = NULL;
+ return;
+ }
+ }
+
+ switch (st->state)
+ {
+ case 0: /* response to "select abalance ..." */
+ res = PQgetResult(st->con);
+ if (check(state, res, n, PGRES_TUPLES_OK))
+ return;
+ PQclear(res);
+ discard_response(st);
+
+ if (++st->cnt >= nxacts)
+ {
+ remains--; /* I've done */
+ PQfinish(st->con);
+ st->con = NULL;
+ return;
+ }
+ break;
+ }
+
+ /* increment state counter */
+ st->state++;
+ if (st->state > 0)
+ st->state = 0;
+ }
+
+ switch (st->state)
+ {
+ case 0:
+ st->aid = getrand(1, naccounts * tps);
+ sprintf(sql, "select abalance from accounts where aid = %d", st->aid);
+ break;
+ }
+
+ if (debug)
+ fprintf(stderr, "client %d sending %s\n", n, sql);
+
+ if (PQsendQuery(st->con, sql) == 0)
+ {
+ if (debug)
+ fprintf(stderr, "PQsendQuery(%s)failed\n", sql);
+ st->ecnt++;
+ }
+ else
+ {
+ st->listen++; /* flags that should be listned */
+ }
}
/* discard connections */
-static void disconnect_all(CState *state) {
- int i;
- for (i=0;i<nclients;i++) {
- if (state[i].con) {
- PQfinish(state[i].con);
- }
- }
+static void
+disconnect_all(CState * state)
+{
+ int i;
+
+ for (i = 0; i < nclients; i++)
+ {
+ if (state[i].con)
+ PQfinish(state[i].con);
+ }
}
/* create tables and setup data */
-static void init(char *pghost, char *pgport,char *dbName) {
- PGconn *con;
- PGresult *res;
- static char *DDLs[] = {
- "drop table branches",
- "create table branches(bid int, primary key(bid),bbalance int,filler char(88))",
- "drop table tellers",
- "create table tellers(tid int, primary key(tid),bid int,tbalance int,filler char(84))",
- "drop table accounts",
- "create table accounts(aid int,primary key(aid),bid int,abalance int,filler char(84))",
- "drop table history",
- "create table history(tid int,bid int,aid int,delta int,time timestamp,filler char(22))"};
- char sql[256];
-
- int i;
-
- con = PQsetdb(pghost, pgport, NULL, NULL, dbName);
- if (PQstatus(con) == CONNECTION_BAD) {
- fprintf(stderr, "Connection to database '%s' on %s failed.\n", dbName,pghost);
- fprintf(stderr, "%s", PQerrorMessage(con));
- exit(1);
- }
-
- for (i=0;i<(sizeof(DDLs)/sizeof(char *));i++) {
- res = PQexec(con,DDLs[i]);
- if (strncmp(DDLs[i],"drop",4) && PQresultStatus(res) != PGRES_COMMAND_OK) {
- fprintf(stderr, "%s", PQerrorMessage(con));
- exit(1);
- }
- PQclear(res);
- }
-
- res = PQexec(con,"begin");
- if (PQresultStatus(res) != PGRES_COMMAND_OK) {
- fprintf(stderr, "%s", PQerrorMessage(con));
- exit(1);
- }
-
- for(i = 0; i < nbranches * tps; i++) {
- sprintf(sql,"insert into branches(bid,bbalance) values(%d,0)",i+1);
- res = PQexec(con,sql);
- if (PQresultStatus(res) != PGRES_COMMAND_OK) {
- fprintf(stderr, "%s", PQerrorMessage(con));
- exit(1);
- }
- PQclear(res);
- }
-
- for(i = 0; i < ntellers * tps; i++) {
- sprintf(sql,"insert into tellers(tid,bid,tbalance) values (%d,%d,0)"
- ,i+1,i/ntellers+1);
- res = PQexec(con,sql);
- if (PQresultStatus(res) != PGRES_COMMAND_OK) {
- fprintf(stderr, "%s", PQerrorMessage(con));
- exit(1);
- }
- PQclear(res);
- }
-
- res = PQexec(con,"copy accounts from stdin");
- if (PQresultStatus(res) != PGRES_COPY_IN) {
- fprintf(stderr, "%s", PQerrorMessage(con));
- exit(1);
- }
- PQclear(res);
-
- fprintf(stderr,"creating tables...\n");
- for(i = 0; i < naccounts*tps; i++) {
- int j = i + 1;
- sprintf(sql,"%d\t%d\t%d\t\n",i+1,(i+1)/naccounts,0);
- if (PQputline(con,sql)) {
- fprintf(stderr,"PQputline failed\n");
- exit(1);
- }
- if (j % 10000 == 0) {
- fprintf(stderr,"%d tuples done.\n",j);
- }
- }
- if (PQputline(con,"\\.\n")) {
- fprintf(stderr,"very last PQputline failed\n");
- exit(1);
- }
-
- if (PQendcopy(con)) {
- fprintf(stderr,"PQendcopy failed\n");
- exit(1);
- }
-
- res = PQexec(con,"end");
- if (PQresultStatus(res) != PGRES_COMMAND_OK) {
- fprintf(stderr, "%s", PQerrorMessage(con));
- exit(1);
- }
-
- /* vacuum */
- fprintf(stderr,"vacuum...");
- res = PQexec(con,"vacuum analyze");
- if (PQresultStatus(res) != PGRES_COMMAND_OK) {
- fprintf(stderr, "%s", PQerrorMessage(con));
- exit(1);
- }
- fprintf(stderr,"done.\n");
-
- PQfinish(con);
-}
+static void
+init(char *pghost, char *pgport, char *dbName)
+{
+ PGconn *con;
+ PGresult *res;
+ static char *DDLs[] = {
+ "drop table branches",
+ "create table branches(bid int, primary key(bid),bbalance int,filler char(88))",
+ "drop table tellers",
+ "create table tellers(tid int, primary key(tid),bid int,tbalance int,filler char(84))",
+ "drop table accounts",
+ "create table accounts(aid int,primary key(aid),bid int,abalance int,filler char(84))",
+ "drop table history",
+ "create table history(tid int,bid int,aid int,delta int,time timestamp,filler char(22))"};
+ char sql[256];
+
+ int i;
+
+ con = PQsetdb(pghost, pgport, NULL, NULL, dbName);
+ if (PQstatus(con) == CONNECTION_BAD)
+ {
+ fprintf(stderr, "Connection to database '%s' on %s failed.\n", dbName, pghost);
+ fprintf(stderr, "%s", PQerrorMessage(con));
+ exit(1);
+ }
-/* print out results */
-static void printResults(
- int ttype, CState *state,
- struct timeval *tv1,struct timeval *tv2,
- struct timeval *tv3) {
- double t1,t2;
- int i;
- int normal_xacts = 0;
-
- for (i=0;i<nclients;i++) {
- normal_xacts += state[i].cnt;
- }
-
- t1 = (tv3->tv_sec - tv1->tv_sec)*1000000.0+(tv3->tv_usec - tv1->tv_usec);
- t1 = normal_xacts*1000000.0/t1;
-
- t2 = (tv3->tv_sec - tv2->tv_sec)*1000000.0+(tv3->tv_usec - tv2->tv_usec);
- t2 = normal_xacts*1000000.0/t2;
-
- printf("transaction type: %s\n",ttype==0?"TPC-B (sort of)":"SELECT only");
- printf("scaling factor: %d\n",tps);
- printf("number of clients: %d\n",nclients);
- printf("number of transactions per client: %d\n",nxacts);
- printf("number of transactions actually processed: %d/%d\n",normal_xacts,nxacts*nclients);
- printf("tps = %f(including connections establishing)\n",t1);
- printf("tps = %f(excluding connections establishing)\n",t2);
-}
+ for (i = 0; i < (sizeof(DDLs) / sizeof(char *)); i++)
+ {
+ res = PQexec(con, DDLs[i]);
+ if (strncmp(DDLs[i], "drop", 4) && PQresultStatus(res) != PGRES_COMMAND_OK)
+ {
+ fprintf(stderr, "%s", PQerrorMessage(con));
+ exit(1);
+ }
+ PQclear(res);
+ }
-int main(int argc, char **argv) {
- extern char *optarg;
- extern int optind, opterr, optopt;
- int c;
- char *pghost = "";
- char *pgport = "";
- char *dbName;
- int is_init_mode = 0; /* initialize mode? */
- int is_no_vacuum = 0; /* no vacuum at all before testing? */
- int is_full_vacuum = 0; /* do full vacuum before testing? */
- int debug = 0; /* debug flag */
- int ttype = 0; /* transaction type. 0: TPC-B, 1: SELECT only */
+ res = PQexec(con, "begin");
+ if (PQresultStatus(res) != PGRES_COMMAND_OK)
+ {
+ fprintf(stderr, "%s", PQerrorMessage(con));
+ exit(1);
+ }
- static CState state[MAXCLIENTS]; /* clients status */
+ for (i = 0; i < nbranches * tps; i++)
+ {
+ sprintf(sql, "insert into branches(bid,bbalance) values(%d,0)", i + 1);
+ res = PQexec(con, sql);
+ if (PQresultStatus(res) != PGRES_COMMAND_OK)
+ {
+ fprintf(stderr, "%s", PQerrorMessage(con));
+ exit(1);
+ }
+ PQclear(res);
+ }
- struct timeval tv1; /* start up time */
- struct timeval tv2; /* after establishing all connections to the backend */
- struct timeval tv3; /* end time */
+ for (i = 0; i < ntellers * tps; i++)
+ {
+ sprintf(sql, "insert into tellers(tid,bid,tbalance) values (%d,%d,0)"
+ ,i + 1, i / ntellers + 1);
+ res = PQexec(con, sql);
+ if (PQresultStatus(res) != PGRES_COMMAND_OK)
+ {
+ fprintf(stderr, "%s", PQerrorMessage(con));
+ exit(1);
+ }
+ PQclear(res);
+ }
- int i;
+ res = PQexec(con, "copy accounts from stdin");
+ if (PQresultStatus(res) != PGRES_COPY_IN)
+ {
+ fprintf(stderr, "%s", PQerrorMessage(con));
+ exit(1);
+ }
+ PQclear(res);
+
+ fprintf(stderr, "creating tables...\n");
+ for (i = 0; i < naccounts * tps; i++)
+ {
+ int j = i + 1;
+
+ sprintf(sql, "%d\t%d\t%d\t\n", i + 1, (i + 1) / naccounts, 0);
+ if (PQputline(con, sql))
+ {
+ fprintf(stderr, "PQputline failed\n");
+ exit(1);
+ }
+ if (j % 10000 == 0)
+ fprintf(stderr, "%d tuples done.\n", j);
+ }
+ if (PQputline(con, "\\.\n"))
+ {
+ fprintf(stderr, "very last PQputline failed\n");
+ exit(1);
+ }
+
+ if (PQendcopy(con))
+ {
+ fprintf(stderr, "PQendcopy failed\n");
+ exit(1);
+ }
+
+ res = PQexec(con, "end");
+ if (PQresultStatus(res) != PGRES_COMMAND_OK)
+ {
+ fprintf(stderr, "%s", PQerrorMessage(con));
+ exit(1);
+ }
+
+ /* vacuum */
+ fprintf(stderr, "vacuum...");
+ res = PQexec(con, "vacuum analyze");
+ if (PQresultStatus(res) != PGRES_COMMAND_OK)
+ {
+ fprintf(stderr, "%s", PQerrorMessage(con));
+ exit(1);
+ }
+ fprintf(stderr, "done.\n");
+
+ PQfinish(con);
+}
- fd_set input_mask;
- int nsocks; /* return from select(2) */
- int maxsock; /* max socket number to be waited */
+/* print out results */
+static void
+printResults(
+ int ttype, CState * state,
+ struct timeval * tv1, struct timeval * tv2,
+ struct timeval * tv3)
+{
+ double t1,
+ t2;
+ int i;
+ int normal_xacts = 0;
+
+ for (i = 0; i < nclients; i++)
+ normal_xacts += state[i].cnt;
+
+ t1 = (tv3->tv_sec - tv1->tv_sec) * 1000000.0 + (tv3->tv_usec - tv1->tv_usec);
+ t1 = normal_xacts * 1000000.0 / t1;
+
+ t2 = (tv3->tv_sec - tv2->tv_sec) * 1000000.0 + (tv3->tv_usec - tv2->tv_usec);
+ t2 = normal_xacts * 1000000.0 / t2;
+
+ printf("transaction type: %s\n", ttype == 0 ? "TPC-B (sort of)" : "SELECT only");
+ printf("scaling factor: %d\n", tps);
+ printf("number of clients: %d\n", nclients);
+ printf("number of transactions per client: %d\n", nxacts);
+ printf("number of transactions actually processed: %d/%d\n", normal_xacts, nxacts * nclients);
+ printf("tps = %f(including connections establishing)\n", t1);
+ printf("tps = %f(excluding connections establishing)\n", t2);
+}
+
+int
+main(int argc, char **argv)
+{
+ extern char *optarg;
+ extern int optind,
+ opterr,
+ optopt;
+ int c;
+ char *pghost = "";
+ char *pgport = "";
+ char *dbName;
+ int is_init_mode = 0; /* initialize mode? */
+ int is_no_vacuum = 0; /* no vacuum at all before
+ * testing? */
+ int is_full_vacuum = 0; /* do full vacuum before testing? */
+ int debug = 0; /* debug flag */
+ int ttype = 0; /* transaction type. 0: TPC-B, 1: SELECT
+ * only */
+
+ static CState state[MAXCLIENTS]; /* clients status */
+
+ struct timeval tv1; /* start up time */
+ struct timeval tv2; /* after establishing all connections to
+ * the backend */
+ struct timeval tv3; /* end time */
+
+ int i;
+
+ fd_set input_mask;
+ int nsocks; /* return from select(2) */
+ int maxsock; /* max socket number to be waited */
#ifndef __CYGWIN32__
- struct rlimit rlim;
+ struct rlimit rlim;
+
#endif
- PGconn *con;
- PGresult *res;
-
- while ((c = getopt(argc, argv, "ih:nvp:dc:t:s:S")) != EOF) {
- switch (c) {
- case 'i':
- is_init_mode++;
- break;
- case 'h':
- pghost = optarg;
- break;
- case 'n':
- is_no_vacuum++;
- break;
- case 'v':
- is_full_vacuum++;
- break;
- case 'p':
- pgport = optarg;
- break;
- case 'd':
- debug++;
- break;
- case 'S':
- ttype = 1;
- break;
- case 'c':
- nclients = atoi(optarg);
- if (nclients <= 0 || nclients > MAXCLIENTS) {
- fprintf(stderr,"wrong number of clients: %d\n",nclients);
- exit(1);
- }
+ PGconn *con;
+ PGresult *res;
+
+ while ((c = getopt(argc, argv, "ih:nvp:dc:t:s:S")) != EOF)
+ {
+ switch (c)
+ {
+ case 'i':
+ is_init_mode++;
+ break;
+ case 'h':
+ pghost = optarg;
+ break;
+ case 'n':
+ is_no_vacuum++;
+ break;
+ case 'v':
+ is_full_vacuum++;
+ break;
+ case 'p':
+ pgport = optarg;
+ break;
+ case 'd':
+ debug++;
+ break;
+ case 'S':
+ ttype = 1;
+ break;
+ case 'c':
+ nclients = atoi(optarg);
+ if (nclients <= 0 || nclients > MAXCLIENTS)
+ {
+ fprintf(stderr, "wrong number of clients: %d\n", nclients);
+ exit(1);
+ }
#ifndef __CYGWIN32__
-#ifdef RLIMIT_NOFILE /* most platform uses RLIMIT_NOFILE */
- if (getrlimit(RLIMIT_NOFILE,&rlim) == -1) {
-#else /* but BSD doesn't ... */
- if (getrlimit(RLIMIT_OFILE,&rlim) == -1) {
-#endif /* HAVE_RLIMIT_NOFILE */
- fprintf(stderr,"getrlimit failed. reason: %s\n",strerror(errno));
- exit(1);
- }
- if (rlim.rlim_cur <= (nclients+2)) {
- fprintf(stderr,"You need at least %d open files resource but you are only allowed to use %ld.\n",nclients+2,rlim.rlim_cur);
- fprintf(stderr,"Use limit/ulimt to increase the limit before using pgbench.\n");
- exit(1);
- }
-#endif /* #ifndef __CYGWIN32__ */
- break;
- case 's':
- tps = atoi(optarg);
- if (tps <= 0) {
- fprintf(stderr,"wrong scaling factor: %d\n",tps);
- exit(1);
- }
- break;
- case 't':
- nxacts = atoi(optarg);
- if (nxacts <= 0) {
- fprintf(stderr,"wrong number of transactions: %d\n",nxacts);
- exit(1);
- }
- break;
- default:
- usage();
- exit(1);
- break;
- }
- }
-
- if (argc > optind) {
- dbName = argv[optind];
- } else {
- dbName = getenv("USER");
- if (dbName == NULL) {
- dbName = "";
- }
- }
-
- if (is_init_mode) {
- init(pghost, pgport, dbName);
- exit(0);
- }
-
- remains = nclients;
-
- if (debug) {
- printf("pghost: %s pgport: %s nclients: %d nxacts: %d dbName: %s\n",
- pghost, pgport, nclients, nxacts, dbName);
- }
-
- /* opening connection... */
- con = PQsetdb(pghost, pgport, NULL, NULL, dbName);
- if (PQstatus(con) == CONNECTION_BAD) {
- fprintf(stderr, "Connection to database '%s' failed.\n", dbName);
- fprintf(stderr, "%s", PQerrorMessage(con));
- exit(1);
- }
-
- /* get the scaling factor that should be same as count(*) from branches... */
- res = PQexec(con,"select count(*) from branches");
- if (PQresultStatus(res) != PGRES_TUPLES_OK) {
- fprintf(stderr, "%s", PQerrorMessage(con));
- exit(1);
- }
- tps = atoi(PQgetvalue(res, 0, 0));
- if (tps < 0) {
- fprintf(stderr,"count(*) from branches invalid (%d)\n",tps);
- exit(1);
- }
- PQclear(res);
-
- if (!is_no_vacuum) {
- fprintf(stderr,"starting vacuum...");
- res = PQexec(con,"vacuum branches");
- if (PQresultStatus(res) != PGRES_COMMAND_OK) {
- fprintf(stderr, "%s", PQerrorMessage(con));
- exit(1);
- }
- PQclear(res);
-
- res = PQexec(con,"vacuum tellers");
- if (PQresultStatus(res) != PGRES_COMMAND_OK) {
- fprintf(stderr, "%s", PQerrorMessage(con));
- exit(1);
- }
- PQclear(res);
-
- res = PQexec(con,"delete from history");
- if (PQresultStatus(res) != PGRES_COMMAND_OK) {
- fprintf(stderr, "%s", PQerrorMessage(con));
- exit(1);
- }
- PQclear(res);
- res = PQexec(con,"vacuum history");
- if (PQresultStatus(res) != PGRES_COMMAND_OK) {
- fprintf(stderr, "%s", PQerrorMessage(con));
- exit(1);
- }
- PQclear(res);
-
- fprintf(stderr,"end.\n");
-
- if (is_full_vacuum) {
- fprintf(stderr,"starting full vacuum...");
- res = PQexec(con,"vacuum analyze accounts");
- if (PQresultStatus(res) != PGRES_COMMAND_OK) {
- fprintf(stderr, "%s", PQerrorMessage(con));
- exit(1);
- }
- PQclear(res);
- fprintf(stderr,"end.\n");
- }
- }
- PQfinish(con);
-
- /* set random seed */
- gettimeofday(&tv1, 0);
- srand((uint)tv1.tv_usec);
-
- /* get start up time */
- gettimeofday(&tv1, 0);
-
- /* make connections to the database */
- for (i=0;i<nclients;i++) {
- state[i].con = PQsetdb(pghost, pgport, NULL, NULL, dbName);
- if (PQstatus(state[i].con) == CONNECTION_BAD) {
- fprintf(stderr, "Connection to database '%s' failed.\n", dbName);
- fprintf(stderr, "%s", PQerrorMessage(state[i].con));
- exit(1);
- }
- }
-
- /* time after connections set up */
- gettimeofday(&tv2, 0);
-
- /* send start up quries in async manner */
- for (i=0;i<nclients;i++) {
- if (ttype == 0) {
- doOne(state, i, debug);
- } else if (ttype == 1) {
- doSelectOnly(state, i, debug);
- }
- }
-
- for (;;) {
- if (remains <= 0) { /* all done ? */
- disconnect_all(state);
- /* get end time */
- gettimeofday(&tv3, 0);
- printResults(ttype, state, &tv1,&tv2,&tv3);
- exit(0);
- }
-
- FD_ZERO(&input_mask);
-
- maxsock = 0;
- for (i=0;i<nclients;i++) {
- if (state[i].con) {
- int sock = PQsocket(state[i].con);
- if (sock < 0) {
- fprintf(stderr,"Client %d: PQsock failed\n",i);
- disconnect_all(state);
- exit(1);
- }
- FD_SET(sock, &input_mask);
- if (maxsock < sock) {
- maxsock = sock;
- }
- }
- }
-
- if ((nsocks = select(maxsock +1, &input_mask, (fd_set *)NULL,
- (fd_set *)NULL, (struct timeval *)NULL)) < 0) {
- if (errno == EINTR) {
- continue;
- }
- /* must be something wrong */
- disconnect_all(state);
- fprintf(stderr,"select failed: %s\n",strerror(errno));
- exit(1);
- } else if (nsocks == 0) { /* timeout */
- fprintf(stderr,"select timeout\n");
- for (i=0;i<nclients;i++) {
- fprintf(stderr,"client %d:state %d cnt %d ecnt %d listen %d\n",
- i,state[i].state,state[i].cnt,state[i].ecnt,state[i].listen);
- }
- exit(0);
- }
-
- /* ok, backend returns reply */
- for (i=0;i<nclients;i++) {
- if (state[i].con && FD_ISSET(PQsocket(state[i].con), &input_mask)) {
- if (ttype == 0) {
- doOne(state, i, debug);
- } else if (ttype == 1) {
- doSelectOnly(state, i, debug);
- }
- }
- }
- }
+#ifdef RLIMIT_NOFILE /* most platform uses RLIMIT_NOFILE */
+ if (getrlimit(RLIMIT_NOFILE, &rlim) == -1)
+ {
+#else /* but BSD doesn't ... */
+ if (getrlimit(RLIMIT_OFILE, &rlim) == -1)
+ {
+#endif /* HAVE_RLIMIT_NOFILE */
+ fprintf(stderr, "getrlimit failed. reason: %s\n", strerror(errno));
+ exit(1);
+ }
+ if (rlim.rlim_cur <= (nclients + 2))
+ {
+ fprintf(stderr, "You need at least %d open files resource but you are only allowed to use %ld.\n", nclients + 2, rlim.rlim_cur);
+ fprintf(stderr, "Use limit/ulimt to increase the limit before using pgbench.\n");
+ exit(1);
+ }
+#endif /* #ifndef __CYGWIN32__ */
+ break;
+ case 's':
+ tps = atoi(optarg);
+ if (tps <= 0)
+ {
+ fprintf(stderr, "wrong scaling factor: %d\n", tps);
+ exit(1);
+ }
+ break;
+ case 't':
+ nxacts = atoi(optarg);
+ if (nxacts <= 0)
+ {
+ fprintf(stderr, "wrong number of transactions: %d\n", nxacts);
+ exit(1);
+ }
+ break;
+ default:
+ usage();
+ exit(1);
+ break;
+ }
+ }
+
+ if (argc > optind)
+ dbName = argv[optind];
+ else
+ {
+ dbName = getenv("USER");
+ if (dbName == NULL)
+ dbName = "";
+ }
+
+ if (is_init_mode)
+ {
+ init(pghost, pgport, dbName);
+ exit(0);
+ }
+
+ remains = nclients;
+
+ if (debug)
+ {
+ printf("pghost: %s pgport: %s nclients: %d nxacts: %d dbName: %s\n",
+ pghost, pgport, nclients, nxacts, dbName);
+ }
+
+ /* opening connection... */
+ con = PQsetdb(pghost, pgport, NULL, NULL, dbName);
+ if (PQstatus(con) == CONNECTION_BAD)
+ {
+ fprintf(stderr, "Connection to database '%s' failed.\n", dbName);
+ fprintf(stderr, "%s", PQerrorMessage(con));
+ exit(1);
+ }
+
+ /*
+ * get the scaling factor that should be same as count(*) from
+ * branches...
+ */
+ res = PQexec(con, "select count(*) from branches");
+ if (PQresultStatus(res) != PGRES_TUPLES_OK)
+ {
+ fprintf(stderr, "%s", PQerrorMessage(con));
+ exit(1);
+ }
+ tps = atoi(PQgetvalue(res, 0, 0));
+ if (tps < 0)
+ {
+ fprintf(stderr, "count(*) from branches invalid (%d)\n", tps);
+ exit(1);
+ }
+ PQclear(res);
+
+ if (!is_no_vacuum)
+ {
+ fprintf(stderr, "starting vacuum...");
+ res = PQexec(con, "vacuum branches");
+ if (PQresultStatus(res) != PGRES_COMMAND_OK)
+ {
+ fprintf(stderr, "%s", PQerrorMessage(con));
+ exit(1);
+ }
+ PQclear(res);
+
+ res = PQexec(con, "vacuum tellers");
+ if (PQresultStatus(res) != PGRES_COMMAND_OK)
+ {
+ fprintf(stderr, "%s", PQerrorMessage(con));
+ exit(1);
+ }
+ PQclear(res);
+
+ res = PQexec(con, "delete from history");
+ if (PQresultStatus(res) != PGRES_COMMAND_OK)
+ {
+ fprintf(stderr, "%s", PQerrorMessage(con));
+ exit(1);
+ }
+ PQclear(res);
+ res = PQexec(con, "vacuum history");
+ if (PQresultStatus(res) != PGRES_COMMAND_OK)
+ {
+ fprintf(stderr, "%s", PQerrorMessage(con));
+ exit(1);
+ }
+ PQclear(res);
+
+ fprintf(stderr, "end.\n");
+
+ if (is_full_vacuum)
+ {
+ fprintf(stderr, "starting full vacuum...");
+ res = PQexec(con, "vacuum analyze accounts");
+ if (PQresultStatus(res) != PGRES_COMMAND_OK)
+ {
+ fprintf(stderr, "%s", PQerrorMessage(con));
+ exit(1);
+ }
+ PQclear(res);
+ fprintf(stderr, "end.\n");
+ }
+ }
+ PQfinish(con);
+
+ /* set random seed */
+ gettimeofday(&tv1, 0);
+ srand((uint) tv1.tv_usec);
+
+ /* get start up time */
+ gettimeofday(&tv1, 0);
+
+ /* make connections to the database */
+ for (i = 0; i < nclients; i++)
+ {
+ state[i].con = PQsetdb(pghost, pgport, NULL, NULL, dbName);
+ if (PQstatus(state[i].con) == CONNECTION_BAD)
+ {
+ fprintf(stderr, "Connection to database '%s' failed.\n", dbName);
+ fprintf(stderr, "%s", PQerrorMessage(state[i].con));
+ exit(1);
+ }
+ }
+
+ /* time after connections set up */
+ gettimeofday(&tv2, 0);
+
+ /* send start up quries in async manner */
+ for (i = 0; i < nclients; i++)
+ {
+ if (ttype == 0)
+ doOne(state, i, debug);
+ else if (ttype == 1)
+ doSelectOnly(state, i, debug);
+ }
+
+ for (;;)
+ {
+ if (remains <= 0)
+ { /* all done ? */
+ disconnect_all(state);
+ /* get end time */
+ gettimeofday(&tv3, 0);
+ printResults(ttype, state, &tv1, &tv2, &tv3);
+ exit(0);
+ }
+
+ FD_ZERO(&input_mask);
+
+ maxsock = 0;
+ for (i = 0; i < nclients; i++)
+ {
+ if (state[i].con)
+ {
+ int sock = PQsocket(state[i].con);
+
+ if (sock < 0)
+ {
+ fprintf(stderr, "Client %d: PQsock failed\n", i);
+ disconnect_all(state);
+ exit(1);
+ }
+ FD_SET(sock, &input_mask);
+ if (maxsock < sock)
+ maxsock = sock;
+ }
+ }
+
+ if ((nsocks = select(maxsock + 1, &input_mask, (fd_set *) NULL,
+ (fd_set *) NULL, (struct timeval *) NULL)) < 0)
+ {
+ if (errno == EINTR)
+ continue;
+ /* must be something wrong */
+ disconnect_all(state);
+ fprintf(stderr, "select failed: %s\n", strerror(errno));
+ exit(1);
+ }
+ else if (nsocks == 0)
+ { /* timeout */
+ fprintf(stderr, "select timeout\n");
+ for (i = 0; i < nclients; i++)
+ {
+ fprintf(stderr, "client %d:state %d cnt %d ecnt %d listen %d\n",
+ i, state[i].state, state[i].cnt, state[i].ecnt, state[i].listen);
+ }
+ exit(0);
+ }
+
+ /* ok, backend returns reply */
+ for (i = 0; i < nclients; i++)
+ {
+ if (state[i].con && FD_ISSET(PQsocket(state[i].con), &input_mask))
+ {
+ if (ttype == 0)
+ doOne(state, i, debug);
+ else if (ttype == 1)
+ doSelectOnly(state, i, debug);
+ }
+ }
+ }
}
#define ISO8859
#define MIN(x, y) ((x) < (y) ? (x) : (y))
-#define VALUE(char) ((char) - '0')
+#define VALUE(char) ((char) - '0')
#define DIGIT(val) ((val) + '0')
#define ISOCTAL(c) (((c) >= '0') && ((c) <= '7'))
#ifndef ISO8859
break;
case '{':
/* Escape beginning of string, to distinguish from arrays */
- if (p == data) {
+ if (p == data)
len++;
- }
break;
default:
if (NOTPRINTABLE(*p))
break;
case '{':
/* Escape beginning of string, to distinguish from arrays */
- if (p == data) {
+ if (p == data)
*r++ = '\\';
- }
*r++ = c;
break;
default:
{
return (string_input(str, 1, 0, NULL));
}
+
#endif
/* end of file */
/*
* Local Variables:
- * tab-width: 4
- * c-indent-level: 4
- * c-basic-offset: 4
+ * tab-width: 4
+ * c-indent-level: 4
+ * c-basic-offset: 4
* End:
*/
#ifndef STRING_IO_H
#define STRING_IO_H
-unsigned char* string_output(unsigned char *data, int size);
-unsigned char* string_input(unsigned char *str, int size, int hdrsize,
- int *rtn_size);
-unsigned char* c_charout(int32 c);
-unsigned char* c_textout(struct varlena * vlena);
-unsigned char* c_varcharout(unsigned char *s);
+unsigned char *string_output(unsigned char *data, int size);
+unsigned char *string_input(unsigned char *str, int size, int hdrsize,
+ int *rtn_size);
+unsigned char *c_charout(int32 c);
+unsigned char *c_textout(struct varlena * vlena);
+unsigned char *c_varcharout(unsigned char *s);
#if 0
-struct varlena* c_textin(unsigned char *str);
-int32* c_charin(unsigned char *str)
+struct varlena *c_textin(unsigned char *str);
+int32 *
+c_charin(unsigned char *str)
#endif
#endif
/*
* Local Variables:
- * tab-width: 4
- * c-indent-level: 4
- * c-basic-offset: 4
+ * tab-width: 4
+ * c-indent-level: 4
+ * c-basic-offset: 4
* End:
*/
/*
* Local Variables:
- * tab-width: 4
- * c-indent-level: 4
- * c-basic-offset: 4
+ * tab-width: 4
+ * c-indent-level: 4
+ * c-basic-offset: 4
* End:
*/
/*
* Local Variables:
- * tab-width: 4
- * c-indent-level: 4
- * c-basic-offset: 4
+ * tab-width: 4
+ * c-indent-level: 4
+ * c-basic-offset: 4
* End:
*/
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.61 2000/01/26 05:55:53 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.62 2000/04/12 17:14:36 momjian Exp $
*
* NOTES
* The old interface functions have been converted to macros
*((int32 *) value[i]));
break;
default:
- Assert(att[i]->attlen >= 0);
- memmove(data, DatumGetPointer(value[i]),
- (size_t)(att[i]->attlen));
+ Assert(att[i]->attlen >= 0);
+ memmove(data, DatumGetPointer(value[i]),
+ (size_t) (att[i]->attlen));
break;
}
data = (char *) att_addlength((long) data, att[i]->attlen, value[i]);
Form_pg_attribute *att = tupleDesc->attrs;
int slow = 0; /* do we have to walk nulls? */
- (void)isnull; /*not used*/
+ (void) isnull; /* not used */
#ifdef IN_MACRO
/* This is handled in the macro */
Assert(attnum > 0);
len += bitmaplen;
}
- hoff = len = MAXALIGN(len); /* be conservative here */
+ hoff = len = MAXALIGN(len); /* be conservative here */
len += ComputeDataSize(tupleDescriptor, value, nulls);
heap_freetuple(HeapTuple htup)
{
if (htup->t_data != NULL)
- if (htup->t_datamcxt != NULL && (char *)(htup->t_data) !=
- ((char *) htup + HEAPTUPLESIZE))
- {
+ if (htup->t_datamcxt != NULL && (char *) (htup->t_data) !=
+ ((char *) htup + HEAPTUPLESIZE))
elog(NOTICE, "TELL Jan Wieck: heap_freetuple() found separate t_data");
- }
pfree(htup);
}
len = offsetof(HeapTupleHeaderData, t_bits);
- hoff = len = MAXALIGN(len); /* be conservative */
+ hoff = len = MAXALIGN(len); /* be conservative */
len += structlen;
tuple = (HeapTuple) palloc(HEAPTUPLESIZE + len);
tuple->t_datamcxt = CurrentMemoryContext;
td->t_infomask = 0;
td->t_infomask |= HEAP_XMAX_INVALID;
- if (structlen > 0)
- memmove((char *) td + hoff, structure, (size_t)structlen);
+ if (structlen > 0)
+ memmove((char *) td + hoff, structure, (size_t) structlen);
return tuple;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/common/indextuple.c,v 1.42 2000/01/26 05:55:53 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/common/indextuple.c,v 1.43 2000/04/12 17:14:37 momjian Exp $
*
*-------------------------------------------------------------------------
*/
hoff = IndexInfoFindDataOffset(infomask);
size = hoff + ComputeDataSize(tupleDescriptor, value, null);
- size = MAXALIGN(size); /* be conservative */
+ size = MAXALIGN(size); /* be conservative */
tp = (char *) palloc(size);
tuple = (IndexTuple) tp;
int data_off; /* tuple data offset */
Form_pg_attribute *att = tupleDesc->attrs;
- (void)isnull;
+ (void) isnull;
/* ----------------
* sanity checks
* ----------------
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/common/tupdesc.c,v 1.61 2000/01/31 04:35:48 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/common/tupdesc.c,v 1.62 2000/04/12 17:14:37 momjian Exp $
*
* NOTES
* some of the executor utility code such as "ExecTypeFromTL" should be
bool
equalTupleDescs(TupleDesc tupdesc1, TupleDesc tupdesc2)
{
- int i;
+ int i;
if (tupdesc1->natts != tupdesc2->natts)
return false;
for (i = 0; i < tupdesc1->natts; i++)
{
- Form_pg_attribute attr1 = tupdesc1->attrs[i];
- Form_pg_attribute attr2 = tupdesc2->attrs[i];
+ Form_pg_attribute attr1 = tupdesc1->attrs[i];
+ Form_pg_attribute attr2 = tupdesc2->attrs[i];
- /* We do not need to check every single field here, and in fact
- * some fields such as attdisbursion probably shouldn't be compared.
+ /*
+ * We do not need to check every single field here, and in fact
+ * some fields such as attdisbursion probably shouldn't be
+ * compared.
*/
if (strcmp(NameStr(attr1->attname), NameStr(attr2->attname)) != 0)
return false;
}
if (tupdesc1->constr != NULL)
{
- TupleConstr *constr1 = tupdesc1->constr;
- TupleConstr *constr2 = tupdesc2->constr;
+ TupleConstr *constr1 = tupdesc1->constr;
+ TupleConstr *constr2 = tupdesc2->constr;
if (constr2 == NULL)
return false;
return false;
for (i = 0; i < (int) constr1->num_defval; i++)
{
- AttrDefault *defval1 = constr1->defval + i;
- AttrDefault *defval2 = constr2->defval + i;
+ AttrDefault *defval1 = constr1->defval + i;
+ AttrDefault *defval2 = constr2->defval + i;
if (defval1->adnum != defval2->adnum)
return false;
return false;
for (i = 0; i < (int) constr1->num_check; i++)
{
- ConstrCheck *check1 = constr1->check + i;
- ConstrCheck *check2 = constr2->check + i;
+ ConstrCheck *check1 = constr1->check + i;
+ ConstrCheck *check2 = constr2->check + i;
if (strcmp(check1->ccname, check2->ccname) != 0)
return false;
constr->has_not_null = true;
desc->attrs[attnum - 1]->attnotnull = entry->is_not_null;
- /* Note we copy only pre-cooked default expressions.
- * Digestion of raw ones is someone else's problem.
+ /*
+ * Note we copy only pre-cooked default expressions. Digestion of
+ * raw ones is someone else's problem.
*/
if (entry->cooked_default != NULL)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.52 2000/03/17 02:36:00 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.53 2000/04/12 17:14:39 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static IndexTuple gist_tuple_replacekey(Relation r, GISTENTRY entry, IndexTuple t);
static void gistcentryinit(GISTSTATE *giststate, GISTENTRY *e, char *pr,
Relation r, Page pg, OffsetNumber o, int b, bool l);
+
#ifdef GISTDEBUG
static char *int_range_out(INTRANGE *r);
+
#endif
/*
/* no locking is needed */
- CommandCounterIncrement(); /* so we can see the new pg_index tuple */
+ CommandCounterIncrement(); /* so we can see the new pg_index tuple */
initGISTstate(&giststate, index);
#ifndef OMIT_PARTIAL_INDEX
/* SetSlotContents(slot, htup); */
slot->val = htup;
- if (! ExecQual((List *) pred, econtext, false))
+ if (!ExecQual((List *) pred, econtext, false))
continue;
#endif /* OMIT_PARTIAL_INDEX */
}
/*
* Since we just counted the tuples in the heap, we update its stats
* in pg_class to guarantee that the planner takes advantage of the
- * index we just created. But, only update statistics during
- * normal index definitions, not for indices on system catalogs
- * created during bootstrap processing. We must close the relations
- * before updating statistics to guarantee that the relcache entries
- * are flushed when we increment the command counter in UpdateStats().
- * But we do not release any locks on the relations; those will be
- * held until end of transaction.
+ * index we just created. But, only update statistics during normal
+ * index definitions, not for indices on system catalogs created
+ * during bootstrap processing. We must close the relations before
+ * updating statistics to guarantee that the relcache entries are
+ * flushed when we increment the command counter in UpdateStats(). But
+ * we do not release any locks on the relations; those will be held
+ * until end of transaction.
*/
if (IsNormalProcessingMode())
{
- Oid hrelid = RelationGetRelid(heap);
- Oid irelid = RelationGetRelid(index);
+ Oid hrelid = RelationGetRelid(heap);
+ Oid irelid = RelationGetRelid(index);
bool inplace = IsReindexProcessing();
heap_close(heap, NoLock);
prev = l;
if (l == (GISTScanList) NULL)
- elog(ERROR, "GiST scan list corrupted -- cannot find 0x%p", (void*)s);
+ elog(ERROR, "GiST scan list corrupted -- cannot find 0x%p", (void *) s);
if (prev == (GISTScanList) NULL)
GISTScans = l->gsl_next;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/hash/hash.c,v 1.36 2000/03/01 05:39:22 inoue Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/hash/hash.c,v 1.37 2000/04/12 17:14:43 momjian Exp $
*
* NOTES
* This file contains only the public interface routines.
#ifndef OMIT_PARTIAL_INDEX
/* SetSlotContents(slot, htup); */
slot->val = htup;
- if (! ExecQual((List *) pred, econtext, false))
+ if (!ExecQual((List *) pred, econtext, false))
continue;
#endif /* OMIT_PARTIAL_INDEX */
}
/*
* Since we just counted the tuples in the heap, we update its stats
* in pg_class to guarantee that the planner takes advantage of the
- * index we just created. But, only update statistics during
- * normal index definitions, not for indices on system catalogs
- * created during bootstrap processing. We must close the relations
- * before updating statistics to guarantee that the relcache entries
- * are flushed when we increment the command counter in UpdateStats().
- * But we do not release any locks on the relations; those will be
- * held until end of transaction.
+ * index we just created. But, only update statistics during normal
+ * index definitions, not for indices on system catalogs created
+ * during bootstrap processing. We must close the relations before
+ * updating statistics to guarantee that the relcache entries are
+ * flushed when we increment the command counter in UpdateStats(). But
+ * we do not release any locks on the relations; those will be held
+ * until end of transaction.
*/
if (IsNormalProcessingMode())
{
- Oid hrelid = RelationGetRelid(heap);
- Oid irelid = RelationGetRelid(index);
+ Oid hrelid = RelationGetRelid(heap);
+ Oid irelid = RelationGetRelid(index);
bool inplace = IsReindexProcessing();
heap_close(heap, NoLock);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/hash/hashfunc.c,v 1.24 2000/02/21 03:36:46 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/hash/hashfunc.c,v 1.25 2000/04/12 17:14:44 momjian Exp $
*
* NOTES
* These functions are stored in pg_amproc. For each operator class
int i;
uint32 result = 0;
- for (i = INDEX_MAX_KEYS; --i >= 0; )
+ for (i = INDEX_MAX_KEYS; --i >= 0;)
result = (result << 1) ^ (~(uint32) key[i]);
return result;
}
/*
* Note: hashint2vector currently can't be used as a user hash table
- * hash function, because it has no pg_proc entry. We only need it
+ * hash function, because it has no pg_proc entry. We only need it
* for catcache indexing.
*/
uint32
int i;
uint32 result = 0;
- for (i = INDEX_MAX_KEYS; --i >= 0; )
+ for (i = INDEX_MAX_KEYS; --i >= 0;)
result = (result << 1) ^ (~(uint32) key[i]);
return result;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/hash/hashscan.c,v 1.22 2000/01/26 05:55:55 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/hash/hashscan.c,v 1.23 2000/04/12 17:14:44 momjian Exp $
*
* NOTES
* Because we can be doing an index scan on a relation while we
last = chk;
if (chk == (HashScanList) NULL)
- elog(ERROR, "hash scan list trashed; can't find 0x%p", (void*)scan);
+ elog(ERROR, "hash scan list trashed; can't find 0x%p", (void *) scan);
if (last == (HashScanList) NULL)
HashScans = chk->hashsl_next;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/hash/hashsearch.c,v 1.23 2000/03/17 02:36:02 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/hash/hashsearch.c,v 1.24 2000/04/12 17:14:44 momjian Exp $
*
*-------------------------------------------------------------------------
*/
opaque = (HashPageOpaque) PageGetSpecialPointer(page);
Assert(opaque->hasho_bucket == bucket);
while (PageIsEmpty(page) &&
- BlockNumberIsValid(opaque->hasho_nextblkno))
+ BlockNumberIsValid(opaque->hasho_nextblkno))
_hash_readnext(rel, &buf, &page, &opaque);
maxoff = PageGetMaxOffsetNumber(page);
offnum = FirstOffsetNumber;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.66 2000/02/09 03:49:47 inoue Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.67 2000/04/12 17:14:45 momjian Exp $
*
*
* INTERFACE ROUTINES
* heap_fetch - retrive tuple with tid
* heap_insert - insert tuple into a relation
* heap_delete - delete a tuple from a relation
- * heap_update - replace a tuple in a relation with another tuple
+ * heap_update - replace a tuple in a relation with another tuple
* heap_markpos - mark scan position
* heap_restrpos - restore position to marked location
*
* ----------------
*/
scan->rs_ntup.t_datamcxt = scan->rs_ctup.t_datamcxt =
- scan->rs_ptup.t_datamcxt = NULL;
+ scan->rs_ptup.t_datamcxt = NULL;
scan->rs_ntup.t_data = scan->rs_ctup.t_data =
- scan->rs_ptup.t_data = NULL;
+ scan->rs_ptup.t_data = NULL;
scan->rs_nbuf = scan->rs_cbuf = scan->rs_pbuf = InvalidBuffer;
}
else if (atend)
if (BufferIsValid(scan->rs_nbuf))
ReleaseBuffer(scan->rs_nbuf);
- /* we don't bother to clear rs_pbuf etc --- caller must
- * reinitialize them if scan descriptor is not being deleted.
+ /*
+ * we don't bother to clear rs_pbuf etc --- caller must reinitialize
+ * them if scan descriptor is not being deleted.
*/
}
if (lockmode == NoLock)
return r; /* caller must check RelationIsValid! */
- if (! RelationIsValid(r))
+ if (!RelationIsValid(r))
elog(ERROR, "Relation %u does not exist", relationId);
LockRelation(r, lockmode);
if (lockmode == NoLock)
return r; /* caller must check RelationIsValid! */
- if (! RelationIsValid(r))
+ if (!RelationIsValid(r))
elog(ERROR, "Relation '%s' does not exist", relationName);
LockRelation(r, lockmode);
* sanity checks
* ----------------
*/
- if (! RelationIsValid(relation))
+ if (!RelationIsValid(relation))
elog(ERROR, "heap_beginscan: !RelationIsValid(relation)");
/* ----------------
* Acquire AccessShareLock for the duration of the scan
*
* Note: we could get an SI inval message here and consequently have
- * to rebuild the relcache entry. The refcount increment above
+ * to rebuild the relcache entry. The refcount increment above
* ensures that we will rebuild it and not just flush it...
* ----------------
*/
scan->rs_nkeys = (short) nkeys;
if (nkeys)
+
/*
* we do this here instead of in initscan() because heap_rescan
* also calls initscan() and we don't want to allocate memory
if (scan->rs_ptup.t_data == scan->rs_ctup.t_data &&
BufferIsInvalid(scan->rs_pbuf))
- {
return NULL;
- }
/*
* Copy the "current" tuple/buffer to "next". Pin/unpin the
}
else
{
- /* All checks passed, so return the tuple as valid.
- * Caller is now responsible for releasing the buffer.
+
+ /*
+ * All checks passed, so return the tuple as valid. Caller is now
+ * responsible for releasing the buffer.
*/
*userbuf = buffer;
}
*/
ItemPointer
heap_get_latest_tid(Relation relation,
- Snapshot snapshot,
- ItemPointer tid)
+ Snapshot snapshot,
+ ItemPointer tid)
{
ItemId lp = NULL;
Buffer buffer;
PageHeader dp;
- OffsetNumber offnum;
- HeapTupleData tp;
- HeapTupleHeader t_data;
- ItemPointerData ctid;
- bool invalidBlock,linkend;
+ OffsetNumber offnum;
+ HeapTupleData tp;
+ HeapTupleHeader t_data;
+ ItemPointerData ctid;
+ bool invalidBlock,
+ linkend;
/* ----------------
* get the buffer from the relation descriptor
invalidBlock = false;
}
if (invalidBlock)
- {
+ {
LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
ReleaseBuffer(buffer);
return NULL;
- }
+ }
/* ----------------
* more sanity checks
snapshot, 0, (ScanKey) NULL);
linkend = true;
- if ((t_data->t_infomask & HEAP_XMAX_COMMITTED) &&
+ if ((t_data->t_infomask & HEAP_XMAX_COMMITTED) &&
!ItemPointerEquals(tid, &ctid))
linkend = false;
{
if (linkend)
return NULL;
- return heap_get_latest_tid(relation, snapshot, &ctid);
+ return heap_get_latest_tid(relation, snapshot, &ctid);
}
return tid;
LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
if (TransactionIdDidAbort(xwait))
goto l1;
- /*
- * xwait is committed but if xwait had just marked
- * the tuple for update then some other xaction could
- * update this tuple before we got to this point.
+
+ /*
+ * xwait is committed but if xwait had just marked the tuple for
+ * update then some other xaction could update this tuple before
+ * we got to this point.
*/
if (tp.t_data->t_xmax != xwait)
goto l1;
}
/*
- * heap_update - replace a tuple
+ * heap_update - replace a tuple
*/
int
heap_update(Relation relation, ItemPointer otid, HeapTuple newtup,
- ItemPointer ctid)
+ ItemPointer ctid)
{
ItemId lp;
HeapTupleData oldtup;
LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
if (TransactionIdDidAbort(xwait))
goto l2;
- /*
- * xwait is committed but if xwait had just marked
- * the tuple for update then some other xaction could
- * update this tuple before we got to this point.
+
+ /*
+ * xwait is committed but if xwait had just marked the tuple for
+ * update then some other xaction could update this tuple before
+ * we got to this point.
*/
if (oldtup.t_data->t_xmax != xwait)
goto l2;
LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
if (TransactionIdDidAbort(xwait))
goto l3;
- /*
- * xwait is committed but if xwait had just marked
- * the tuple for update then some other xaction could
- * update this tuple before we got to this point.
+
+ /*
+ * xwait is committed but if xwait had just marked the tuple for
+ * update then some other xaction could update this tuple before
+ * we got to this point.
*/
if (tuple->t_data->t_xmax != xwait)
goto l3;
*
*
* IDENTIFICATION
- * $Id: hio.c,v 1.30 2000/03/17 02:36:02 tgl Exp $
+ * $Id: hio.c,v 1.31 2000/04/12 17:14:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
IncrHeapAccessStat(global_RelationPutHeapTuple);
pageHeader = (Page) BufferGetPage(buffer);
- len = MAXALIGN(tuple->t_len); /* be conservative */
+ len = MAXALIGN(tuple->t_len); /* be conservative */
Assert(len <= PageGetFreeSpace(pageHeader));
offnum = PageAddItem((Page) pageHeader, (Item) tuple->t_data,
ItemId itemId;
Item item;
- len = MAXALIGN(tuple->t_len); /* be conservative */
+ len = MAXALIGN(tuple->t_len); /* be conservative */
/*
- * If we're gonna fail for oversize tuple, do it right away...
- * this code should go away eventually.
+ * If we're gonna fail for oversize tuple, do it right away... this
+ * code should go away eventually.
*/
if (len > MaxTupleSize)
elog(ERROR, "Tuple is too big: size %u, max size %ld",
lastblock = RelationGetNumberOfBlocks(relation);
/*
- * Get the last existing page --- may need to create the first one
- * if this is a virgin relation.
+ * Get the last existing page --- may need to create the first one if
+ * this is a virgin relation.
*/
if (lastblock == 0)
{
if (len > PageGetFreeSpace(pageHeader))
{
+
/*
- * BUG: by elog'ing here, we leave the new buffer locked and not
- * marked dirty, which may result in an invalid page header
- * being left on disk. But we should not get here given the
- * test at the top of the routine, and the whole deal should
- * go away when we implement tuple splitting anyway...
+ * BUG: by elog'ing here, we leave the new buffer locked and
+ * not marked dirty, which may result in an invalid page
+ * header being left on disk. But we should not get here
+ * given the test at the top of the routine, and the whole
+ * deal should go away when we implement tuple splitting
+ * anyway...
*/
elog(ERROR, "Tuple is too big: size %u", len);
}
*
* tuptoaster.c
* Support routines for external and compressed storage of
- * variable size attributes.
+ * variable size attributes.
*
* Copyright (c) 2000, PostgreSQL Global Development Group
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/heap/tuptoaster.c,v 1.2 2000/01/20 21:50:59 petere Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/heap/tuptoaster.c,v 1.3 2000/04/12 17:14:45 momjian Exp $
*
*
* INTERFACE ROUTINES
#ifdef TUPLE_TOASTER_ACTIVE
void
-heap_tuple_toast_attrs (Relation rel, HeapTuple newtup, HeapTuple oldtup)
+heap_tuple_toast_attrs(Relation rel, HeapTuple newtup, HeapTuple oldtup)
{
return;
}
-varattrib *
-heap_tuple_untoast_attr (varattrib *attr)
+varattrib *
+heap_tuple_untoast_attr(varattrib * attr)
{
elog(ERROR, "heap_tuple_untoast_attr() called");
}
-#endif /* TUPLE_TOASTER_ACTIVE */
+#endif /* TUPLE_TOASTER_ACTIVE */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/index/genam.c,v 1.24 2000/03/14 23:52:01 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/index/genam.c,v 1.25 2000/04/12 17:14:47 momjian Exp $
*
* NOTES
* many of the old access method routines have been turned into
*
* At the end of a scan, the AM's endscan routine undoes the locking,
* but does *not* call IndexScanEnd --- the higher-level index_endscan
- * routine does that. (We can't do it in the AM because index_endscan
+ * routine does that. (We can't do it in the AM because index_endscan
* still needs to touch the IndexScanDesc after calling the AM.)
*
* Because of this, the AM does not have a choice whether to call
ItemPointerSetInvalid(&scan->currentMarkData);
ItemPointerSetInvalid(&scan->nextMarkData);
- /* mark cached function lookup data invalid; it will be set on first use */
+ /*
+ * mark cached function lookup data invalid; it will be set on first
+ * use
+ */
scan->fn_getnext.fn_oid = InvalidOid;
if (numberOfKeys > 0)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.41 2000/03/14 23:52:01 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.42 2000/04/12 17:14:47 momjian Exp $
*
* INTERFACE ROUTINES
* index_open - open an index relation by relationId
* index_open - open an index relation by relationId
*
* presently the relcache routines do all the work we need
- * to open/close index relations. However, callers of index_open
+ * to open/close index relations. However, callers of index_open
* expect it to succeed, so we need to check for a failure return.
*
- * Note: we acquire no lock on the index. An AccessShareLock is
+ * Note: we acquire no lock on the index. An AccessShareLock is
* acquired by index_beginscan (and released by index_endscan).
* ----------------
*/
r = RelationIdGetRelation(relationId);
- if (! RelationIsValid(r))
+ if (!RelationIsValid(r))
elog(ERROR, "Index %u does not exist", relationId);
if (r->rd_rel->relkind != RELKIND_INDEX)
r = RelationNameGetRelation(relationName);
- if (! RelationIsValid(r))
+ if (!RelationIsValid(r))
elog(ERROR, "Index '%s' does not exist", relationName);
if (r->rd_rel->relkind != RELKIND_INDEX)
* Acquire AccessShareLock for the duration of the scan
*
* Note: we could get an SI inval message here and consequently have
- * to rebuild the relcache entry. The refcount increment above
+ * to rebuild the relcache entry. The refcount increment above
* ensures that we will rebuild it and not just flush it...
* ----------------
*/
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/index/Attic/istrat.c,v 1.41 2000/02/18 09:29:16 inoue Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/index/Attic/istrat.c,v 1.42 2000/04/12 17:14:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
HeapTuple tuple;
HeapScanDesc scan = NULL;
- bool cachesearch = (!IsBootstrapProcessingMode()) && IsCacheInitialized();
+ bool cachesearch = (!IsBootstrapProcessingMode()) && IsCacheInitialized();
if (cachesearch)
{
AttrNumber attributeNumber;
int attributeIndex;
Oid operatorClassObjectId[INDEX_MAX_KEYS];
- bool cachesearch = (!IsBootstrapProcessingMode()) && IsCacheInitialized();
+ bool cachesearch = (!IsBootstrapProcessingMode()) && IsCacheInitialized();
if (cachesearch)
{
aform = (Form_pg_amop) GETSTRUCT(tuple);
OperatorRelationFillScanKeyEntry(operatorRelation,
aform->amopopr,
- StrategyMapGetScanKeyEntry(map, aform->amopstrategy));
+ StrategyMapGetScanKeyEntry(map, aform->amopstrategy));
}
heap_endscan(scan);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtcompare.c,v 1.33 2000/02/10 19:51:38 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtcompare.c,v 1.34 2000/04/12 17:14:49 momjian Exp $
*
* NOTES
* These functions are stored in pg_amproc. For each operator class
int32
btint4cmp(int32 a, int32 b)
{
- if (a > b)
- return 1;
- else if (a == b)
- return 0;
- else
- return -1;
+ if (a > b)
+ return 1;
+ else if (a == b)
+ return 0;
+ else
+ return -1;
}
int32
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtinsert.c,v 1.56 2000/03/17 02:36:03 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtinsert.c,v 1.57 2000/04/12 17:14:49 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static InsertIndexResult _bt_insertonpg(Relation rel, Buffer buf, BTStack stack, int keysz, ScanKey scankey, BTItem btitem, BTItem afteritem);
static Buffer _bt_split(Relation rel, Size keysz, ScanKey scankey,
- Buffer buf, OffsetNumber firstright);
+ Buffer buf, OffsetNumber firstright);
static OffsetNumber _bt_findsplitloc(Relation rel, Size keysz, ScanKey scankey,
- Page page, OffsetNumber start,
- OffsetNumber maxoff, Size llimit);
+ Page page, OffsetNumber start,
+ OffsetNumber maxoff, Size llimit);
static void _bt_newroot(Relation rel, Buffer lbuf, Buffer rbuf);
static OffsetNumber _bt_pgaddtup(Relation rel, Buffer buf, int keysz, ScanKey itup_scankey, Size itemsize, BTItem btitem, BTItem afteritem);
static bool _bt_goesonpg(Relation rel, Buffer buf, Size keysz, ScanKey scankey, BTItem afteritem);
itemsz = IndexTupleDSize(btitem->bti_itup)
+ (sizeof(BTItemData) - sizeof(IndexTupleData));
- itemsz = MAXALIGN(itemsz); /* be safe, PageAddItem will do
- * this but we need to be
- * consistent */
+ itemsz = MAXALIGN(itemsz); /* be safe, PageAddItem will do this but
+ * we need to be consistent */
/*
- * Check whether the item can fit on a btree page at all.
- * (Eventually, we ought to try to apply TOAST methods if not.)
- * We actually need to be able to fit three items on every page,
- * so restrict any one item to 1/3 the per-page available space.
- * Note that at this point, itemsz doesn't include the ItemId.
+ * Check whether the item can fit on a btree page at all. (Eventually,
+ * we ought to try to apply TOAST methods if not.) We actually need to
+ * be able to fit three items on every page, so restrict any one item
+ * to 1/3 the per-page available space. Note that at this point,
+ * itemsz doesn't include the ItemId.
*/
- if (itemsz > (PageGetPageSize(page)-sizeof(PageHeaderData)-MAXALIGN(sizeof(BTPageOpaqueData)))/3 - sizeof(ItemIdData))
+ if (itemsz > (PageGetPageSize(page) - sizeof(PageHeaderData) - MAXALIGN(sizeof(BTPageOpaqueData))) / 3 - sizeof(ItemIdData))
elog(ERROR, "btree: index item size %u exceeds maximum %lu",
itemsz,
- (PageGetPageSize(page)-sizeof(PageHeaderData)-MAXALIGN(sizeof(BTPageOpaqueData)))/3 - sizeof(ItemIdData));
+ (PageGetPageSize(page) - sizeof(PageHeaderData) - MAXALIGN(sizeof(BTPageOpaqueData))) /3 - sizeof(ItemIdData));
/*
* If we have to insert item on the leftmost page which is the first
bool is_root = lpageop->btpo_flags & BTP_ROOT;
/*
- * Instead of splitting leaf page in the chain of duplicates
- * by new duplicate, insert it into some right page.
+ * Instead of splitting leaf page in the chain of duplicates by
+ * new duplicate, insert it into some right page.
*/
if ((lpageop->btpo_flags & BTP_CHAIN) &&
(lpageop->btpo_flags & BTP_LEAF) && keys_equal)
rbuf = _bt_getbuf(rel, lpageop->btpo_next, BT_WRITE);
rpage = BufferGetPage(rbuf);
rpageop = (BTPageOpaque) PageGetSpecialPointer(rpage);
- /*
- * some checks
+
+ /*
+ * some checks
*/
if (!P_RIGHTMOST(rpageop)) /* non-rightmost page */
{ /* If we have the same hikey here then
BTGreaterStrategyNumber))
elog(FATAL, "btree: hikey is out of order");
else if (rpageop->btpo_flags & BTP_CHAIN)
+
/*
* If hikey > scankey then it's last page in chain and
* BTP_CHAIN must be OFF
}
else
/* rightmost page */
- {
Assert(!(rpageop->btpo_flags & BTP_CHAIN));
- }
_bt_relbuf(rel, buf, BT_WRITE);
return (_bt_insertonpg(rel, rbuf, stack, keysz,
scankey, btitem, afteritem));
*/
if (!parent_chained &&
MAXALIGN(IndexTupleDSize(lowLeftItem->bti_itup)) ==
- MAXALIGN(IndexTupleDSize(stack->bts_btitem->bti_itup)))
+ MAXALIGN(IndexTupleDSize(stack->bts_btitem->bti_itup)))
{
_bt_updateitem(rel, keysz, pbuf,
stack->bts_btitem, lowLeftItem);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtpage.c,v 1.35 2000/01/26 05:55:58 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtpage.c,v 1.36 2000/04/12 17:14:49 momjian Exp $
*
* NOTES
* Postgres btree pages look like ordinary relation pages. The opaque
else
{
rootblkno = metad->btm_root;
- _bt_relbuf(rel, metabuf, BT_READ); /* done with the meta page */
+ _bt_relbuf(rel, metabuf, BT_READ); /* done with the meta page */
rootbuf = _bt_getbuf(rel, rootblkno, access);
}
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtree.c,v 1.53 2000/02/18 09:29:54 inoue Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtree.c,v 1.54 2000/04/12 17:14:49 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#endif
Node *pred,
*oldPred;
- BTSpool *spool = NULL;
+ BTSpool *spool = NULL;
bool isunique;
bool usefast;
#ifndef OMIT_PARTIAL_INDEX
/* SetSlotContents(slot, htup); */
slot->val = htup;
- if (! ExecQual((List *) pred, econtext, false))
+ if (!ExecQual((List *) pred, econtext, false))
continue;
#endif /* OMIT_PARTIAL_INDEX */
}
}
/*
- * if we are doing bottom-up btree build, finish the build by
- * (1) completing the sort of the spool file, (2) inserting the
- * sorted tuples into btree pages and (3) building the upper levels.
+ * if we are doing bottom-up btree build, finish the build by (1)
+ * completing the sort of the spool file, (2) inserting the sorted
+ * tuples into btree pages and (3) building the upper levels.
*/
if (usefast)
{
/*
* Since we just counted the tuples in the heap, we update its stats
* in pg_class to guarantee that the planner takes advantage of the
- * index we just created. But, only update statistics during
- * normal index definitions, not for indices on system catalogs
- * created during bootstrap processing. We must close the relations
- * before updating statistics to guarantee that the relcache entries
- * are flushed when we increment the command counter in UpdateStats().
- * But we do not release any locks on the relations; those will be
- * held until end of transaction.
+ * index we just created. But, only update statistics during normal
+ * index definitions, not for indices on system catalogs created
+ * during bootstrap processing. We must close the relations before
+ * updating statistics to guarantee that the relcache entries are
+ * flushed when we increment the command counter in UpdateStats(). But
+ * we do not release any locks on the relations; those will be held
+ * until end of transaction.
*/
if (IsNormalProcessingMode())
{
- Oid hrelid = RelationGetRelid(heap);
- Oid irelid = RelationGetRelid(index);
+ Oid hrelid = RelationGetRelid(heap);
+ Oid irelid = RelationGetRelid(index);
bool inplace = IsReindexProcessing();
heap_close(heap, NoLock);
index_close(index);
+
/*
- UpdateStats(hrelid, nhtups, true);
- UpdateStats(irelid, nitups, false);
- */
+ * UpdateStats(hrelid, nhtups, true); UpdateStats(irelid, nitups,
+ * false);
+ */
UpdateStats(hrelid, nhtups, inplace);
UpdateStats(irelid, nitups, inplace);
if (oldPred != NULL)
BTItem item;
BlockNumber blkno;
- LockBuffer(buf, BT_READ); /* lock buffer first! */
+ LockBuffer(buf, BT_READ); /* lock buffer first! */
page = BufferGetPage(buf);
maxoff = PageGetMaxOffsetNumber(page);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/Attic/nbtscan.c,v 1.30 2000/01/26 05:55:58 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/Attic/nbtscan.c,v 1.31 2000/04/12 17:14:49 momjian Exp $
*
*
* NOTES
void
AtEOXact_nbtree(void)
{
- /* Note: these actions should only be necessary during xact abort;
- * but they can't hurt during a commit.
+
+ /*
+ * Note: these actions should only be necessary during xact abort; but
+ * they can't hurt during a commit.
*/
- /* Reset the active-scans list to empty.
- * We do not need to free the list elements, because they're all
- * palloc()'d, so they'll go away at end of transaction anyway.
+ /*
+ * Reset the active-scans list to empty. We do not need to free the
+ * list elements, because they're all palloc()'d, so they'll go away
+ * at end of transaction anyway.
*/
BTScans = NULL;
last = chk;
if (chk == (BTScanList) NULL)
- elog(ERROR, "btree scan list trashed; can't find 0x%p", (void*)scan);
+ elog(ERROR, "btree scan list trashed; can't find 0x%p", (void *) scan);
if (last == (BTScanList) NULL)
BTScans = chk->btsl_next;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.58 2000/03/17 02:36:04 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.59 2000/04/12 17:14:49 momjian Exp $
*
*-------------------------------------------------------------------------
*/
compare = -1; /* not-NULL key "<" NULL datum */
}
else
- {
compare = (int32) FMGR_PTR2(&entry->sk_func, keyDatum, attrDatum);
- }
if (compare != 0)
break; /* done when we find unequal attributes */
/*
* If there are no keys on the page, return the first available slot.
- * Note this covers two cases: the page is really empty (no keys),
- * or it contains only a high key. The latter case is possible after
+ * Note this covers two cases: the page is really empty (no keys), or
+ * it contains only a high key. The latter case is possible after
* vacuuming.
*/
if (high < low)
return low;
/*
- * Binary search to find the first key on the page >= scan key.
- * Loop invariant: all slots before 'low' are < scan key, all slots
- * at or after 'high' are >= scan key. Also, haveEq is true if the
- * tuple at 'high' is == scan key.
- * We can fall out when high == low.
+ * Binary search to find the first key on the page >= scan key. Loop
+ * invariant: all slots before 'low' are < scan key, all slots at or
+ * after 'high' are >= scan key. Also, haveEq is true if the tuple at
+ * 'high' is == scan key. We can fall out when high == low.
*/
high++; /* establish the loop invariant for high */
haveEq = false;
while (high > low)
{
- OffsetNumber mid = low + ((high - low) / 2);
+ OffsetNumber mid = low + ((high - low) / 2);
+
/* We have low <= mid < high, so mid points at a real slot */
result = _bt_compare(rel, itupdesc, page, keysz, scankey, mid);
/*--------------------
* At this point we have high == low, but be careful: they could point
- * past the last slot on the page. We also know that haveEq is true
+ * past the last slot on the page. We also know that haveEq is true
* if and only if there is an equal key (in which case high&low point
* at the first equal key).
*
if (haveEq)
{
+
/*
* There is an equal key. We return either the first equal key
* (which we just found), or the last lesser key.
*
- * We need not check srchtype != BT_DESCENT here, since if that
- * is true then natts == keysz by assumption.
+ * We need not check srchtype != BT_DESCENT here, since if that is
+ * true then natts == keysz by assumption.
*/
if (natts == keysz)
return low; /* return first equal key */
}
else
{
+
/*
* There is no equal key. We return either the first greater key
* (which we just found), or the last lesser key.
&& P_LEFTMOST(opaque)
&& offnum == P_HIKEY)
{
+
/*
* we just have to believe that this will only be called with
* offnum == P_HIKEY when P_HIKEY is the OffsetNumber of the first
bool strategyCheck;
ScanKey scankeys = 0;
- int keysCount = 0;
- int *nKeyIs = 0;
- int i, j;
- StrategyNumber strat_total;
-
+ int keysCount = 0;
+ int *nKeyIs = 0;
+ int i,
+ j;
+ StrategyNumber strat_total;
+
rel = scan->relation;
so = (BTScanOpaque) scan->opaque;
_bt_orderkeys(rel, so);
if (so->qual_ok)
- strategyCheck = true;
- }
+ strategyCheck = true;
+ }
strat_total = BTEqualStrategyNumber;
if (strategyCheck)
{
AttrNumber attno;
- nKeyIs = (int *)palloc(so->numberOfKeys*sizeof(int));
- for (i=0; i < so->numberOfKeys; i++)
+ nKeyIs = (int *) palloc(so->numberOfKeys * sizeof(int));
+ for (i = 0; i < so->numberOfKeys; i++)
{
attno = so->keyData[i].sk_attno;
if (attno == keysCount)
if (attno > keysCount + 1)
break;
strat = _bt_getstrat(rel, attno,
- so->keyData[i].sk_procedure);
+ so->keyData[i].sk_procedure);
if (strat == strat_total ||
- strat == BTEqualStrategyNumber)
+ strat == BTEqualStrategyNumber)
{
nKeyIs[keysCount++] = i;
continue;
}
if (ScanDirectionIsBackward(dir) &&
- (strat == BTLessStrategyNumber ||
- strat == BTLessEqualStrategyNumber) )
+ (strat == BTLessStrategyNumber ||
+ strat == BTLessEqualStrategyNumber))
{
nKeyIs[keysCount++] = i;
strat_total = strat;
continue;
}
if (ScanDirectionIsForward(dir) &&
- (strat == BTGreaterStrategyNumber ||
- strat == BTGreaterEqualStrategyNumber) )
+ (strat == BTGreaterStrategyNumber ||
+ strat == BTGreaterEqualStrategyNumber))
{
nKeyIs[keysCount++] = i;
strat_total = strat;
* at the right place in the scan.
*/
/* _bt_orderkeys disallows it, but it's place to add some code latter */
- scankeys = (ScanKey)palloc(keysCount*sizeof(ScanKeyData));
- for (i=0; i < keysCount; i++)
+ scankeys = (ScanKey) palloc(keysCount * sizeof(ScanKeyData));
+ for (i = 0; i < keysCount; i++)
{
j = nKeyIs[i];
if (so->keyData[j].sk_flags & SK_ISNULL)
pfree(scankeys);
elog(ERROR, "_bt_first: btree doesn't support is(not)null, yet");
return ((RetrieveIndexResult) NULL);
- }
- proc = index_getprocid(rel, i+1, BTORDER_PROC);
- ScanKeyEntryInitialize(scankeys+i, so->keyData[j].sk_flags,
- i+1, proc, so->keyData[j].sk_argument);
+ }
+ proc = index_getprocid(rel, i + 1, BTORDER_PROC);
+ ScanKeyEntryInitialize(scankeys + i, so->keyData[j].sk_flags,
+ i + 1, proc, so->keyData[j].sk_argument);
}
- if (nKeyIs) pfree(nKeyIs);
+ if (nKeyIs)
+ pfree(nKeyIs);
stack = _bt_search(rel, keysCount, scankeys, &buf);
_bt_freestack(stack);
*
* We use tuplesort.c to sort the given index tuples into order.
* Then we scan the index tuples in order and build the btree pages
- * for each level. When we have only one page on a level, it must be the
+ * for each level. When we have only one page on a level, it must be the
* root -- it can be attached to the btree metapage and we are done.
*
* this code is moderately slow (~10% slower) compared to the regular
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsort.c,v 1.51 2000/02/18 06:32:39 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsort.c,v 1.52 2000/04/12 17:14:49 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static void _bt_load(Relation index, BTSpool *btspool);
static BTItem _bt_buildadd(Relation index, Size keysz, ScanKey scankey,
- BTPageState *state, BTItem bti, int flags);
+ BTPageState *state, BTItem bti, int flags);
static BTItem _bt_minitem(Page opage, BlockNumber oblkno, int atend);
static BTPageState *_bt_pagestate(Relation index, int flags,
- int level, bool doupper);
+ int level, bool doupper);
static void _bt_uppershutdown(Relation index, Size keysz, ScanKey scankey,
- BTPageState *state);
+ BTPageState *state);
/*
/*
* create and initialize a spool structure
*/
-BTSpool *
+BTSpool *
_bt_spoolinit(Relation index, bool isunique)
{
BTSpool *btspool = (BTSpool *) palloc(sizeof(BTSpool));
btspool->sortstate = tuplesort_begin_index(index, isunique, false);
/*
- * Currently, tuplesort provides sort functions on IndexTuples.
- * If we kept anything in a BTItem other than a regular IndexTuple,
- * we'd need to modify tuplesort to understand BTItems as such.
+ * Currently, tuplesort provides sort functions on IndexTuples. If we
+ * kept anything in a BTItem other than a regular IndexTuple, we'd
+ * need to modify tuplesort to understand BTItems as such.
*/
Assert(sizeof(BTItemData) == sizeof(IndexTupleData));
btisz = MAXALIGN(btisz);
/*
- * Check whether the item can fit on a btree page at all.
- * (Eventually, we ought to try to apply TOAST methods if not.)
- * We actually need to be able to fit three items on every page,
- * so restrict any one item to 1/3 the per-page available space.
- * Note that at this point, btisz doesn't include the ItemId.
+ * Check whether the item can fit on a btree page at all. (Eventually,
+ * we ought to try to apply TOAST methods if not.) We actually need to
+ * be able to fit three items on every page, so restrict any one item
+ * to 1/3 the per-page available space. Note that at this point, btisz
+ * doesn't include the ItemId.
*
* NOTE: similar code appears in _bt_insertonpg() to defend against
- * oversize items being inserted into an already-existing index.
- * But during creation of an index, we don't go through there.
+ * oversize items being inserted into an already-existing index. But
+ * during creation of an index, we don't go through there.
*/
- if (btisz > (PageGetPageSize(npage)-sizeof(PageHeaderData)-MAXALIGN(sizeof(BTPageOpaqueData)))/3 - sizeof(ItemIdData))
+ if (btisz > (PageGetPageSize(npage) - sizeof(PageHeaderData) - MAXALIGN(sizeof(BTPageOpaqueData))) / 3 - sizeof(ItemIdData))
elog(ERROR, "btree: index item size %d exceeds maximum %ld",
btisz,
- (PageGetPageSize(npage)-sizeof(PageHeaderData)-MAXALIGN(sizeof(BTPageOpaqueData)))/3 - sizeof(ItemIdData));
+ (PageGetPageSize(npage) - sizeof(PageHeaderData) - MAXALIGN(sizeof(BTPageOpaqueData))) /3 - sizeof(ItemIdData));
if (pgspc < btisz)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtutils.c,v 1.35 2000/02/18 06:32:39 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtutils.c,v 1.36 2000/04/12 17:14:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
uint16 numberOfKeys = so->numberOfKeys;
uint16 new_numberOfKeys = 0;
AttrNumber attno = 1;
- bool equalStrategyEnd, underEqualStrategy;
+ bool equalStrategyEnd,
+ underEqualStrategy;
if (numberOfKeys < 1)
return;
elog(ERROR, "_bt_orderkeys: key(s) for attribute %d missed", attno + 1);
underEqualStrategy = (!equalStrategyEnd);
+
/*
* If = has been specified, no other key will be used. In case
* of key < 2 && key == 1 and so on we have to set qual_ok to
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.44 2000/03/01 05:39:23 inoue Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.45 2000/04/12 17:14:51 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#ifndef OMIT_PARTIAL_INDEX
/* SetSlotContents(slot, htup); */
slot->val = htup;
- if (! ExecQual((List *) pred, econtext, false))
+ if (!ExecQual((List *) pred, econtext, false))
continue;
#endif /* OMIT_PARTIAL_INDEX */
}
/*
* Since we just counted the tuples in the heap, we update its stats
* in pg_class to guarantee that the planner takes advantage of the
- * index we just created. But, only update statistics during
- * normal index definitions, not for indices on system catalogs
- * created during bootstrap processing. We must close the relations
- * before updating statistics to guarantee that the relcache entries
- * are flushed when we increment the command counter in UpdateStats().
- * But we do not release any locks on the relations; those will be
- * held until end of transaction.
+ * index we just created. But, only update statistics during normal
+ * index definitions, not for indices on system catalogs created
+ * during bootstrap processing. We must close the relations before
+ * updating statistics to guarantee that the relcache entries are
+ * flushed when we increment the command counter in UpdateStats(). But
+ * we do not release any locks on the relations; those will be held
+ * until end of transaction.
*/
if (IsNormalProcessingMode())
{
- Oid hrelid = RelationGetRelid(heap);
- Oid irelid = RelationGetRelid(index);
+ Oid hrelid = RelationGetRelid(heap);
+ Oid irelid = RelationGetRelid(index);
bool inplace = IsReindexProcessing();
heap_close(heap, NoLock);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtscan.c,v 1.31 2000/01/26 05:56:00 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtscan.c,v 1.32 2000/04/12 17:14:51 momjian Exp $
*
*-------------------------------------------------------------------------
*/
prev = l;
if (l == (RTScanList) NULL)
- elog(ERROR, "rtree scan list corrupted -- cannot find 0x%p", (void*)s);
+ elog(ERROR, "rtree scan list corrupted -- cannot find 0x%p", (void *) s);
if (prev == (RTScanList) NULL)
RTScans = l->rtsl_next;
#include "postgres.h"
#include "access/rmgr.h"
-RmgrData *RmgrTable = NULL;
+RmgrData *RmgrTable = NULL;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/transam/transam.c,v 1.33 2000/01/26 05:56:03 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/transam/transam.c,v 1.34 2000/04/12 17:14:52 momjian Exp $
*
* NOTES
* This file contains the high level access-method interface to the
if (!fail)
{
+
/*
* DO NOT cache status for transactions in unknown state !!!
*/
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/transam/varsup.c,v 1.27 2000/03/31 02:43:31 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/transam/varsup.c,v 1.28 2000/04/12 17:14:53 momjian Exp $
*
*-------------------------------------------------------------------------
*/
SpinAcquire(OidGenLockId); /* not good for concurrency... */
/*
- * Note that we don't check is ShmemVariableCache->xid_count equal
- * to 0 or not. This will work as long as we don't call
+ * Note that we don't check is ShmemVariableCache->xid_count equal to
+ * 0 or not. This will work as long as we don't call
* ReadNewTransactionId() before GetNewTransactionId().
*/
if (ShmemVariableCache->nextXid == 0)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.63 2000/04/09 04:43:16 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.64 2000/04/12 17:14:53 momjian Exp $
*
* NOTES
* Transaction aborts can now occur two ways:
#include "utils/portal.h"
#include "utils/relcache.h"
-extern bool SharedBufferChanged;
+extern bool SharedBufferChanged;
static void AbortTransaction(void);
static void AtAbort_Cache(void);
CurrentTransactionStateData.scanCommandId = CurrentTransactionStateData.commandId;
/*
- * make cache changes visible to me. AtCommit_LocalCache()
- * instead of AtCommit_Cache() is called here.
+ * make cache changes visible to me. AtCommit_LocalCache() instead of
+ * AtCommit_Cache() is called here.
*/
AtCommit_LocalCache();
AtStart_Cache();
*/
xid = GetCurrentTransactionId();
- /*
- * flush the buffer manager pages. Note: if we have stable
- * main memory, dirty shared buffers are not flushed
- * plai 8/7/90
+ /*
+ * flush the buffer manager pages. Note: if we have stable main
+ * memory, dirty shared buffers are not flushed plai 8/7/90
*/
leak = BufferPoolCheckLeak();
/*
- * If no one shared buffer was changed by this transaction then
- * we don't flush shared buffers and don't record commit status.
+ * If no one shared buffer was changed by this transaction then we
+ * don't flush shared buffers and don't record commit status.
*/
if (SharedBufferChanged)
{
ResetBufferPool(true);
/*
- * have the transaction access methods record the status
- * of this transaction id in the pg_log relation.
+ * have the transaction access methods record the status of this
+ * transaction id in the pg_log relation.
*/
TransactionIdCommit(xid);
/*
- * Now write the log info to the disk too.
+ * Now write the log info to the disk too.
*/
leak = BufferPoolCheckLeak();
FlushBufferPool();
*/
xid = GetCurrentTransactionId();
- /*
- * Have the transaction access methods record the status of
- * this transaction id in the pg_log relation. We skip it
- * if no one shared buffer was changed by this transaction.
+ /*
+ * Have the transaction access methods record the status of this
+ * transaction id in the pg_log relation. We skip it if no one shared
+ * buffer was changed by this transaction.
*/
if (SharedBufferChanged && !TransactionIdDidCommit(xid))
TransactionIdAbort(xid);
/* ----------------
* Tell the trigger manager that this transaction is about to be
* committed. He'll invoke all trigger deferred until XACT before
- * we really start on committing the transaction.
+ * we really start on committing the transaction.
* ----------------
*/
DeferredTriggerEndXact();
RecordTransactionCommit();
/*
- * Let others know about no transaction in progress by me.
- * Note that this must be done _before_ releasing locks we hold
- * and SpinAcquire(SInvalLock) is required: UPDATE with xid 0 is
- * blocked by xid 1' UPDATE, xid 1 is doing commit while xid 2
- * gets snapshot - if xid 2' GetSnapshotData sees xid 1 as running
- * then it must see xid 0 as running as well or it will see two
- * tuple versions - one deleted by xid 1 and one inserted by xid 0.
+ * Let others know about no transaction in progress by me. Note that
+ * this must be done _before_ releasing locks we hold and
+ * SpinAcquire(SInvalLock) is required: UPDATE with xid 0 is blocked
+ * by xid 1' UPDATE, xid 1 is doing commit while xid 2 gets snapshot -
+ * if xid 2' GetSnapshotData sees xid 1 as running then it must see
+ * xid 0 as running as well or it will see two tuple versions - one
+ * deleted by xid 1 and one inserted by xid 0.
*/
if (MyProc != (PROC *) NULL)
{
* ----------------
*/
s->state = TRANS_DEFAULT;
- SharedBufferChanged = false; /* safest place to do it */
+ SharedBufferChanged = false;/* safest place to do it */
}
/* ----------------
* Tell the trigger manager that this transaction is about to be
- * aborted.
+ * aborted.
* ----------------
*/
DeferredTriggerAbortXact();
* ----------------
*/
s->state = TRANS_DEFAULT;
- SharedBufferChanged = false; /* safest place to do it */
+ SharedBufferChanged = false;/* safest place to do it */
}
/* --------------------------------
-/*-------------------------------------------------------------------------
+/*-------------------------------------------------------------------------
*
* xlog.c
*
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Header: /cvsroot/pgsql/src/backend/access/transam/xlog.c,v 1.12 2000/03/20 07:25:39 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/transam/xlog.c,v 1.13 2000/04/12 17:14:53 momjian Exp $
*
*-------------------------------------------------------------------------
*/
SPINLOCK ControlFileLockId;
SPINLOCK XidGenLockId;
-extern bool ReleaseDataFile(void);
+extern bool ReleaseDataFile(void);
-extern VariableCache ShmemVariableCache;
+extern VariableCache ShmemVariableCache;
-#define MinXLOGbuffers 4
+#define MinXLOGbuffers 4
typedef struct XLgwrRqst
{
- XLogRecPtr Write; /* byte (1-based) to write out */
- XLogRecPtr Flush; /* byte (1-based) to flush */
+ XLogRecPtr Write; /* byte (1-based) to write out */
+ XLogRecPtr Flush; /* byte (1-based) to flush */
} XLgwrRqst;
typedef struct XLgwrResult
{
- XLogRecPtr Write; /* bytes written out */
- XLogRecPtr Flush; /* bytes flushed */
+ XLogRecPtr Write; /* bytes written out */
+ XLogRecPtr Flush; /* bytes flushed */
} XLgwrResult;
typedef struct XLogCtlInsert
{
- XLgwrResult LgwrResult;
- XLogRecPtr PrevRecord;
- uint16 curridx; /* current block index in cache */
- XLogPageHeader currpage;
- char *currpos;
+ XLgwrResult LgwrResult;
+ XLogRecPtr PrevRecord;
+ uint16 curridx; /* current block index in cache */
+ XLogPageHeader currpage;
+ char *currpos;
} XLogCtlInsert;
typedef struct XLogCtlWrite
{
- XLgwrResult LgwrResult;
- uint16 curridx; /* index of next block to write */
+ XLgwrResult LgwrResult;
+ uint16 curridx; /* index of next block to write */
} XLogCtlWrite;
#ifndef HAS_TEST_AND_SET
-#define TAS(lck) 0
-#define S_UNLOCK(lck)
-#define S_INIT_LOCK(lck)
+#define TAS(lck) 0
+#define S_UNLOCK(lck)
+#define S_INIT_LOCK(lck)
#endif
typedef struct XLogCtlData
{
- XLogCtlInsert Insert;
- XLgwrRqst LgwrRqst;
- XLgwrResult LgwrResult;
- XLogCtlWrite Write;
- char *pages;
- XLogRecPtr *xlblocks; /* 1st byte ptr-s + BLCKSZ */
- uint32 XLogCacheByte;
- uint32 XLogCacheBlck;
+ XLogCtlInsert Insert;
+ XLgwrRqst LgwrRqst;
+ XLgwrResult LgwrResult;
+ XLogCtlWrite Write;
+ char *pages;
+ XLogRecPtr *xlblocks; /* 1st byte ptr-s + BLCKSZ */
+ uint32 XLogCacheByte;
+ uint32 XLogCacheBlck;
#ifdef HAS_TEST_AND_SET
- slock_t insert_lck;
- slock_t info_lck;
- slock_t lgwr_lck;
+ slock_t insert_lck;
+ slock_t info_lck;
+ slock_t lgwr_lck;
#endif
} XLogCtlData;
-static XLogCtlData *XLogCtl = NULL;
+static XLogCtlData *XLogCtl = NULL;
typedef enum DBState
{
typedef struct ControlFileData
{
- uint32 logId; /* current log file id */
- uint32 logSeg; /* current log file segment (1-based) */
- XLogRecPtr checkPoint; /* last check point record ptr */
- time_t time; /* time stamp of last modification */
- DBState state; /* */
+ uint32 logId; /* current log file id */
+ uint32 logSeg; /* current log file segment (1-based) */
+ XLogRecPtr checkPoint; /* last check point record ptr */
+ time_t time; /* time stamp of last modification */
+ DBState state; /* */
/*
- * this data is used to make sure that configuration of this DB
- * is compatible with the current backend
+ * this data is used to make sure that configuration of this DB is
+ * compatible with the current backend
*/
- uint32 blcksz; /* block size for this DB */
- uint32 relseg_size; /* blocks per segment of large relation */
- uint32 catalog_version_no; /* internal version number */
+ uint32 blcksz; /* block size for this DB */
+ uint32 relseg_size; /* blocks per segment of large relation */
+ uint32 catalog_version_no; /* internal version number */
/*
- * MORE DATA FOLLOWS AT THE END OF THIS STRUCTURE
- * - locations of data dirs
+ * MORE DATA FOLLOWS AT THE END OF THIS STRUCTURE - locations of data
+ * dirs
*/
} ControlFileData;
-static ControlFileData *ControlFile = NULL;
+static ControlFileData *ControlFile = NULL;
typedef struct CheckPoint
{
- XLogRecPtr redo; /* next RecPtr available when we */
- /* began to create CheckPoint */
- /* (i.e. REDO start point) */
- XLogRecPtr undo; /* first record of oldest in-progress */
- /* transaction when we started */
- /* (i.e. UNDO end point) */
- TransactionId nextXid;
- Oid nextOid;
+ XLogRecPtr redo; /* next RecPtr available when we */
+ /* began to create CheckPoint */
+ /* (i.e. REDO start point) */
+ XLogRecPtr undo; /* first record of oldest in-progress */
+ /* transaction when we started */
+ /* (i.e. UNDO end point) */
+ TransactionId nextXid;
+ Oid nextOid;
} CheckPoint;
-/*
- * We break each log file in 16Mb segments
+/*
+ * We break each log file in 16Mb segments
*/
#define XLogSegSize (16*1024*1024)
-#define XLogLastSeg (0xffffffff / XLogSegSize)
-#define XLogFileSize (XLogLastSeg * XLogSegSize)
+#define XLogLastSeg (0xffffffff / XLogSegSize)
+#define XLogFileSize (XLogLastSeg * XLogSegSize)
-#define XLogFileName(path, log, seg) \
+#define XLogFileName(path, log, seg) \
snprintf(path, MAXPGPATH, "%s%c%08X%08X", \
XLogDir, SEP_CHAR, log, seg)
-#define PrevBufIdx(curridx) \
+#define PrevBufIdx(curridx) \
((curridx == 0) ? XLogCtl->XLogCacheBlck : (curridx - 1))
-#define NextBufIdx(curridx) \
+#define NextBufIdx(curridx) \
((curridx == XLogCtl->XLogCacheBlck) ? 0 : (curridx + 1))
-#define XLByteLT(left, right) \
+#define XLByteLT(left, right) \
(right.xlogid > left.xlogid || \
(right.xlogid == left.xlogid && right.xrecoff > left.xrecoff))
-#define XLByteLE(left, right) \
+#define XLByteLE(left, right) \
(right.xlogid > left.xlogid || \
(right.xlogid == left.xlogid && right.xrecoff >= left.xrecoff))
-#define XLByteEQ(left, right) \
+#define XLByteEQ(left, right) \
(right.xlogid == left.xlogid && right.xrecoff == left.xrecoff)
-#define InitXLBuffer(curridx) (\
+#define InitXLBuffer(curridx) (\
XLogCtl->xlblocks[curridx].xrecoff = \
(XLogCtl->xlblocks[Insert->curridx].xrecoff == XLogFileSize) ? \
BLCKSZ : (XLogCtl->xlblocks[Insert->curridx].xrecoff + BLCKSZ), \
Insert->currpage->xlp_info = 0 \
)
-#define XRecOffIsValid(xrecoff) \
+#define XRecOffIsValid(xrecoff) \
(xrecoff % BLCKSZ >= SizeOfXLogPHD && \
(BLCKSZ - xrecoff % BLCKSZ) >= SizeOfXLogRecord)
-static void GetFreeXLBuffer(void);
-static void XLogWrite(char *buffer);
-static int XLogFileInit(uint32 log, uint32 seg);
-static int XLogFileOpen(uint32 log, uint32 seg, bool econt);
-static XLogRecord *ReadRecord(XLogRecPtr *RecPtr, char *buffer);
-static char *str_time(time_t tnow);
-
-static XLgwrResult LgwrResult = {{0, 0}, {0, 0}};
-static XLgwrRqst LgwrRqst = {{0, 0}, {0, 0}};
-
-static int logFile = -1;
-static uint32 logId = 0;
-static uint32 logSeg = 0;
-static uint32 logOff = 0;
-
-static XLogRecPtr ReadRecPtr;
-static XLogRecPtr EndRecPtr;
-static int readFile = -1;
-static uint32 readId = 0;
-static uint32 readSeg = 0;
-static uint32 readOff = 0;
-static char readBuf[BLCKSZ];
-static XLogRecord *nextRecord = NULL;
+static void GetFreeXLBuffer(void);
+static void XLogWrite(char *buffer);
+static int XLogFileInit(uint32 log, uint32 seg);
+static int XLogFileOpen(uint32 log, uint32 seg, bool econt);
+static XLogRecord *ReadRecord(XLogRecPtr *RecPtr, char *buffer);
+static char *str_time(time_t tnow);
+
+static XLgwrResult LgwrResult = {{0, 0}, {0, 0}};
+static XLgwrRqst LgwrRqst = {{0, 0}, {0, 0}};
+
+static int logFile = -1;
+static uint32 logId = 0;
+static uint32 logSeg = 0;
+static uint32 logOff = 0;
+
+static XLogRecPtr ReadRecPtr;
+static XLogRecPtr EndRecPtr;
+static int readFile = -1;
+static uint32 readId = 0;
+static uint32 readSeg = 0;
+static uint32 readOff = 0;
+static char readBuf[BLCKSZ];
+static XLogRecord *nextRecord = NULL;
XLogRecPtr
XLogInsert(RmgrId rmid, char *hdr, uint32 hdrlen, char *buf, uint32 buflen)
{
- XLogCtlInsert *Insert = &XLogCtl->Insert;
- XLogRecord *record;
- XLogSubRecord *subrecord;
- XLogRecPtr RecPtr;
- uint32 len = hdrlen + buflen,
- freespace,
- wlen;
- uint16 curridx;
- bool updrqst = false;
+ XLogCtlInsert *Insert = &XLogCtl->Insert;
+ XLogRecord *record;
+ XLogSubRecord *subrecord;
+ XLogRecPtr RecPtr;
+ uint32 len = hdrlen + buflen,
+ freespace,
+ wlen;
+ uint16 curridx;
+ bool updrqst = false;
if (len == 0 || len > MAXLOGRECSZ)
elog(STOP, "XLogInsert: invalid record len %u", len);
bool do_lgwr = true;
unsigned i = 0;
- for ( ; ; )
+ for (;;)
{
/* try to read LgwrResult while waiting for insert lock */
if (!TAS(&(XLogCtl->info_lck)))
LgwrRqst = XLogCtl->LgwrRqst;
LgwrResult = XLogCtl->LgwrResult;
S_UNLOCK(&(XLogCtl->info_lck));
+
/*
* If cache is half filled then try to acquire lgwr lock
* and do LGWR work, but only once.
*/
- if (do_lgwr &&
- (LgwrRqst.Write.xlogid != LgwrResult.Write.xlogid ||
- (LgwrRqst.Write.xrecoff - LgwrResult.Write.xrecoff >=
- XLogCtl->XLogCacheByte / 2)))
+ if (do_lgwr &&
+ (LgwrRqst.Write.xlogid != LgwrResult.Write.xlogid ||
+ (LgwrRqst.Write.xrecoff - LgwrResult.Write.xrecoff >=
+ XLogCtl->XLogCacheByte / 2)))
{
if (!TAS(&(XLogCtl->lgwr_lck)))
{
}
}
- freespace = ((char*) Insert->currpage) + BLCKSZ - Insert->currpos;
+ freespace = ((char *) Insert->currpage) + BLCKSZ - Insert->currpos;
if (freespace < SizeOfXLogRecord)
{
curridx = NextBufIdx(Insert->curridx);
if (XLByteLE(XLogCtl->xlblocks[curridx], LgwrResult.Write))
InitXLBuffer(curridx);
- else
+ else
GetFreeXLBuffer();
freespace = BLCKSZ - SizeOfXLogPHD;
}
curridx = Insert->curridx;
freespace -= SizeOfXLogRecord;
- record = (XLogRecord*) Insert->currpos;
+ record = (XLogRecord *) Insert->currpos;
record->xl_prev = Insert->PrevRecord;
if (rmid != RM_XLOG_ID)
record->xl_xact_prev = MyLastRecPtr;
record->xl_info = (len > freespace) ? XLR_TO_BE_CONTINUED : 0;
record->xl_rmid = rmid;
RecPtr.xlogid = XLogCtl->xlblocks[curridx].xlogid;
- RecPtr.xrecoff =
- XLogCtl->xlblocks[curridx].xrecoff - BLCKSZ +
- Insert->currpos - ((char*) Insert->currpage);
+ RecPtr.xrecoff =
+ XLogCtl->xlblocks[curridx].xrecoff - BLCKSZ +
+ Insert->currpos - ((char *) Insert->currpage);
if (MyLastRecPtr.xrecoff == 0 && rmid != RM_XLOG_ID)
{
SpinAcquire(SInvalLock);
buf += wlen;
Insert->currpos += wlen;
}
- Insert->currpos = ((char*)Insert->currpage) +
- DOUBLEALIGN(Insert->currpos - ((char*)Insert->currpage));
+ Insert->currpos = ((char *) Insert->currpage) +
+ DOUBLEALIGN(Insert->currpos - ((char *) Insert->currpage));
len = hdrlen + buflen;
}
}
freespace = BLCKSZ - SizeOfXLogPHD - SizeOfXLogSubRecord;
Insert->currpage->xlp_info |= XLP_FIRST_IS_SUBRECORD;
- subrecord = (XLogSubRecord*) Insert->currpos;
+ subrecord = (XLogSubRecord *) Insert->currpos;
Insert->currpos += SizeOfXLogSubRecord;
if (hdrlen > freespace)
{
}
subrecord->xl_info = 0;
RecPtr.xlogid = XLogCtl->xlblocks[curridx].xlogid;
- RecPtr.xrecoff = XLogCtl->xlblocks[curridx].xrecoff -
- BLCKSZ + SizeOfXLogPHD + subrecord->xl_len;
- Insert->currpos = ((char*)Insert->currpage) +
- DOUBLEALIGN(Insert->currpos - ((char*)Insert->currpage));
+ RecPtr.xrecoff = XLogCtl->xlblocks[curridx].xrecoff -
+ BLCKSZ + SizeOfXLogPHD + subrecord->xl_len;
+ Insert->currpos = ((char *) Insert->currpage) +
+ DOUBLEALIGN(Insert->currpos - ((char *) Insert->currpage));
}
- freespace = ((char*) Insert->currpage) + BLCKSZ - Insert->currpos;
+ freespace = ((char *) Insert->currpage) + BLCKSZ - Insert->currpos;
+
/*
* All done! Update global LgwrRqst if some block was filled up.
*/
if (freespace < SizeOfXLogRecord)
- updrqst = true; /* curridx is filled and available for writing out */
+ updrqst = true; /* curridx is filled and available for
+ * writing out */
else
curridx = PrevBufIdx(curridx);
LgwrRqst.Write = XLogCtl->xlblocks[curridx];
{
unsigned i = 0;
- for ( ; ; )
+ for (;;)
{
if (!TAS(&(XLogCtl->info_lck)))
{
}
return (RecPtr);
-}
+}
void
XLogFlush(XLogRecPtr record)
{
- XLogRecPtr WriteRqst;
- char buffer[BLCKSZ];
- char *usebuf = NULL;
- unsigned i = 0;
- bool force_lgwr = false;
+ XLogRecPtr WriteRqst;
+ char buffer[BLCKSZ];
+ char *usebuf = NULL;
+ unsigned i = 0;
+ bool force_lgwr = false;
if (XLByteLE(record, LgwrResult.Flush))
return;
WriteRqst = LgwrRqst.Write;
- for ( ; ; )
+ for (;;)
{
/* try to read LgwrResult */
if (!TAS(&(XLogCtl->info_lck)))
/* if something was added to log cache then try to flush this too */
if (!TAS(&(XLogCtl->insert_lck)))
{
- XLogCtlInsert *Insert = &XLogCtl->Insert;
- uint32 freespace =
- ((char*) Insert->currpage) + BLCKSZ - Insert->currpos;
+ XLogCtlInsert *Insert = &XLogCtl->Insert;
+ uint32 freespace =
+ ((char *) Insert->currpage) + BLCKSZ - Insert->currpos;
if (freespace < SizeOfXLogRecord) /* buffer is full */
{
memcpy(usebuf, Insert->currpage, BLCKSZ - freespace);
memset(usebuf + BLCKSZ - freespace, 0, freespace);
WriteRqst = XLogCtl->xlblocks[Insert->curridx];
- WriteRqst.xrecoff = WriteRqst.xrecoff - BLCKSZ +
- Insert->currpos - ((char*) Insert->currpage);
+ WriteRqst.xrecoff = WriteRqst.xrecoff - BLCKSZ +
+ Insert->currpos - ((char *) Insert->currpage);
}
S_UNLOCK(&(XLogCtl->insert_lck));
force_lgwr = true;
}
- if (force_lgwr || WriteRqst.xlogid > record.xlogid ||
- (WriteRqst.xlogid == record.xlogid &&
+ if (force_lgwr || WriteRqst.xlogid > record.xlogid ||
+ (WriteRqst.xlogid == record.xlogid &&
WriteRqst.xrecoff >= record.xrecoff + BLCKSZ))
{
if (!TAS(&(XLogCtl->lgwr_lck)))
s_lock_sleep(i++);
}
- if (logFile >= 0 && (LgwrResult.Write.xlogid != logId ||
- (LgwrResult.Write.xrecoff - 1) / XLogSegSize != logSeg))
+ if (logFile >= 0 && (LgwrResult.Write.xlogid != logId ||
+ (LgwrResult.Write.xrecoff - 1) / XLogSegSize != logSeg))
{
if (close(logFile) != 0)
- elog(STOP, "Close(logfile %u seg %u) failed: %d",
- logId, logSeg, errno);
+ elog(STOP, "Close(logfile %u seg %u) failed: %d",
+ logId, logSeg, errno);
logFile = -1;
}
}
if (fsync(logFile) != 0)
- elog(STOP, "Fsync(logfile %u seg %u) failed: %d",
- logId, logSeg, errno);
+ elog(STOP, "Fsync(logfile %u seg %u) failed: %d",
+ logId, logSeg, errno);
LgwrResult.Flush = LgwrResult.Write;
- for (i = 0; ; )
+ for (i = 0;;)
{
if (!TAS(&(XLogCtl->info_lck)))
{
static void
GetFreeXLBuffer()
{
- XLogCtlInsert *Insert = &XLogCtl->Insert;
- XLogCtlWrite *Write = &XLogCtl->Write;
- uint16 curridx = NextBufIdx(Insert->curridx);
+ XLogCtlInsert *Insert = &XLogCtl->Insert;
+ XLogCtlWrite *Write = &XLogCtl->Write;
+ uint16 curridx = NextBufIdx(Insert->curridx);
LgwrRqst.Write = XLogCtl->xlblocks[Insert->curridx];
- for ( ; ; )
+ for (;;)
{
if (!TAS(&(XLogCtl->info_lck)))
{
return;
}
}
+
/*
* LgwrResult lock is busy or un-updated. Try to acquire lgwr lock
* and write full blocks.
InitXLBuffer(curridx);
return;
}
- /*
- * Have to write buffers while holding insert lock -
- * not good...
+
+ /*
+ * Have to write buffers while holding insert lock - not
+ * good...
*/
XLogWrite(NULL);
S_UNLOCK(&(XLogCtl->lgwr_lck));
static void
XLogWrite(char *buffer)
{
- XLogCtlWrite *Write = &XLogCtl->Write;
- char *from;
- uint32 wcnt = 0;
- int i = 0;
+ XLogCtlWrite *Write = &XLogCtl->Write;
+ char *from;
+ uint32 wcnt = 0;
+ int i = 0;
- for ( ; XLByteLT(LgwrResult.Write, LgwrRqst.Write); )
+ for (; XLByteLT(LgwrResult.Write, LgwrRqst.Write);)
{
LgwrResult.Write = XLogCtl->xlblocks[Write->curridx];
- if (LgwrResult.Write.xlogid != logId ||
+ if (LgwrResult.Write.xlogid != logId ||
(LgwrResult.Write.xrecoff - 1) / XLogSegSize != logSeg)
{
if (wcnt > 0)
{
if (fsync(logFile) != 0)
- elog(STOP, "Fsync(logfile %u seg %u) failed: %d",
- logId, logSeg, errno);
+ elog(STOP, "Fsync(logfile %u seg %u) failed: %d",
+ logId, logSeg, errno);
if (LgwrResult.Write.xlogid != logId)
LgwrResult.Flush.xrecoff = XLogFileSize;
else
if (logFile >= 0)
{
if (close(logFile) != 0)
- elog(STOP, "Close(logfile %u seg %u) failed: %d",
- logId, logSeg, errno);
+ elog(STOP, "Close(logfile %u seg %u) failed: %d",
+ logId, logSeg, errno);
logFile = -1;
}
logId = LgwrResult.Write.xlogid;
if (logOff != (LgwrResult.Write.xrecoff - BLCKSZ) % XLogSegSize)
{
logOff = (LgwrResult.Write.xrecoff - BLCKSZ) % XLogSegSize;
- if (lseek(logFile, (off_t)logOff, SEEK_SET) < 0)
- elog(STOP, "Lseek(logfile %u seg %u off %u) failed: %d",
- logId, logSeg, logOff, errno);
+ if (lseek(logFile, (off_t) logOff, SEEK_SET) < 0)
+ elog(STOP, "Lseek(logfile %u seg %u off %u) failed: %d",
+ logId, logSeg, logOff, errno);
}
if (buffer != NULL && XLByteLT(LgwrRqst.Write, LgwrResult.Write))
from = XLogCtl->pages + Write->curridx * BLCKSZ;
if (write(logFile, from, BLCKSZ) != BLCKSZ)
- elog(STOP, "Write(logfile %u seg %u off %u) failed: %d",
- logId, logSeg, logOff, errno);
+ elog(STOP, "Write(logfile %u seg %u off %u) failed: %d",
+ logId, logSeg, logOff, errno);
wcnt++;
logOff += BLCKSZ;
if (wcnt == 0)
elog(STOP, "XLogWrite: nothing written");
- if (XLByteLT(LgwrResult.Flush, LgwrRqst.Flush) &&
+ if (XLByteLT(LgwrResult.Flush, LgwrRqst.Flush) &&
XLByteLE(LgwrRqst.Flush, LgwrResult.Write))
{
if (fsync(logFile) != 0)
- elog(STOP, "Fsync(logfile %u seg %u) failed: %d",
- logId, logSeg, errno);
+ elog(STOP, "Fsync(logfile %u seg %u) failed: %d",
+ logId, logSeg, errno);
LgwrResult.Flush = LgwrResult.Write;
}
- for ( ; ; )
+ for (;;)
{
if (!TAS(&(XLogCtl->info_lck)))
{
static int
XLogFileInit(uint32 log, uint32 seg)
{
- char path[MAXPGPATH];
- int fd;
+ char path[MAXPGPATH];
+ int fd;
XLogFileName(path, log, seg);
unlink(path);
tryAgain:
#ifndef __CYGWIN__
- fd = open(path, O_RDWR|O_CREAT|O_EXCL, S_IRUSR|S_IWUSR);
+ fd = open(path, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
#else
- fd = open(path, O_RDWR|O_CREAT|O_EXCL|O_BINARY, S_IRUSR|S_IWUSR);
+ fd = open(path, O_RDWR | O_CREAT | O_EXCL | O_BINARY, S_IRUSR | S_IWUSR);
#endif
if (fd < 0 && (errno == EMFILE || errno == ENFILE))
{
fd = errno;
if (!ReleaseDataFile())
- elog(STOP, "Create(logfile %u seg %u) failed: %d (and no one data file can be closed)",
- logId, logSeg, fd);
+ elog(STOP, "Create(logfile %u seg %u) failed: %d (and no one data file can be closed)",
+ logId, logSeg, fd);
goto tryAgain;
}
if (fd < 0)
- elog(STOP, "Init(logfile %u seg %u) failed: %d",
- logId, logSeg, errno);
+ elog(STOP, "Init(logfile %u seg %u) failed: %d",
+ logId, logSeg, errno);
if (lseek(fd, XLogSegSize - 1, SEEK_SET) != (off_t) (XLogSegSize - 1))
- elog(STOP, "Lseek(logfile %u seg %u) failed: %d",
- logId, logSeg, errno);
+ elog(STOP, "Lseek(logfile %u seg %u) failed: %d",
+ logId, logSeg, errno);
if (write(fd, "", 1) != 1)
- elog(STOP, "Init(logfile %u seg %u) failed: %d",
- logId, logSeg, errno);
+ elog(STOP, "Init(logfile %u seg %u) failed: %d",
+ logId, logSeg, errno);
if (fsync(fd) != 0)
- elog(STOP, "Fsync(logfile %u seg %u) failed: %d",
- logId, logSeg, errno);
+ elog(STOP, "Fsync(logfile %u seg %u) failed: %d",
+ logId, logSeg, errno);
if (lseek(fd, 0, SEEK_SET) < 0)
- elog(STOP, "Lseek(logfile %u seg %u off %u) failed: %d",
- log, seg, 0, errno);
+ elog(STOP, "Lseek(logfile %u seg %u off %u) failed: %d",
+ log, seg, 0, errno);
- return(fd);
+ return (fd);
}
static int
XLogFileOpen(uint32 log, uint32 seg, bool econt)
{
- char path[MAXPGPATH];
- int fd;
+ char path[MAXPGPATH];
+ int fd;
XLogFileName(path, log, seg);
{
fd = errno;
if (!ReleaseDataFile())
- elog(STOP, "Open(logfile %u seg %u) failed: %d (and no one data file can be closed)",
- logId, logSeg, fd);
+ elog(STOP, "Open(logfile %u seg %u) failed: %d (and no one data file can be closed)",
+ logId, logSeg, fd);
goto tryAgain;
}
if (fd < 0)
if (econt && errno == ENOENT)
{
elog(LOG, "Open(logfile %u seg %u) failed: file doesn't exist",
- logId, logSeg);
+ logId, logSeg);
return (fd);
}
- elog(STOP, "Open(logfile %u seg %u) failed: %d",
- logId, logSeg, errno);
+ elog(STOP, "Open(logfile %u seg %u) failed: %d",
+ logId, logSeg, errno);
}
- return(fd);
+ return (fd);
}
-static XLogRecord*
+static XLogRecord *
ReadRecord(XLogRecPtr *RecPtr, char *buffer)
{
- XLogRecord *record;
- XLogRecPtr tmpRecPtr = EndRecPtr;
- bool nextmode = (RecPtr == NULL);
- int emode = (nextmode) ? LOG : STOP;
- bool noBlck = false;
+ XLogRecord *record;
+ XLogRecPtr tmpRecPtr = EndRecPtr;
+ bool nextmode = (RecPtr == NULL);
+ int emode = (nextmode) ? LOG : STOP;
+ bool noBlck = false;
if (nextmode)
{
}
else if (!XRecOffIsValid(RecPtr->xrecoff))
elog(STOP, "ReadRecord: invalid record offset in (%u, %u)",
- RecPtr->xlogid, RecPtr->xrecoff);
+ RecPtr->xlogid, RecPtr->xrecoff);
- if (readFile >= 0 && (RecPtr->xlogid != readId ||
- RecPtr->xrecoff / XLogSegSize != readSeg))
+ if (readFile >= 0 && (RecPtr->xlogid != readId ||
+ RecPtr->xrecoff / XLogSegSize != readSeg))
{
close(readFile);
readFile = -1;
if (noBlck || readOff != (RecPtr->xrecoff % XLogSegSize) / BLCKSZ)
{
readOff = (RecPtr->xrecoff % XLogSegSize) / BLCKSZ;
- if (lseek(readFile, (off_t)(readOff * BLCKSZ), SEEK_SET) < 0)
- elog(STOP, "ReadRecord: lseek(logfile %u seg %u off %u) failed: %d",
- readId, readSeg, readOff, errno);
+ if (lseek(readFile, (off_t) (readOff * BLCKSZ), SEEK_SET) < 0)
+ elog(STOP, "ReadRecord: lseek(logfile %u seg %u off %u) failed: %d",
+ readId, readSeg, readOff, errno);
if (read(readFile, readBuf, BLCKSZ) != BLCKSZ)
- elog(STOP, "ReadRecord: read(logfile %u seg %u off %u) failed: %d",
- readId, readSeg, readOff, errno);
- if (((XLogPageHeader)readBuf)->xlp_magic != XLOG_PAGE_MAGIC)
+ elog(STOP, "ReadRecord: read(logfile %u seg %u off %u) failed: %d",
+ readId, readSeg, readOff, errno);
+ if (((XLogPageHeader) readBuf)->xlp_magic != XLOG_PAGE_MAGIC)
{
elog(emode, "ReadRecord: invalid magic number %u in logfile %u seg %u off %u",
- ((XLogPageHeader)readBuf)->xlp_magic,
- readId, readSeg, readOff);
+ ((XLogPageHeader) readBuf)->xlp_magic,
+ readId, readSeg, readOff);
goto next_record_is_invalid;
}
}
- if ((((XLogPageHeader)readBuf)->xlp_info & XLP_FIRST_IS_SUBRECORD) &&
+ if ((((XLogPageHeader) readBuf)->xlp_info & XLP_FIRST_IS_SUBRECORD) &&
RecPtr->xrecoff % BLCKSZ == SizeOfXLogPHD)
{
elog(emode, "ReadRecord: subrecord is requested by (%u, %u)",
- RecPtr->xlogid, RecPtr->xrecoff);
+ RecPtr->xlogid, RecPtr->xrecoff);
goto next_record_is_invalid;
}
- record = (XLogRecord*)((char*) readBuf + RecPtr->xrecoff % BLCKSZ);
+ record = (XLogRecord *) ((char *) readBuf + RecPtr->xrecoff % BLCKSZ);
got_record:;
- if (record->xl_len == 0 || record->xl_len >
+ if (record->xl_len == 0 || record->xl_len >
(BLCKSZ - RecPtr->xrecoff % BLCKSZ - SizeOfXLogRecord))
{
elog(emode, "ReadRecord: invalid record len %u in (%u, %u)",
- record->xl_len, RecPtr->xlogid, RecPtr->xrecoff);
+ record->xl_len, RecPtr->xlogid, RecPtr->xrecoff);
goto next_record_is_invalid;
}
if (record->xl_rmid > RM_MAX_ID)
{
elog(emode, "ReadRecord: invalid resource managed id %u in (%u, %u)",
- record->xl_rmid, RecPtr->xlogid, RecPtr->xrecoff);
+ record->xl_rmid, RecPtr->xlogid, RecPtr->xrecoff);
goto next_record_is_invalid;
}
nextRecord = NULL;
if (record->xl_info & XLR_TO_BE_CONTINUED)
{
- XLogSubRecord *subrecord;
- uint32 len = record->xl_len;
+ XLogSubRecord *subrecord;
+ uint32 len = record->xl_len;
if (record->xl_len + RecPtr->xrecoff % BLCKSZ + SizeOfXLogRecord != BLCKSZ)
{
elog(emode, "ReadRecord: invalid fragmented record len %u in (%u, %u)",
- record->xl_len, RecPtr->xlogid, RecPtr->xrecoff);
+ record->xl_len, RecPtr->xlogid, RecPtr->xrecoff);
goto next_record_is_invalid;
}
memcpy(buffer, record, record->xl_len + SizeOfXLogRecord);
- record = (XLogRecord*) buffer;
+ record = (XLogRecord *) buffer;
buffer += record->xl_len + SizeOfXLogRecord;
- for ( ; ; )
+ for (;;)
{
readOff++;
if (readOff == XLogSegSize / BLCKSZ)
goto next_record_is_invalid;
}
if (read(readFile, readBuf, BLCKSZ) != BLCKSZ)
- elog(STOP, "ReadRecord: read(logfile %u seg %u off %u) failed: %d",
- readId, readSeg, readOff, errno);
- if (((XLogPageHeader)readBuf)->xlp_magic != XLOG_PAGE_MAGIC)
+ elog(STOP, "ReadRecord: read(logfile %u seg %u off %u) failed: %d",
+ readId, readSeg, readOff, errno);
+ if (((XLogPageHeader) readBuf)->xlp_magic != XLOG_PAGE_MAGIC)
{
elog(emode, "ReadRecord: invalid magic number %u in logfile %u seg %u off %u",
- ((XLogPageHeader)readBuf)->xlp_magic,
- readId, readSeg, readOff);
+ ((XLogPageHeader) readBuf)->xlp_magic,
+ readId, readSeg, readOff);
goto next_record_is_invalid;
}
- if (!(((XLogPageHeader)readBuf)->xlp_info & XLP_FIRST_IS_SUBRECORD))
+ if (!(((XLogPageHeader) readBuf)->xlp_info & XLP_FIRST_IS_SUBRECORD))
{
elog(emode, "ReadRecord: there is no subrecord flag in logfile %u seg %u off %u",
- readId, readSeg, readOff);
+ readId, readSeg, readOff);
goto next_record_is_invalid;
}
- subrecord = (XLogSubRecord*)((char*) readBuf + SizeOfXLogPHD);
- if (subrecord->xl_len == 0 || subrecord->xl_len >
+ subrecord = (XLogSubRecord *) ((char *) readBuf + SizeOfXLogPHD);
+ if (subrecord->xl_len == 0 || subrecord->xl_len >
(BLCKSZ - SizeOfXLogPHD - SizeOfXLogSubRecord))
{
elog(emode, "ReadRecord: invalid subrecord len %u in logfile %u seg %u off %u",
- subrecord->xl_len, readId, readSeg, readOff);
+ subrecord->xl_len, readId, readSeg, readOff);
goto next_record_is_invalid;
}
len += subrecord->xl_len;
if (len > MAXLOGRECSZ)
{
elog(emode, "ReadRecord: too long record len %u in (%u, %u)",
- len, RecPtr->xlogid, RecPtr->xrecoff);
+ len, RecPtr->xlogid, RecPtr->xrecoff);
goto next_record_is_invalid;
}
- memcpy(buffer, (char*)subrecord + SizeOfXLogSubRecord, subrecord->xl_len);
+ memcpy(buffer, (char *) subrecord + SizeOfXLogSubRecord, subrecord->xl_len);
buffer += subrecord->xl_len;
if (subrecord->xl_info & XLR_TO_BE_CONTINUED)
{
- if (subrecord->xl_len +
+ if (subrecord->xl_len +
SizeOfXLogPHD + SizeOfXLogSubRecord != BLCKSZ)
{
elog(emode, "ReadRecord: invalid fragmented subrecord len %u in logfile %u seg %u off %u",
- subrecord->xl_len, readId, readSeg, readOff);
+ subrecord->xl_len, readId, readSeg, readOff);
goto next_record_is_invalid;
}
continue;
}
break;
}
- if (BLCKSZ - SizeOfXLogRecord >=
+ if (BLCKSZ - SizeOfXLogRecord >=
subrecord->xl_len + SizeOfXLogPHD + SizeOfXLogSubRecord)
{
- nextRecord = (XLogRecord*)
- ((char*)subrecord + subrecord->xl_len + SizeOfXLogSubRecord);
+ nextRecord = (XLogRecord *)
+ ((char *) subrecord + subrecord->xl_len + SizeOfXLogSubRecord);
}
EndRecPtr.xlogid = readId;
- EndRecPtr.xrecoff = readSeg * XLogSegSize + readOff * BLCKSZ +
+ EndRecPtr.xrecoff = readSeg * XLogSegSize + readOff * BLCKSZ +
SizeOfXLogPHD + SizeOfXLogSubRecord + subrecord->xl_len;
ReadRecPtr = *RecPtr;
- return(record);
+ return (record);
}
- if (BLCKSZ - SizeOfXLogRecord >=
+ if (BLCKSZ - SizeOfXLogRecord >=
record->xl_len + RecPtr->xrecoff % BLCKSZ + SizeOfXLogRecord)
- {
- nextRecord = (XLogRecord*)((char*)record + record->xl_len + SizeOfXLogRecord);
- }
+ nextRecord = (XLogRecord *) ((char *) record + record->xl_len + SizeOfXLogRecord);
EndRecPtr.xlogid = RecPtr->xlogid;
EndRecPtr.xrecoff = RecPtr->xrecoff + record->xl_len + SizeOfXLogRecord;
ReadRecPtr = *RecPtr;
- return(record);
+ return (record);
next_record_is_invalid:;
close(readFile);
readFile = -1;
nextRecord = NULL;
memset(buffer, 0, SizeOfXLogRecord);
- record = (XLogRecord*) buffer;
+ record = (XLogRecord *) buffer;
+
/*
* If we assumed that next record began on the same page where
* previous one ended - zero end of page.
*/
if (XLByteEQ(tmpRecPtr, EndRecPtr))
{
- Assert (EndRecPtr.xrecoff % BLCKSZ > (SizeOfXLogPHD + SizeOfXLogSubRecord) &&
- BLCKSZ - EndRecPtr.xrecoff % BLCKSZ >= SizeOfXLogRecord);
+ Assert(EndRecPtr.xrecoff % BLCKSZ > (SizeOfXLogPHD + SizeOfXLogSubRecord) &&
+ BLCKSZ - EndRecPtr.xrecoff % BLCKSZ >= SizeOfXLogRecord);
readId = EndRecPtr.xlogid;
readSeg = EndRecPtr.xrecoff / XLogSegSize;
readOff = (EndRecPtr.xrecoff % XLogSegSize) / BLCKSZ;
elog(LOG, "Formatting logfile %u seg %u block %u at offset %u",
- readId, readSeg, readOff, EndRecPtr.xrecoff % BLCKSZ);
+ readId, readSeg, readOff, EndRecPtr.xrecoff % BLCKSZ);
readFile = XLogFileOpen(readId, readSeg, false);
- if (lseek(readFile, (off_t)(readOff * BLCKSZ), SEEK_SET) < 0)
- elog(STOP, "ReadRecord: lseek(logfile %u seg %u off %u) failed: %d",
- readId, readSeg, readOff, errno);
+ if (lseek(readFile, (off_t) (readOff * BLCKSZ), SEEK_SET) < 0)
+ elog(STOP, "ReadRecord: lseek(logfile %u seg %u off %u) failed: %d",
+ readId, readSeg, readOff, errno);
if (read(readFile, readBuf, BLCKSZ) != BLCKSZ)
- elog(STOP, "ReadRecord: read(logfile %u seg %u off %u) failed: %d",
- readId, readSeg, readOff, errno);
- memset(readBuf + EndRecPtr.xrecoff % BLCKSZ, 0,
- BLCKSZ - EndRecPtr.xrecoff % BLCKSZ);
- if (lseek(readFile, (off_t)(readOff * BLCKSZ), SEEK_SET) < 0)
- elog(STOP, "ReadRecord: lseek(logfile %u seg %u off %u) failed: %d",
- readId, readSeg, readOff, errno);
+ elog(STOP, "ReadRecord: read(logfile %u seg %u off %u) failed: %d",
+ readId, readSeg, readOff, errno);
+ memset(readBuf + EndRecPtr.xrecoff % BLCKSZ, 0,
+ BLCKSZ - EndRecPtr.xrecoff % BLCKSZ);
+ if (lseek(readFile, (off_t) (readOff * BLCKSZ), SEEK_SET) < 0)
+ elog(STOP, "ReadRecord: lseek(logfile %u seg %u off %u) failed: %d",
+ readId, readSeg, readOff, errno);
if (write(readFile, readBuf, BLCKSZ) != BLCKSZ)
- elog(STOP, "ReadRecord: write(logfile %u seg %u off %u) failed: %d",
- readId, readSeg, readOff, errno);
+ elog(STOP, "ReadRecord: write(logfile %u seg %u off %u) failed: %d",
+ readId, readSeg, readOff, errno);
readOff++;
}
else
{
- Assert (EndRecPtr.xrecoff % BLCKSZ == 0 ||
- BLCKSZ - EndRecPtr.xrecoff % BLCKSZ < SizeOfXLogRecord);
+ Assert(EndRecPtr.xrecoff % BLCKSZ == 0 ||
+ BLCKSZ - EndRecPtr.xrecoff % BLCKSZ < SizeOfXLogRecord);
readId = tmpRecPtr.xlogid;
readSeg = tmpRecPtr.xrecoff / XLogSegSize;
readOff = (tmpRecPtr.xrecoff % XLogSegSize) / BLCKSZ;
{
if (!XLByteEQ(tmpRecPtr, EndRecPtr))
elog(LOG, "Formatting logfile %u seg %u block %u at offset 0",
- readId, readSeg, readOff);
+ readId, readSeg, readOff);
readOff *= BLCKSZ;
memset(readBuf, 0, BLCKSZ);
readFile = XLogFileOpen(readId, readSeg, false);
- if (lseek(readFile, (off_t)readOff, SEEK_SET) < 0)
- elog(STOP, "ReadRecord: lseek(logfile %u seg %u off %u) failed: %d",
- readId, readSeg, readOff, errno);
+ if (lseek(readFile, (off_t) readOff, SEEK_SET) < 0)
+ elog(STOP, "ReadRecord: lseek(logfile %u seg %u off %u) failed: %d",
+ readId, readSeg, readOff, errno);
while (readOff < XLogSegSize)
{
if (write(readFile, readBuf, BLCKSZ) != BLCKSZ)
- elog(STOP, "ReadRecord: write(logfile %u seg %u off %u) failed: %d",
- readId, readSeg, readOff, errno);
+ elog(STOP, "ReadRecord: write(logfile %u seg %u off %u) failed: %d",
+ readId, readSeg, readOff, errno);
readOff += BLCKSZ;
}
}
if (readFile >= 0)
{
if (fsync(readFile) < 0)
- elog(STOP, "ReadRecord: fsync(logfile %u seg %u) failed: %d",
- readId, readSeg, errno);
+ elog(STOP, "ReadRecord: fsync(logfile %u seg %u) failed: %d",
+ readId, readSeg, errno);
close(readFile);
readFile = -1;
}
readId++;
}
{
- char path[MAXPGPATH];
+ char path[MAXPGPATH];
XLogFileName(path, readId, readSeg);
unlink(path);
}
- return(record);
+ return (record);
}
void
UpdateControlFile()
{
- int fd;
+ int fd;
tryAgain:
#ifndef __CYGWIN__
{
fd = errno;
if (!ReleaseDataFile())
- elog(STOP, "Open(cntlfile) failed: %d (and no one data file can be closed)",
- fd);
+ elog(STOP, "Open(cntlfile) failed: %d (and no one data file can be closed)",
+ fd);
goto tryAgain;
}
if (fd < 0)
if (XLOGbuffers < MinXLOGbuffers)
XLOGbuffers = MinXLOGbuffers;
- return(sizeof(XLogCtlData) + BLCKSZ * XLOGbuffers +
+ return (sizeof(XLogCtlData) + BLCKSZ * XLOGbuffers +
sizeof(XLogRecPtr) * XLOGbuffers + BLCKSZ);
}
void
XLOGShmemInit(void)
{
- bool found;
+ bool found;
if (XLOGbuffers < MinXLOGbuffers)
XLOGbuffers = MinXLOGbuffers;
- ControlFile = (ControlFileData*)
+ ControlFile = (ControlFileData *)
ShmemInitStruct("Control File", BLCKSZ, &found);
Assert(!found);
- XLogCtl = (XLogCtlData*)
- ShmemInitStruct("XLOG Ctl", sizeof(XLogCtlData) + BLCKSZ * XLOGbuffers +
+ XLogCtl = (XLogCtlData *)
+ ShmemInitStruct("XLOG Ctl", sizeof(XLogCtlData) + BLCKSZ * XLOGbuffers +
sizeof(XLogRecPtr) * XLOGbuffers, &found);
Assert(!found);
}
void
BootStrapXLOG()
{
- int fd;
- char buffer[BLCKSZ];
- CheckPoint checkPoint;
+ int fd;
+ char buffer[BLCKSZ];
+ CheckPoint checkPoint;
#ifdef NOT_USED
- XLogPageHeader page = (XLogPageHeader)buffer;
- XLogRecord *record;
+ XLogPageHeader page = (XLogPageHeader) buffer;
+ XLogRecord *record;
+
#endif
#ifndef __CYGWIN__
- fd = open(ControlFilePath, O_RDWR|O_CREAT|O_EXCL, S_IRUSR|S_IWUSR);
+ fd = open(ControlFilePath, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
#else
- fd = open(ControlFilePath, O_RDWR|O_CREAT|O_EXCL|O_BINARY, S_IRUSR|S_IWUSR);
+ fd = open(ControlFilePath, O_RDWR | O_CREAT | O_EXCL | O_BINARY, S_IRUSR | S_IWUSR);
#endif
if (fd < 0)
- elog(STOP, "BootStrapXLOG failed to create control file (%s): %d",
- ControlFilePath, errno);
+ elog(STOP, "BootStrapXLOG failed to create control file (%s): %d",
+ ControlFilePath, errno);
checkPoint.redo.xlogid = 0;
checkPoint.redo.xrecoff = SizeOfXLogPHD;
checkPoint.undo = checkPoint.redo;
checkPoint.nextXid = FirstTransactionId;
- checkPoint.nextOid = BootstrapObjectIdData;
+ checkPoint.nextOid = BootstrapObjectIdData;
#ifdef NOT_USED
memset(buffer, 0, BLCKSZ);
page->xlp_magic = XLOG_PAGE_MAGIC;
page->xlp_info = 0;
- record = (XLogRecord*) ((char*)page + SizeOfXLogPHD);
- record->xl_prev.xlogid = 0; record->xl_prev.xrecoff = 0;
+ record = (XLogRecord *) ((char *) page + SizeOfXLogPHD);
+ record->xl_prev.xlogid = 0;
+ record->xl_prev.xrecoff = 0;
record->xl_xact_prev = record->xl_prev;
record->xl_xid = InvalidTransactionId;
record->xl_len = sizeof(checkPoint);
record->xl_info = 0;
record->xl_rmid = RM_XLOG_ID;
- memcpy((char*)record + SizeOfXLogRecord, &checkPoint, sizeof(checkPoint));
+ memcpy((char *) record + SizeOfXLogRecord, &checkPoint, sizeof(checkPoint));
logFile = XLogFileInit(0, 0);
#endif
memset(buffer, 0, BLCKSZ);
- ControlFile = (ControlFileData*) buffer;
+ ControlFile = (ControlFileData *) buffer;
ControlFile->logId = 0;
ControlFile->logSeg = 1;
ControlFile->checkPoint = checkPoint.redo;
close(fd);
}
-static char*
+static char *
str_time(time_t tnow)
{
- char *result = ctime(&tnow);
- char *p = strchr(result, '\n');
+ char *result = ctime(&tnow);
+ char *p = strchr(result, '\n');
if (p != NULL)
*p = 0;
- return(result);
+ return (result);
}
/*
StartupXLOG()
{
#ifdef NOT_USED
- XLogCtlInsert *Insert;
- CheckPoint checkPoint;
- XLogRecPtr RecPtr,
- LastRec;
- XLogRecord *record;
- char buffer[MAXLOGRECSZ+SizeOfXLogRecord];
- int recovery = 0;
- bool sie_saved = false;
+ XLogCtlInsert *Insert;
+ CheckPoint checkPoint;
+ XLogRecPtr RecPtr,
+ LastRec;
+ XLogRecord *record;
+ char buffer[MAXLOGRECSZ + SizeOfXLogRecord];
+ int recovery = 0;
+ bool sie_saved = false;
+
#endif
- int fd;
+ int fd;
elog(LOG, "Data Base System is starting up at %s", str_time(time(NULL)));
- XLogCtl->xlblocks = (XLogRecPtr*) (((char *)XLogCtl) + sizeof(XLogCtlData));
- XLogCtl->pages = ((char *)XLogCtl->xlblocks + sizeof(XLogRecPtr) * XLOGbuffers);
+ XLogCtl->xlblocks = (XLogRecPtr *) (((char *) XLogCtl) + sizeof(XLogCtlData));
+ XLogCtl->pages = ((char *) XLogCtl->xlblocks + sizeof(XLogRecPtr) * XLOGbuffers);
XLogCtl->XLogCacheByte = BLCKSZ * XLOGbuffers;
XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
memset(XLogCtl->xlblocks, 0, sizeof(XLogRecPtr) * XLOGbuffers);
{
fd = errno;
if (!ReleaseDataFile())
- elog(STOP, "Open(\"%s\") failed: %d (and no one data file can be closed)",
- ControlFilePath, fd);
+ elog(STOP, "Open(\"%s\") failed: %d (and no one data file can be closed)",
+ ControlFilePath, fd);
goto tryAgain;
}
if (fd < 0)
close(fd);
- if (ControlFile->logSeg == 0 ||
- ControlFile->time <= 0 ||
- ControlFile->state < DB_SHUTDOWNED ||
- ControlFile->state > DB_IN_PRODUCTION ||
+ if (ControlFile->logSeg == 0 ||
+ ControlFile->time <= 0 ||
+ ControlFile->state < DB_SHUTDOWNED ||
+ ControlFile->state > DB_IN_PRODUCTION ||
!XRecOffIsValid(ControlFile->checkPoint.xrecoff))
elog(STOP, "Control file context is broken");
if (ControlFile->state == DB_SHUTDOWNED)
elog(LOG, "Data Base System was shut down at %s",
- str_time(ControlFile->time));
+ str_time(ControlFile->time));
else if (ControlFile->state == DB_SHUTDOWNING)
elog(LOG, "Data Base System was interrupted when shutting down at %s",
- str_time(ControlFile->time));
+ str_time(ControlFile->time));
else if (ControlFile->state == DB_IN_RECOVERY)
{
elog(LOG, "Data Base System was interrupted being in recovery at %s\n"
- "\tThis propably means that some data blocks are corrupted\n"
- "\tAnd you will have to use last backup for recovery",
- str_time(ControlFile->time));
+ "\tThis propably means that some data blocks are corrupted\n"
+ "\tAnd you will have to use last backup for recovery",
+ str_time(ControlFile->time));
}
else if (ControlFile->state == DB_IN_PRODUCTION)
elog(LOG, "Data Base System was interrupted being in production at %s",
- str_time(ControlFile->time));
+ str_time(ControlFile->time));
#ifdef NOT_USED
elog(STOP, "Invalid RMID in checkPoint record");
if (record->xl_len != sizeof(checkPoint))
elog(STOP, "Invalid length of checkPoint record");
- checkPoint = *((CheckPoint*)((char*)record + SizeOfXLogRecord));
+ checkPoint = *((CheckPoint *) ((char *) record + SizeOfXLogRecord));
elog(LOG, "Redo record at (%u, %u); Undo record at (%u, %u)",
- checkPoint.redo.xlogid, checkPoint.redo.xrecoff,
- checkPoint.undo.xlogid, checkPoint.undo.xrecoff);
+ checkPoint.redo.xlogid, checkPoint.redo.xrecoff,
+ checkPoint.undo.xlogid, checkPoint.undo.xrecoff);
elog(LOG, "NextTransactionId: %u; NextOid: %u",
- checkPoint.nextXid, checkPoint.nextOid);
- if (checkPoint.nextXid < FirstTransactionId ||
+ checkPoint.nextXid, checkPoint.nextOid);
+ if (checkPoint.nextXid < FirstTransactionId ||
checkPoint.nextOid < BootstrapObjectIdData)
#ifdef XLOG
elog(STOP, "Invalid NextTransactionId/NextOid");
if (recovery > 0)
{
elog(LOG, "The DataBase system was not properly shut down\n"
- "\tAutomatic recovery is in progress...");
+ "\tAutomatic recovery is in progress...");
ControlFile->state = DB_IN_RECOVERY;
ControlFile->time = time(NULL);
UpdateControlFile();
/* Is REDO required ? */
if (XLByteLT(checkPoint.redo, RecPtr))
record = ReadRecord(&(checkPoint.redo), buffer);
- else /* read past CheckPoint record */
+ else
+/* read past CheckPoint record */
record = ReadRecord(NULL, buffer);
/* REDO */
if (record->xl_len != 0)
{
- elog(LOG, "Redo starts at (%u, %u)",
- ReadRecPtr.xlogid, ReadRecPtr.xrecoff);
+ elog(LOG, "Redo starts at (%u, %u)",
+ ReadRecPtr.xlogid, ReadRecPtr.xrecoff);
do
{
#ifdef XLOG
RmgrTable[record->xl_rmid].rm_redo(EndRecPtr, record);
record = ReadRecord(NULL, buffer);
} while (record->xl_len != 0);
- elog(LOG, "Redo done at (%u, %u)",
- ReadRecPtr.xlogid, ReadRecPtr.xrecoff);
+ elog(LOG, "Redo done at (%u, %u)",
+ ReadRecPtr.xlogid, ReadRecPtr.xrecoff);
LastRec = ReadRecPtr;
}
else
RecPtr = ReadRecPtr;
if (XLByteLT(checkPoint.undo, RecPtr))
{
- elog(LOG, "Undo starts at (%u, %u)",
- RecPtr.xlogid, RecPtr.xrecoff);
+ elog(LOG, "Undo starts at (%u, %u)",
+ RecPtr.xlogid, RecPtr.xrecoff);
do
{
record = ReadRecord(&RecPtr, buffer);
- if (TransactionIdIsValid(record->xl_xid) &&
+ if (TransactionIdIsValid(record->xl_xid) &&
!TransactionIdDidCommit(record->xl_xid))
RmgrTable[record->xl_rmid].rm_undo(record);
RecPtr = record->xl_prev;
} while (XLByteLE(checkPoint.undo, RecPtr));
- elog(LOG, "Undo done at (%u, %u)",
- ReadRecPtr.xlogid, ReadRecPtr.xrecoff);
+ elog(LOG, "Undo done at (%u, %u)",
+ ReadRecPtr.xlogid, ReadRecPtr.xrecoff);
}
else
{
logOff = 0;
logFile = XLogFileOpen(logId, logSeg, false);
XLogCtl->xlblocks[0].xlogid = logId;
- XLogCtl->xlblocks[0].xrecoff =
- ((EndRecPtr.xrecoff - 1) / BLCKSZ + 1) * BLCKSZ;
+ XLogCtl->xlblocks[0].xrecoff =
+ ((EndRecPtr.xrecoff - 1) / BLCKSZ + 1) * BLCKSZ;
Insert = &XLogCtl->Insert;
- memcpy((char*)(Insert->currpage), readBuf, BLCKSZ);
- Insert->currpos = ((char*) Insert->currpage) +
+ memcpy((char *) (Insert->currpage), readBuf, BLCKSZ);
+ Insert->currpos = ((char *) Insert->currpage) +
(EndRecPtr.xrecoff + BLCKSZ - XLogCtl->xlblocks[0].xrecoff);
Insert->PrevRecord = ControlFile->checkPoint;
if (recovery > 0)
{
- int i;
+ int i;
- /*
+ /*
* Let resource managers know that recovery is done
*/
for (i = 0; i <= RM_MAX_ID; i++)
StopIfError = sie_saved;
}
-#endif /* NOT_USED */
+#endif /* NOT_USED */
ControlFile->state = DB_IN_PRODUCTION;
ControlFile->time = time(NULL);
CreateCheckPoint(bool shutdown)
{
#ifdef NOT_USED
- CheckPoint checkPoint;
- XLogRecPtr recptr;
- XLogCtlInsert *Insert = &XLogCtl->Insert;
- uint32 freespace;
- uint16 curridx;
+ CheckPoint checkPoint;
+ XLogRecPtr recptr;
+ XLogCtlInsert *Insert = &XLogCtl->Insert;
+ uint32 freespace;
+ uint16 curridx;
memset(&checkPoint, 0, sizeof(checkPoint));
if (shutdown)
elog(STOP, "XLog insert lock is busy while data base is shutting down");
(void) select(0, NULL, NULL, NULL, &delay);
}
- freespace = ((char*) Insert->currpage) + BLCKSZ - Insert->currpos;
+ freespace = ((char *) Insert->currpage) + BLCKSZ - Insert->currpos;
if (freespace < SizeOfXLogRecord)
{
curridx = NextBufIdx(Insert->curridx);
if (XLByteLE(XLogCtl->xlblocks[curridx], LgwrResult.Write))
InitXLBuffer(curridx);
- else
+ else
GetFreeXLBuffer();
freespace = BLCKSZ - SizeOfXLogPHD;
}
else
curridx = Insert->curridx;
checkPoint.redo.xlogid = XLogCtl->xlblocks[curridx].xlogid;
- checkPoint.redo.xrecoff = XLogCtl->xlblocks[curridx].xrecoff - BLCKSZ +
- Insert->currpos - ((char*) Insert->currpage);
+ checkPoint.redo.xrecoff = XLogCtl->xlblocks[curridx].xrecoff - BLCKSZ +
+ Insert->currpos - ((char *) Insert->currpage);
S_UNLOCK(&(XLogCtl->insert_lck));
SpinAcquire(XidGenLockId);
if (shutdown && checkPoint.undo.xrecoff != 0)
elog(STOP, "Active transaction while data base is shutting down");
- recptr = XLogInsert(RM_XLOG_ID, (char*)&checkPoint, sizeof(checkPoint), NULL, 0);
+ recptr = XLogInsert(RM_XLOG_ID, (char *) &checkPoint, sizeof(checkPoint), NULL, 0);
if (shutdown && !XLByteEQ(checkPoint.redo, MyLastRecPtr))
elog(STOP, "XLog concurrent activity while data base is shutting down");
XLogFlush(recptr);
-#endif /* NOT_USED */
+#endif /* NOT_USED */
SpinAcquire(ControlFileLockId);
if (shutdown)
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.80 2000/02/18 09:28:39 inoue Exp $
+ * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.81 2000/04/12 17:14:54 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#define ALLOC(t, c) (t *)calloc((unsigned)(c), sizeof(t))
-extern void BaseInit(void);
-extern void StartupXLOG(void);
-extern void ShutdownXLOG(void);
-extern void BootStrapXLOG(void);
+extern void BaseInit(void);
+extern void StartupXLOG(void);
+extern void ShutdownXLOG(void);
+extern void BootStrapXLOG(void);
-extern char XLogDir[];
-extern char ControlFilePath[];
+extern char XLogDir[];
+extern char ControlFilePath[];
extern int Int_yyparse(void);
static hashnode *AddStr(char *str, int strlength, int mderef);
{"char", CHAROID, 0, 1, F_CHARIN, F_CHAROUT},
{"name", NAMEOID, 0, NAMEDATALEN, F_NAMEIN, F_NAMEOUT},
{"int2", INT2OID, 0, 2, F_INT2IN, F_INT2OUT},
- {"int2vector", INT2VECTOROID, 0, INDEX_MAX_KEYS*2, F_INT2VECTORIN, F_INT2VECTOROUT},
+ {"int2vector", INT2VECTOROID, 0, INDEX_MAX_KEYS * 2, F_INT2VECTORIN, F_INT2VECTOROUT},
{"int4", INT4OID, 0, 4, F_INT4IN, F_INT4OUT},
{"regproc", REGPROCOID, 0, 4, F_REGPROCIN, F_REGPROCOUT},
{"text", TEXTOID, 0, -1, F_TEXTIN, F_TEXTOUT},
{"tid", TIDOID, 0, 6, F_TIDIN, F_TIDOUT},
{"xid", XIDOID, 0, 4, F_XIDIN, F_XIDOUT},
{"cid", CIDOID, 0, 4, F_CIDIN, F_CIDOUT},
- {"oidvector", 30, 0, INDEX_MAX_KEYS*4, F_OIDVECTORIN, F_OIDVECTOROUT},
+ {"oidvector", 30, 0, INDEX_MAX_KEYS * 4, F_OIDVECTORIN, F_OIDVECTOROUT},
{"smgr", 210, 0, 2, F_SMGRIN, F_SMGROUT},
{"_int4", 1007, INT4OID, -1, F_ARRAY_IN, F_ARRAY_OUT},
{"_aclitem", 1034, 1033, -1, F_ARRAY_IN, F_ARRAY_OUT}
}
/*
- * Bootstrap under Postmaster means two things:
- * (xloginit) ? StartupXLOG : ShutdownXLOG
+ * Bootstrap under Postmaster means two things: (xloginit) ?
+ * StartupXLOG : ShutdownXLOG
*
* If !under Postmaster and xloginit then BootStrapXLOG.
*/
}
if (!IsUnderPostmaster && xloginit)
- {
BootStrapXLOG();
- }
/*
* backend initialization
*/
if (namestrcmp(&attrtypes[i]->attname, "attisset") == 0)
attrtypes[i]->attisset = get_attisset(RelationGetRelid(reldesc),
- NameStr(attrtypes[i]->attname));
+ NameStr(attrtypes[i]->attname));
else
attrtypes[i]->attisset = false;
index_build(heap, ind, ILHead->il_natts, ILHead->il_attnos,
ILHead->il_nparams, ILHead->il_params, ILHead->il_finfo,
ILHead->il_predInfo);
- /* In normal processing mode, index_build would close the heap
- * and index, but in bootstrap mode it will not.
+
+ /*
+ * In normal processing mode, index_build would close the heap and
+ * index, but in bootstrap mode it will not.
*/
/*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/aclchk.c,v 1.37 2000/01/26 05:56:09 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/aclchk.c,v 1.38 2000/04/12 17:14:55 momjian Exp $
*
* NOTES
* See acl.h.
*/
if (((mode & ACL_WR) || (mode & ACL_AP)) &&
!allowSystemTableMods && IsSystemRelationName(relname) &&
- strncmp(relname,"pg_temp.", strlen("pg_temp.")) != 0 &&
+ strncmp(relname, "pg_temp.", strlen("pg_temp.")) != 0 &&
!((Form_pg_shadow) GETSTRUCT(tuple))->usecatupd)
{
elog(DEBUG, "pg_aclcheck: catalog update to \"%s\": permission denied",
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/catalog.c,v 1.31 2000/04/09 04:43:15 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/catalog.c,v 1.32 2000/04/12 17:14:55 momjian Exp $
*
*-------------------------------------------------------------------------
*/
snprintf(path, bufsize, "%s%c%s", DataDir, SEP_CHAR, relname);
return path;
}
+
/*
* If it is in the current database, assume it is in current working
* directory. NB: this does not work during bootstrap!
* relpath_blind - construct path to a relation's file
*
* Construct the path using only the info available to smgrblindwrt,
- * namely the names and OIDs of the database and relation. (Shared system
+ * namely the names and OIDs of the database and relation. (Shared system
* relations are identified with dbid = 0.) Note that we may have to
* access a relation belonging to a different database!
*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.124 2000/03/17 02:36:05 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.125 2000/04/12 17:14:55 momjian Exp $
*
*
* INTERFACE ROUTINES
static void AddNewRelationTuple(Relation pg_class_desc,
- Relation new_rel_desc, Oid new_rel_oid,
- int natts,
- char relkind, char *temp_relname);
+ Relation new_rel_desc, Oid new_rel_oid,
+ int natts,
+ char relkind, char *temp_relname);
static void AddToNoNameRelList(Relation r);
static void DeleteAttributeTuples(Relation rel);
static void RemoveFromNoNameRelList(Relation r);
static void AddNewRelationType(char *typeName, Oid new_rel_oid);
static void StoreAttrDefault(Relation rel, AttrNumber attnum, char *adbin,
- bool updatePgAttribute);
+ bool updatePgAttribute);
static void StoreRelCheck(Relation rel, char *ccname, char *ccbin);
static void StoreConstraints(Relation rel);
static void RemoveConstraints(Relation rel);
rel = (Relation) palloc(len);
MemSet((char *) rel, 0, len);
- rel->rd_fd = -1; /* table is not open */
+ rel->rd_fd = -1; /* table is not open */
rel->rd_unlinked = TRUE; /* table is not created yet */
+
/*
* create a new tuple descriptor from the one passed in
*/
bool
heap_storage_create(Relation rel)
{
- bool smgrcall = false;
+ bool smgrcall = false;
if (rel->rd_unlinked)
{
if (!IsIgnoringSystemIndexes())
{
+
/*
* First, open the catalog indices and insert index tuples for the
* new relation.
* SOMEDAY: fill the STATISTIC relation properly.
* ----------------
*/
- heap_close(new_rel_desc, NoLock); /* do not unlock till end of xact */
+ heap_close(new_rel_desc, NoLock); /* do not unlock till end of xact */
heap_close(pg_class_desc, RowExclusiveLock);
return new_rel_oid;
* 3) remove indexes
* 4) remove pg_class tuple
* 5) remove pg_attribute tuples and related descriptions
- * 6) remove pg_description tuples
+ * 6) remove pg_description tuples
* 7) remove pg_type tuples
* 8) RemoveConstraints ()
* 9) unlink relation
tuple = heap_getnext(scan, 0);
if (HeapTupleIsValid(tuple))
{
- Oid subclass = ((Form_pg_inherits) GETSTRUCT(tuple))->inhrelid;
+ Oid subclass = ((Form_pg_inherits) GETSTRUCT(tuple))->inhrelid;
heap_endscan(scan);
heap_close(catalogRelation, RowExclusiveLock);
{
heap_close(pg_class_desc, RowExclusiveLock);
elog(ERROR, "Relation '%s' does not exist",
- RelationGetRelationName(rel));
+ RelationGetRelationName(rel));
}
/* ----------------
static void
RelationTruncateIndexes(Relation heapRelation)
{
- Relation indexRelation, currentIndex;
+ Relation indexRelation,
+ currentIndex;
ScanKeyData entry;
HeapScanDesc scan;
- HeapTuple indexTuple, procTuple, classTuple;
+ HeapTuple indexTuple,
+ procTuple,
+ classTuple;
Form_pg_index index;
- Oid heapId, indexId, procId, accessMethodId;
- Node *oldPred = NULL;
- PredInfo *predInfo;
- List *cnfPred = NULL;
+ Oid heapId,
+ indexId,
+ procId,
+ accessMethodId;
+ Node *oldPred = NULL;
+ PredInfo *predInfo;
+ List *cnfPred = NULL;
AttrNumber *attributeNumberA;
- FuncIndexInfo fInfo, *funcInfo = NULL;
- int i, numberOfAttributes;
- char *predString;
+ FuncIndexInfo fInfo,
+ *funcInfo = NULL;
+ int i,
+ numberOfAttributes;
+ char *predString;
heapId = RelationGetRelid(heapRelation);
scan = heap_beginscan(indexRelation, false, SnapshotNow, 1, &entry);
while (HeapTupleIsValid(indexTuple = heap_getnext(scan, 0)))
{
+
/*
- * For each index, fetch index attributes so we can apply index_build
+ * For each index, fetch index attributes so we can apply
+ * index_build
*/
index = (Form_pg_index) GETSTRUCT(indexTuple);
indexId = index->indexrelid;
LockRelation(currentIndex, AccessExclusiveLock);
/*
- * Release any buffers associated with this index. If they're dirty,
- * they're just dropped without bothering to flush to disk.
+ * Release any buffers associated with this index. If they're
+ * dirty, they're just dropped without bothering to flush to disk.
*/
ReleaseRelationBuffers(currentIndex);
if (FlushRelationBuffers(currentIndex, (BlockNumber) 0, false) < 0)
attributeNumberA, 0, NULL, funcInfo, predInfo);
/*
- * index_build will close both the heap and index relations
- * (but not give up the locks we hold on them). That's fine
- * for the index, but we need to open the heap again. We need
- * no new lock, since this backend still has the exclusive lock
- * grabbed by heap_truncate.
+ * index_build will close both the heap and index relations (but
+ * not give up the locks we hold on them). That's fine for the
+ * index, but we need to open the heap again. We need no new
+ * lock, since this backend still has the exclusive lock grabbed
+ * by heap_truncate.
*/
heapRelation = heap_open(heapId, NoLock);
Assert(heapRelation != NULL);
}
/* Complete the scan and close pg_index */
- heap_endscan(scan);
+ heap_endscan(scan);
heap_close(indexRelation, AccessShareLock);
}
/* ----------------------------
- * heap_truncate
+ * heap_truncate
*
- * This routine is used to truncate the data from the
- * storage manager of any data within the relation handed
- * to this routine.
+ * This routine is used to truncate the data from the
+ * storage manager of any data within the relation handed
+ * to this routine.
* ----------------------------
*/
void
heap_truncate(char *relname)
{
- Relation rel;
- Oid rid;
+ Relation rel;
+ Oid rid;
/* Open relation for processing, and grab exclusive access on it. */
* they don't exist anyway. So, no warning in that case.
* ----------------
*/
- if (IsTransactionBlock() && ! rel->rd_myxactonly)
+ if (IsTransactionBlock() && !rel->rd_myxactonly)
elog(NOTICE, "Caution: TRUNCATE TABLE cannot be rolled back, so don't abort now");
/*
- * Release any buffers associated with this relation. If they're dirty,
- * they're just dropped without bothering to flush to disk.
+ * Release any buffers associated with this relation. If they're
+ * dirty, they're just dropped without bothering to flush to disk.
*/
ReleaseRelationBuffers(rel);
attnum++)
{
if (HeapTupleIsValid(tup = SearchSysCacheTupleCopy(ATTNUM,
- ObjectIdGetDatum(RelationGetRelid(rel)),
- Int16GetDatum(attnum),
+ ObjectIdGetDatum(RelationGetRelid(rel)),
+ Int16GetDatum(attnum),
0, 0)))
{
-
- /*** Delete any comments associated with this attribute ***/
- DeleteComments(tup->t_data->t_oid);
+ /*** Delete any comments associated with this attribute ***/
+
+ DeleteComments(tup->t_data->t_oid);
- heap_delete(pg_attribute_desc, &tup->t_self, NULL);
- heap_freetuple(tup);
+ heap_delete(pg_attribute_desc, &tup->t_self, NULL);
+ heap_freetuple(tup);
}
}
* we release the read lock on pg_type. -mer 13 Aug 1991
* ----------------
*/
-
+
heap_delete(pg_type_desc, &tup->t_self, NULL);
heap_endscan(pg_type_scan);
* they don't exist anyway. So, no warning in that case.
* ----------------
*/
- if (IsTransactionBlock() && ! rel->rd_myxactonly)
+ if (IsTransactionBlock() && !rel->rd_myxactonly)
elog(NOTICE, "Caution: DROP TABLE cannot be rolled back, so don't abort now");
/* ----------------
/*
* Close relcache entry, but *keep* AccessExclusiveLock on the
- * relation until transaction commit. This ensures no one else
- * will try to do something with the doomed relation.
+ * relation until transaction commit. This ensures no one else will
+ * try to do something with the doomed relation.
*/
heap_close(rel, NoLock);
Relation idescs[Num_pg_attrdef_indices];
HeapTuple tuple;
Datum values[4];
- static char nulls[4] = {' ', ' ', ' ', ' '};
+ static char nulls[4] = {' ', ' ', ' ', ' '};
Relation attrrel;
Relation attridescs[Num_pg_attr_indices];
HeapTuple atttup;
* Need to construct source equivalent of given node-string.
*/
expr = stringToNode(adbin);
+
/*
* deparse_expression needs a RangeTblEntry list, so make one
*/
heap_freetuple(tuple);
pfree(adsrc);
- if (! updatePgAttribute)
+ if (!updatePgAttribute)
return; /* done if pg_attribute is OK */
attrrel = heap_openr(AttributeRelationName, RowExclusiveLock);
atttup = SearchSysCacheTupleCopy(ATTNUM,
- ObjectIdGetDatum(RelationGetRelid(rel)),
+ ObjectIdGetDatum(RelationGetRelid(rel)),
(Datum) attnum, 0, 0);
if (!HeapTupleIsValid(atttup))
elog(ERROR, "cache lookup of attribute %d in relation %u failed",
attnum, RelationGetRelid(rel));
attStruct = (Form_pg_attribute) GETSTRUCT(atttup);
- if (! attStruct->atthasdef)
+ if (!attStruct->atthasdef)
{
attStruct->atthasdef = true;
heap_update(attrrel, &atttup->t_self, atttup, NULL);
Relation idescs[Num_pg_relcheck_indices];
HeapTuple tuple;
Datum values[4];
- static char nulls[4] = {' ', ' ', ' ', ' '};
+ static char nulls[4] = {' ', ' ', ' ', ' '};
/*
* Convert condition to a normal boolean expression tree.
*/
expr = stringToNode(ccbin);
expr = (Node *) make_ands_explicit((List *) expr);
+
/*
* deparse_expression needs a RangeTblEntry list, so make one
*/
if (!constr)
return;
- /* deparsing of constraint expressions will fail unless the just-created
- * pg_attribute tuples for this relation are made visible. So, bump
- * the command counter.
+ /*
+ * deparsing of constraint expressions will fail unless the
+ * just-created pg_attribute tuples for this relation are made
+ * visible. So, bump the command counter.
*/
CommandCounterIncrement();
* expression.
*
* NB: caller should have opened rel with AccessExclusiveLock, and should
- * hold that lock till end of transaction. Also, we assume the caller has
+ * hold that lock till end of transaction. Also, we assume the caller has
* done a CommandCounterIncrement if necessary to make the relation's catalog
* tuples visible.
*/
}
/*
- * Create a dummy ParseState and insert the target relation as
- * its sole rangetable entry. We need a ParseState for transformExpr.
+ * Create a dummy ParseState and insert the target relation as its
+ * sole rangetable entry. We need a ParseState for transformExpr.
*/
pstate = make_parsestate(NULL);
makeRangeTable(pstate, NULL);
Oid type_id;
Assert(colDef->raw_default != NULL);
+
/*
* Transform raw parsetree to executable expression.
*/
expr = transformExpr(pstate, colDef->raw_default, EXPR_COLUMN_FIRST);
+
/*
* Make sure default expr does not refer to any vars.
*/
if (contain_var_clause(expr))
elog(ERROR, "Cannot use attribute(s) in DEFAULT clause");
+
/*
- * Check that it will be possible to coerce the expression
- * to the column's type. We store the expression without
- * coercion, however, to avoid premature coercion in cases like
+ * Check that it will be possible to coerce the expression to the
+ * column's type. We store the expression without coercion,
+ * however, to avoid premature coercion in cases like
*
* CREATE TABLE tbl (fld datetime DEFAULT 'now');
*
- * NB: this should match the code in updateTargetListEntry()
- * that will actually do the coercion, to ensure we don't accept
- * an unusable default expression.
+ * NB: this should match the code in updateTargetListEntry() that
+ * will actually do the coercion, to ensure we don't accept an
+ * unusable default expression.
*/
type_id = exprType(expr);
if (type_id != InvalidOid)
if (type_id != atp->atttypid)
{
if (CoerceTargetExpr(NULL, expr, type_id,
- atp->atttypid, atp->atttypmod) == NULL)
+ atp->atttypid, atp->atttypmod) == NULL)
elog(ERROR, "Attribute '%s' is of type '%s'"
" but default expression is of type '%s'"
- "\n\tYou will need to rewrite or cast the expression",
+ "\n\tYou will need to rewrite or cast the expression",
NameStr(atp->attname),
typeidTypeName(atp->atttypid),
typeidTypeName(type_id));
}
}
+
/*
* Might as well try to reduce any constant expressions.
*/
expr = eval_const_expressions(expr);
+
/*
* Must fix opids, in case any operators remain...
*/
fix_opids(expr);
+
/*
* OK, store it.
*/
ccname = (char *) palloc(NAMEDATALEN);
snprintf(ccname, NAMEDATALEN, "$%d", numchecks + 1);
}
+
/*
* Transform raw parsetree to executable expression.
*/
expr = transformExpr(pstate, cdef->raw_expr, EXPR_COLUMN_FIRST);
+
/*
* Make sure it yields a boolean result.
*/
if (exprType(expr) != BOOLOID)
elog(ERROR, "CHECK '%s' does not yield boolean result",
ccname);
+
/*
* Make sure no outside relations are referred to.
*/
if (length(pstate->p_rtable) != 1)
elog(ERROR, "Only relation '%s' can be referenced in CHECK",
relname);
+
/*
* Might as well try to reduce any constant expressions.
*/
expr = eval_const_expressions(expr);
+
/*
* Constraints are evaluated with execQual, which expects an
* implicit-AND list, so convert expression to implicit-AND form.
* overkill...)
*/
expr = (Node *) make_ands_implicit((Expr *) expr);
+
/*
* Must fix opids in operator clauses.
*/
fix_opids(expr);
+
/*
* OK, store it.
*/
* We do this even if there was no change, in order to ensure that an
* SI update message is sent out for the pg_class tuple, which will
* force other backends to rebuild their relcache entries for the rel.
- * (Of course, for a newly created rel there is no need for an SI message,
- * but for ALTER TABLE ADD ATTRIBUTE this'd be important.)
+ * (Of course, for a newly created rel there is no need for an SI
+ * message, but for ALTER TABLE ADD ATTRIBUTE this'd be important.)
*/
relrel = heap_openr(RelationRelationName, RowExclusiveLock);
reltup = SearchSysCacheTupleCopy(RELOID,
- ObjectIdGetDatum(RelationGetRelid(rel)),
+ ObjectIdGetDatum(RelationGetRelid(rel)),
0, 0, 0);
if (!HeapTupleIsValid(reltup))
elog(ERROR, "cache lookup of relation %u failed", RelationGetRelid(rel));
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.107 2000/03/01 05:39:24 inoue Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.108 2000/04/12 17:14:55 momjian Exp $
*
*
* INTERFACE ROUTINES
/* non-export function prototypes */
static Oid GetHeapRelationOid(char *heapRelationName, char *indexRelationName,
- bool istemp);
+ bool istemp);
static TupleDesc BuildFuncTupleDesc(FuncIndexInfo *funcInfo);
static TupleDesc ConstructTupleDescriptor(Oid heapoid, Relation heapRelation,
- List *attributeList, int numatts, AttrNumber *attNums);
+ List *attributeList, int numatts, AttrNumber *attNums);
static void ConstructIndexReldesc(Relation indexRelation, Oid amoid);
static Oid UpdateRelationRelation(Relation indexRelation, char *temp_relname);
static void InitializeAttributeOids(Relation indexRelation,
- int numatts, Oid indexoid);
+ int numatts, Oid indexoid);
static void AppendAttributeTuples(Relation indexRelation, int numatts);
static void UpdateIndexRelation(Oid indexoid, Oid heapoid,
- FuncIndexInfo *funcInfo, int natts,
- AttrNumber *attNums, Oid *classOids, Node *predicate,
- List *attributeList, bool islossy, bool unique, bool primary);
+ FuncIndexInfo *funcInfo, int natts,
+ AttrNumber *attNums, Oid *classOids, Node *predicate,
+ List *attributeList, bool islossy, bool unique, bool primary);
static void DefaultBuild(Relation heapRelation, Relation indexRelation,
- int numberOfAttributes, AttrNumber *attributeNumber,
- IndexStrategy indexStrategy, uint16 parameterCount,
+ int numberOfAttributes, AttrNumber *attributeNumber,
+ IndexStrategy indexStrategy, uint16 parameterCount,
Datum *parameter, FuncIndexInfoPtr funcInfo, PredInfo *predInfo);
-static Oid IndexGetRelation(Oid indexId);
+static Oid IndexGetRelation(Oid indexId);
-static bool reindexing = false;
-extern bool SetReindexProcessing(bool reindexmode)
+static bool reindexing = false;
+extern bool
+SetReindexProcessing(bool reindexmode)
{
- bool old = reindexing;
+ bool old = reindexing;
+
reindexing = reindexmode;
return old;
}
-extern bool IsReindexProcessing(void)
+extern bool
+IsReindexProcessing(void)
{
return reindexing;
}
+
/* ----------------------------------------------------------------
* sysatts is a structure containing attribute tuple forms
* for system attributes (numbered -1, -2, ...). This really
* ----------------
*/
indexRelation = heap_create(indexRelationName,
- indexTupDesc, false, istemp, false);
+ indexTupDesc, false, istemp, false);
/* ----------------
* construct the index relation descriptor
* bootstrapping. Otherwise, we call the routine that constructs the
* index.
*
- * In normal processing mode, the heap and index relations are closed
- * by index_build() --- but we continue to hold the ShareLock on the
- * heap that we acquired above, until end of transaction.
+ * In normal processing mode, the heap and index relations are closed by
+ * index_build() --- but we continue to hold the ShareLock on the heap
+ * that we acquired above, until end of transaction.
*/
if (IsBootstrapProcessingMode())
{
* they don't exist anyway. So, no warning in that case.
* ----------------
*/
- if (IsTransactionBlock() && ! userIndexRelation->rd_myxactonly)
+ if (IsTransactionBlock() && !userIndexRelation->rd_myxactonly)
elog(NOTICE, "Caution: DROP INDEX cannot be rolled back, so don't abort now");
/* ----------------
* ----------------
*/
DeleteComments(indexId);
-
+
/* ----------------
* fix RELATION relation
* ----------------
* --------------------------------------------
*/
static
-bool LockClassinfoForUpdate(Oid relid, HeapTuple rtup, Buffer *buffer, bool confirmCommitted)
+bool
+LockClassinfoForUpdate(Oid relid, HeapTuple rtup, Buffer *buffer, bool confirmCommitted)
{
HeapTuple classTuple;
- Form_pg_class pgcform;
+ Form_pg_class pgcform;
bool test;
Relation relationRelation;
classTuple = SearchSysCacheTuple(RELOID, PointerGetDatum(relid),
- 0, 0, 0);
+ 0, 0, 0);
if (!HeapTupleIsValid(classTuple))
return false;
rtup->t_self = classTuple->t_self;
RelationInvalidateHeapTuple(relationRelation, rtup);
if (confirmCommitted)
{
- HeapTupleHeader th = rtup->t_data;
+ HeapTupleHeader th = rtup->t_data;
+
if (!(th->t_infomask & HEAP_XMIN_COMMITTED))
elog(ERROR, "The tuple isn't committed");
if (th->t_infomask & HEAP_XMAX_COMMITTED)
* Indexes of the relation active ?
* ---------------------------------------------
*/
-bool IndexesAreActive(Oid relid, bool confirmCommitted)
+bool
+IndexesAreActive(Oid relid, bool confirmCommitted)
{
- HeapTupleData tuple;
+ HeapTupleData tuple;
Relation indexRelation;
Buffer buffer;
- HeapScanDesc scan;
- ScanKeyData entry;
+ HeapScanDesc scan;
+ ScanKeyData entry;
bool isactive;
if (!LockClassinfoForUpdate(relid, &tuple, &buffer, confirmCommitted))
elog(ERROR, "IndexesAreActive couldn't lock %u", relid);
if (((Form_pg_class) GETSTRUCT(&tuple))->relkind != RELKIND_RELATION)
- elog(ERROR, "relation %u isn't an relation", relid);
+ elog(ERROR, "relation %u isn't an relation", relid);
isactive = ((Form_pg_class) GETSTRUCT(&tuple))->relhasindex;
ReleaseBuffer(buffer);
if (isactive)
return isactive;
indexRelation = heap_openr(IndexRelationName, AccessShareLock);
ScanKeyEntryInitialize(&entry, 0, Anum_pg_index_indrelid,
- F_OIDEQ, ObjectIdGetDatum(relid));
+ F_OIDEQ, ObjectIdGetDatum(relid));
scan = heap_beginscan(indexRelation, false, SnapshotNow,
- 1, &entry);
+ 1, &entry);
if (!heap_getnext(scan, 0))
isactive = true;
heap_endscan(scan);
Relation whichRel;
Relation pg_class;
HeapTuple tuple;
- Form_pg_class rd_rel;
- HeapScanDesc pg_class_scan = NULL;
+ Form_pg_class rd_rel;
+ HeapScanDesc pg_class_scan = NULL;
/* ----------------
* This routine handles updates for only the heap relation
if (!IsIgnoringSystemIndexes())
{
tuple = SearchSysCacheTupleCopy(RELOID,
- ObjectIdGetDatum(relid), 0, 0, 0);
+ ObjectIdGetDatum(relid), 0, 0, 0);
}
else
{
heap_close(pg_class, RowExclusiveLock);
elog(ERROR, "setRelhasindexInplace: cannot scan RELATION relation");
}
+
/*
- * Confirm that target tuple is locked by this transaction
- * in case of immedaite updation.
+ * Confirm that target tuple is locked by this transaction in case of
+ * immedaite updation.
*/
if (immediate)
{
- HeapTupleHeader th = tuple->t_data;
+ HeapTupleHeader th = tuple->t_data;
+
if (!(th->t_infomask & HEAP_XMIN_COMMITTED))
elog(ERROR, "Immediate hasindex updation can be done only for committed tuples %x", th->t_infomask);
if (th->t_infomask & HEAP_XMAX_INVALID)
}
else
{
- HeapTupleData htup;
+ HeapTupleData htup;
Buffer buffer;
htup.t_self = tuple->t_self;
Datum values[Natts_pg_class];
char nulls[Natts_pg_class];
char replace[Natts_pg_class];
- HeapScanDesc pg_class_scan = NULL;
+ HeapScanDesc pg_class_scan = NULL;
bool in_place_upd;
/* ----------------
* pattern "CREATE TABLE; CREATE INDEX; insert data" leaves the table
* with zero size statistics until a VACUUM is done. The optimizer will
* generate very bad plans if the stats claim the table is empty when
- * it is actually sizable. See also CREATE TABLE in heap.c.
+ * it is actually sizable. See also CREATE TABLE in heap.c.
* ----------------
*/
relpages = RelationGetNumberOfBlocks(whichRel);
char *nullv;
long reltuples,
indtuples;
+
#ifndef OMIT_PARTIAL_INDEX
ExprContext *econtext;
TupleTable tupleTable;
TupleTableSlot *slot;
+
#endif
Node *predicate;
Node *oldPred;
reltuples++;
#ifndef OMIT_PARTIAL_INDEX
+
/*
* If oldPred != NULL, this is an EXTEND INDEX command, so skip
* this tuple if it was already in the existing partial index
{
/* SetSlotContents(slot, heapTuple); */
slot->val = heapTuple;
- if (! ExecQual((List *) predicate, econtext, false))
+ if (!ExecQual((List *) predicate, econtext, false))
continue;
}
#endif /* OMIT_PARTIAL_INDEX */
/*
* Since we just counted the tuples in the heap, we update its stats
* in pg_class to guarantee that the planner takes advantage of the
- * index we just created. But, only update statistics during
- * normal index definitions, not for indices on system catalogs
- * created during bootstrap processing. We must close the relations
- * before updating statistics to guarantee that the relcache entries
- * are flushed when we increment the command counter in UpdateStats().
- * But we do not release any locks on the relations; those will be
- * held until end of transaction.
+ * index we just created. But, only update statistics during normal
+ * index definitions, not for indices on system catalogs created
+ * during bootstrap processing. We must close the relations before
+ * updating statistics to guarantee that the relcache entries are
+ * flushed when we increment the command counter in UpdateStats(). But
+ * we do not release any locks on the relations; those will be held
+ * until end of transaction.
*/
if (IsNormalProcessingMode())
{
- Oid hrelid = RelationGetRelid(heapRelation);
- Oid irelid = RelationGetRelid(indexRelation);
+ Oid hrelid = RelationGetRelid(heapRelation);
+ Oid irelid = RelationGetRelid(indexRelation);
bool inplace = IsReindexProcessing();
heap_close(heapRelation, NoLock);
/*
* IndexGetRelation: given an index's relation OID, get the OID of the
- * relation it is an index on. Uses the system cache.
+ * relation it is an index on. Uses the system cache.
*/
static Oid
IndexGetRelation(Oid indexId)
bool
activate_index(Oid indexId, bool activate)
{
- if (!activate) /* Currently does nothing */
+ if (!activate) /* Currently does nothing */
return true;
return reindex_index(indexId, false);
}
-
+
/* --------------------------------
* reindex_index - This routine is used to recreate an index
* --------------------------------
bool
reindex_index(Oid indexId, bool force)
{
- Relation iRel, indexRelation, heapRelation;
- ScanKeyData entry;
- HeapScanDesc scan;
- HeapTuple indexTuple, procTuple, classTuple;
- Form_pg_index index;
- Oid heapId, procId, accessMethodId;
- Node *oldPred = NULL;
- PredInfo *predInfo;
- AttrNumber *attributeNumberA;
- FuncIndexInfo fInfo, *funcInfo = NULL;
- int i, numberOfAttributes;
- char *predString;
+ Relation iRel,
+ indexRelation,
+ heapRelation;
+ ScanKeyData entry;
+ HeapScanDesc scan;
+ HeapTuple indexTuple,
+ procTuple,
+ classTuple;
+ Form_pg_index index;
+ Oid heapId,
+ procId,
+ accessMethodId;
+ Node *oldPred = NULL;
+ PredInfo *predInfo;
+ AttrNumber *attributeNumberA;
+ FuncIndexInfo fInfo,
+ *funcInfo = NULL;
+ int i,
+ numberOfAttributes;
+ char *predString;
bool old;
old = SetReindexProcessing(true);
LockRelation(iRel, AccessExclusiveLock);
/*
- * Release any buffers associated with this index. If they're dirty,
+ * Release any buffers associated with this index. If they're dirty,
* they're just dropped without bothering to flush to disk.
*/
ReleaseRelationBuffers(iRel);
/* Initialize the index and rebuild */
InitIndexStrategy(numberOfAttributes, iRel, accessMethodId);
index_build(heapRelation, iRel, numberOfAttributes,
- attributeNumberA, 0, NULL, funcInfo, predInfo);
+ attributeNumberA, 0, NULL, funcInfo, predInfo);
/*
- * index_build will close both the heap and index relations
- * (but not give up the locks we hold on them). That's fine
- * for the index, but we need to open the heap again. We need
- * no new lock, since this backend still has the exclusive lock
- * grabbed by heap_truncate.
+ * index_build will close both the heap and index relations (but not
+ * give up the locks we hold on them). That's fine for the index, but
+ * we need to open the heap again. We need no new lock, since this
+ * backend still has the exclusive lock grabbed by heap_truncate.
*/
iRel = index_open(indexId);
Assert(iRel != NULL);
/*
* ----------------------------
- * activate_indexes_of_a_table
+ * activate_indexes_of_a_table
* activate/deactivate indexes of the specified table.
* ----------------------------
*/
if (!activate)
setRelhasindexInplace(relid, false, true);
else
- {
return false;
- }
}
else
{
if (activate)
reindex_relation(relid, false);
else
- {
return false;
- }
}
return true;
}
+
/* --------------------------------
* reindex_relation - This routine is used to recreate indexes
* of a relation.
reindex_relation(Oid relid, bool force)
{
Relation indexRelation;
- ScanKeyData entry;
- HeapScanDesc scan;
+ ScanKeyData entry;
+ HeapScanDesc scan;
HeapTuple indexTuple;
- bool old, reindexed;
+ bool old,
+ reindexed;
old = SetReindexProcessing(true);
if (IndexesAreActive(relid, true))
indexRelation = heap_openr(IndexRelationName, AccessShareLock);
ScanKeyEntryInitialize(&entry, 0, Anum_pg_index_indrelid,
- F_OIDEQ, ObjectIdGetDatum(relid));
+ F_OIDEQ, ObjectIdGetDatum(relid));
scan = heap_beginscan(indexRelation, false, SnapshotNow,
- 1, &entry);
+ 1, &entry);
reindexed = false;
while (HeapTupleIsValid(indexTuple = heap_getnext(scan, 0)))
{
- Form_pg_index index = (Form_pg_index) GETSTRUCT(indexTuple);
+ Form_pg_index index = (Form_pg_index) GETSTRUCT(indexTuple);
+
if (activate_index(index->indexrelid, true))
reindexed = true;
else
heap_endscan(scan);
heap_close(indexRelation, AccessShareLock);
if (reindexed)
- {
setRelhasindexInplace(relid, true, false);
- }
SetReindexProcessing(old);
return reindexed;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/indexing.c,v 1.59 2000/02/18 09:28:41 inoue Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/indexing.c,v 1.60 2000/04/12 17:14:56 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
char *Name_pg_aggregate_indices[Num_pg_aggregate_indices] =
- {AggregateNameTypeIndex};
+{AggregateNameTypeIndex};
char *Name_pg_am_indices[Num_pg_am_indices] =
- {AmNameIndex};
+{AmNameIndex};
char *Name_pg_amop_indices[Num_pg_amop_indices] =
- {AccessMethodOpidIndex, AccessMethodStrategyIndex};
+{AccessMethodOpidIndex, AccessMethodStrategyIndex};
char *Name_pg_attr_indices[Num_pg_attr_indices] =
- {AttributeRelidNameIndex, AttributeRelidNumIndex};
+{AttributeRelidNameIndex, AttributeRelidNumIndex};
char *Name_pg_attrdef_indices[Num_pg_attrdef_indices] =
- {AttrDefaultIndex};
+{AttrDefaultIndex};
char *Name_pg_class_indices[Num_pg_class_indices] =
- {ClassNameIndex, ClassOidIndex};
+{ClassNameIndex, ClassOidIndex};
char *Name_pg_group_indices[Num_pg_group_indices] =
- {GroupNameIndex, GroupSysidIndex};
+{GroupNameIndex, GroupSysidIndex};
char *Name_pg_index_indices[Num_pg_index_indices] =
- {IndexRelidIndex};
+{IndexRelidIndex};
char *Name_pg_inherits_indices[Num_pg_inherits_indices] =
- {InheritsRelidSeqnoIndex};
+{InheritsRelidSeqnoIndex};
char *Name_pg_language_indices[Num_pg_language_indices] =
- {LanguageOidIndex, LanguageNameIndex};
+{LanguageOidIndex, LanguageNameIndex};
char *Name_pg_listener_indices[Num_pg_listener_indices] =
- {ListenerRelnamePidIndex};
+{ListenerRelnamePidIndex};
char *Name_pg_opclass_indices[Num_pg_opclass_indices] =
- {OpclassNameIndex, OpclassDeftypeIndex};
+{OpclassNameIndex, OpclassDeftypeIndex};
char *Name_pg_operator_indices[Num_pg_operator_indices] =
- {OperatorOidIndex, OperatorNameIndex};
+{OperatorOidIndex, OperatorNameIndex};
char *Name_pg_proc_indices[Num_pg_proc_indices] =
- {ProcedureOidIndex, ProcedureNameIndex};
+{ProcedureOidIndex, ProcedureNameIndex};
char *Name_pg_relcheck_indices[Num_pg_relcheck_indices] =
- {RelCheckIndex};
+{RelCheckIndex};
char *Name_pg_rewrite_indices[Num_pg_rewrite_indices] =
- {RewriteOidIndex, RewriteRulenameIndex};
+{RewriteOidIndex, RewriteRulenameIndex};
char *Name_pg_shadow_indices[Num_pg_shadow_indices] =
- {ShadowNameIndex, ShadowSysidIndex};
+{ShadowNameIndex, ShadowSysidIndex};
char *Name_pg_statistic_indices[Num_pg_statistic_indices] =
- {StatisticRelidAttnumIndex};
+{StatisticRelidAttnumIndex};
char *Name_pg_trigger_indices[Num_pg_trigger_indices] =
- {TriggerRelidIndex, TriggerConstrNameIndex, TriggerConstrRelidIndex};
+{TriggerRelidIndex, TriggerConstrNameIndex, TriggerConstrRelidIndex};
char *Name_pg_type_indices[Num_pg_type_indices] =
- {TypeNameIndex, TypeOidIndex};
-char *Name_pg_description_indices[Num_pg_description_indices] =
- {DescriptionObjIndex};
+{TypeNameIndex, TypeOidIndex};
+char *Name_pg_description_indices[Num_pg_description_indices] =
+{DescriptionObjIndex};
static HeapTuple CatalogIndexFetchTuple(Relation heapRelation,
- Relation idesc,
- ScanKey skey,
- int16 num_keys);
+ Relation idesc,
+ ScanKey skey,
+ int16 num_keys);
/*
/*---------------------------------------------------------------------
- * Class-specific index lookups
+ * Class-specific index lookups
*---------------------------------------------------------------------
*/
Relation idesc;
ScanKeyData skey[2];
HeapTuple tuple;
-
+
ScanKeyEntryInitialize(&skey[0],
(bits16) 0x0,
(AttrNumber) 1,
Relation idesc;
ScanKeyData skey[1];
HeapTuple tuple;
-
+
ScanKeyEntryInitialize(&skey[0],
(bits16) 0x0,
(AttrNumber) 1,
HeapTuple
AttributeRelidNameIndexScan(Relation heapRelation,
- Oid relid,
- char *attname)
+ Oid relid,
+ char *attname)
{
Relation idesc;
ScanKeyData skey[2];
HeapTuple
AttributeRelidNumIndexScan(Relation heapRelation,
- Oid relid,
- AttrNumber attnum)
+ Oid relid,
+ AttrNumber attnum)
{
Relation idesc;
ScanKeyData skey[2];
Relation idesc;
ScanKeyData skey[1];
HeapTuple tuple;
-
+
ScanKeyEntryInitialize(&skey[0],
(bits16) 0x0,
(AttrNumber) 1,
Relation idesc;
ScanKeyData skey[1];
HeapTuple tuple;
-
+
ScanKeyEntryInitialize(&skey[0],
(bits16) 0x0,
(AttrNumber) 1,
Relation idesc;
ScanKeyData skey[1];
HeapTuple tuple;
-
+
ScanKeyEntryInitialize(&skey[0],
(bits16) 0x0,
(AttrNumber) 1,
HeapTuple
InheritsRelidSeqnoIndexScan(Relation heapRelation,
- Oid relid,
- int4 seqno)
+ Oid relid,
+ int4 seqno)
{
Relation idesc;
ScanKeyData skey[2];
Relation idesc;
ScanKeyData skey[1];
HeapTuple tuple;
-
+
ScanKeyEntryInitialize(&skey[0],
(bits16) 0x0,
(AttrNumber) 1,
Relation idesc;
ScanKeyData skey[2];
HeapTuple tuple;
-
+
ScanKeyEntryInitialize(&skey[0],
(bits16) 0x0,
(AttrNumber) 1,
HeapTuple
OperatorNameIndexScan(Relation heapRelation,
- char *oprName,
- Oid oprLeft,
- Oid oprRight,
- char oprKind)
+ char *oprName,
+ Oid oprLeft,
+ Oid oprRight,
+ char oprKind)
{
Relation idesc;
ScanKeyData skey[4];
Relation idesc;
ScanKeyData skey[1];
HeapTuple tuple;
-
+
ScanKeyEntryInitialize(&skey[0],
(bits16) 0x0,
(AttrNumber) 1,
Relation idesc;
ScanKeyData skey[1];
HeapTuple tuple;
-
+
ScanKeyEntryInitialize(&skey[0],
(bits16) 0x0,
(AttrNumber) 1,
Relation idesc;
ScanKeyData skey[1];
HeapTuple tuple;
-
+
ScanKeyEntryInitialize(&skey[0],
(bits16) 0x0,
(AttrNumber) 1,
Relation idesc;
ScanKeyData skey[1];
HeapTuple tuple;
-
+
ScanKeyEntryInitialize(&skey[0],
(bits16) 0x0,
(AttrNumber) 1,
HeapTuple
StatisticRelidAttnumIndexScan(Relation heapRelation,
- Oid relId,
- AttrNumber attNum)
+ Oid relId,
+ AttrNumber attNum)
{
Relation idesc;
ScanKeyData skey[2];
return tuple;
}
-
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/pg_aggregate.c,v 1.30 2000/03/26 19:43:58 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/pg_aggregate.c,v 1.31 2000/04/12 17:14:56 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* handle finalfn */
if (aggfinalfnName)
{
- int nargs = 0;
+ int nargs = 0;
if (OidIsValid(xret1))
fnArgs[nargs++] = xret1;
{
if (nargs == 2)
elog(ERROR, "AggregateCreate: '%s'('%s','%s') does not exist",
- aggfinalfnName, aggtransfn1typeName, aggtransfn2typeName);
+ aggfinalfnName, aggtransfn1typeName, aggtransfn2typeName);
else if (OidIsValid(xret1))
elog(ERROR, "AggregateCreate: '%s'('%s') does not exist",
aggfinalfnName, aggtransfn1typeName);
}
else
{
- /* If no finalfn, aggregate result type is type of the sole
- * state value (we already checked there is only one)
+
+ /*
+ * If no finalfn, aggregate result type is type of the sole state
+ * value (we already checked there is only one)
*/
if (OidIsValid(xret1))
fret = xret1;
Assert(xfuncno == 1 || xfuncno == 2);
/*
- * since we will have to use fastgetattr (in case one or both init vals
- * are NULL), we will need to open the relation. Do that first to
- * ensure we don't get a stale tuple from the cache.
+ * since we will have to use fastgetattr (in case one or both init
+ * vals are NULL), we will need to open the relation. Do that first
+ * to ensure we don't get a stale tuple from the cache.
*/
aggRel = heap_openr(AggregateRelationName, AccessShareLock);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/pg_proc.c,v 1.41 2000/04/04 21:44:37 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/pg_proc.c,v 1.42 2000/04/12 17:14:56 momjian Exp $
*
*-------------------------------------------------------------------------
*/
return tup->t_data->t_oid;
#else
elog(ERROR, "lookup for procedure by source needs fix (Jan)");
-#endif /* SETS_FIXED */
+#endif /* SETS_FIXED */
}
}
prosrc = procedureName;
if (fmgr_lookupByName(prosrc) == (func_ptr) NULL)
elog(ERROR,
- "ProcedureCreate: there is no builtin function named \"%s\"",
+ "ProcedureCreate: there is no builtin function named \"%s\"",
prosrc);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.49 2000/01/26 05:56:11 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.50 2000/04/12 17:14:56 momjian Exp $
*
*-------------------------------------------------------------------------
*/
values[i++] = (Datum) GetUserId(); /* 2 */
values[i++] = (Datum) internalSize; /* 3 */
values[i++] = (Datum) externalSize; /* 4 */
- values[i++] = (Datum) passedByValue;/* 5 */
+ values[i++] = (Datum) passedByValue; /* 5 */
values[i++] = (Datum) typeType; /* 6 */
values[i++] = (Datum) (bool) 1; /* 7 */
values[i++] = (Datum) typDelim; /* 8 */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/_deadcode/Attic/recipe.c,v 1.10 2000/01/26 05:56:17 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/_deadcode/Attic/recipe.c,v 1.11 2000/04/12 17:15:06 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (parameterCount == FUNC_MAX_ARGS)
{
elog(ERROR,
- "getParamTypes: Ingredients cannot take > %d arguments",FUNC_MAX_ARGS);
+ "getParamTypes: Ingredients cannot take > %d arguments", FUNC_MAX_ARGS);
}
t = elem->inTypes->val[j];
if (strcmp(t, "opaque") == 0)
{
TgElement *elem;
char *funcName;
- Oid typev[FUNC_MAX_ARGS], /* eight arguments maximum */
+ Oid typev[FUNC_MAX_ARGS], /* eight arguments maximum */
relid;
int i,
parameterCount;
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/async.c,v 1.58 2000/01/26 05:56:12 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/async.c,v 1.59 2000/04/12 17:14:57 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* no point in making duplicate entries in the list ... */
if (!AsyncExistsPendingNotify(relname))
{
+
/*
* We allocate list memory from the global malloc pool to ensure
- * that it will live until we want to use it. This is probably not
- * necessary any longer, since we will use it before the end of the
- * transaction. DLList only knows how to use malloc() anyway, but we
- * could probably palloc() the strings...
+ * that it will live until we want to use it. This is probably
+ * not necessary any longer, since we will use it before the end
+ * of the transaction. DLList only knows how to use malloc()
+ * anyway, but we could probably palloc() the strings...
*/
notifyName = strdup(relname);
DLAddHead(pendingNotifies, DLNewElem(notifyName));
if (listenerPID == MyProcPid)
{
+
/*
* Self-notify: no need to bother with table update.
* Indeed, we *must not* clear the notification field in
*/
if (kill(listenerPID, SIGUSR2) < 0)
projects / users / c2main / postgres.git / commitdiff