database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-11-10 17:42:29 +03:00
Code Activity

Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.

Browse Source
This commit is contained in:
Bruce Momjian
1997-09-08 02:41:22 +00:00
parent a90f12fd9d
commit 319dbfa736
632 changed files with 28301 additions and 28220 deletions
Download Patch File Download Diff File Expand all files Collapse all files

680
src/backend/access/common/heaptuple.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.22 1997/09/07 04:37:30 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.23 1997/09/08 02:19:47 momjian Exp $
*
* NOTES
* The old interface functions have been converted to macros
@@ -53,9 +53,9 @@ ComputeDataSize(TupleDesc tupleDesc,
Datum value[],
char nulls[])
{
uint32 data_length;
int i;
int numberOfAttributes = tupleDesc->natts;
uint32 data_length;
int i;
int numberOfAttributes = tupleDesc->natts;
AttributeTupleForm *att = tupleDesc->attrs;
for (data_length = 0, i = 0; i < numberOfAttributes; i++)
@@ -65,41 +65,41 @@ ComputeDataSize(TupleDesc tupleDesc,
switch (att[i]->attlen)
{
case -1:
case -1:
/*
* This is the size of the disk representation and so must
* include the additional sizeof long.
*/
if (att[i]->attalign == 'd')
{
data_length = DOUBLEALIGN(data_length)
+ VARSIZE(DatumGetPointer(value[i]));
}
else
{
data_length = INTALIGN(data_length)
+ VARSIZE(DatumGetPointer(value[i]));
}
break;
case sizeof(char):
data_length++;
break;
case sizeof(short):
data_length = SHORTALIGN(data_length + sizeof(short));
break;
case sizeof(int32):
data_length = INTALIGN(data_length + sizeof(int32));
break;
default:
if (att[i]->attlen < sizeof(int32))
elog(WARN, "ComputeDataSize: attribute %d has len %d",
i, att[i]->attlen);
if (att[i]->attalign == 'd')
data_length = DOUBLEALIGN(data_length) + att[i]->attlen;
else
data_length = LONGALIGN(data_length) + att[i]->attlen;
break;
/*
* This is the size of the disk representation and so must
* include the additional sizeof long.
*/
if (att[i]->attalign == 'd')
{
data_length = DOUBLEALIGN(data_length)
+ VARSIZE(DatumGetPointer(value[i]));
}
else
{
data_length = INTALIGN(data_length)
+ VARSIZE(DatumGetPointer(value[i]));
}
break;
case sizeof(char):
data_length++;
break;
case sizeof(short):
data_length = SHORTALIGN(data_length + sizeof(short));
break;
case sizeof(int32):
data_length = INTALIGN(data_length + sizeof(int32));
break;
default:
if (att[i]->attlen < sizeof(int32))
elog(WARN, "ComputeDataSize: attribute %d has len %d",
i, att[i]->attlen);
if (att[i]->attalign == 'd')
data_length = DOUBLEALIGN(data_length) + att[i]->attlen;
else
data_length = LONGALIGN(data_length) + att[i]->attlen;
break;
}
}
@@ -118,11 +118,11 @@ DataFill(char *data,
char *infomask,
bits8 * bit)
{
bits8 *bitP = 0;
int bitmask = 0;
uint32 data_length;
int i;
int numberOfAttributes = tupleDesc->natts;
bits8 *bitP = 0;
int bitmask = 0;
uint32 data_length;
int i;
int numberOfAttributes = tupleDesc->natts;
AttributeTupleForm *att = tupleDesc->attrs;
if (bit != NULL)
@@ -159,58 +159,58 @@ DataFill(char *data,
switch (att[i]->attlen)
{
case -1:
*infomask |= HEAP_HASVARLENA;
if (att[i]->attalign == 'd')
{
data = (char *) DOUBLEALIGN(data);
}
else
{
case -1:
*infomask |= HEAP_HASVARLENA;
if (att[i]->attalign == 'd')
{
data = (char *) DOUBLEALIGN(data);
}
else
{
data = (char *) INTALIGN(data);
}
data_length = VARSIZE(DatumGetPointer(value[i]));
memmove(data, DatumGetPointer(value[i]), data_length);
data += data_length;
break;
case sizeof(char):
*data = att[i]->attbyval ?
DatumGetChar(value[i]) : *((char *) value[i]);
data += sizeof(char);
break;
case sizeof(int16):
data = (char *) SHORTALIGN(data);
*(short *) data = (att[i]->attbyval ?
DatumGetInt16(value[i]) :
*((short *) value[i]));
data += sizeof(short);
break;
case sizeof(int32):
data = (char *) INTALIGN(data);
}
data_length = VARSIZE(DatumGetPointer(value[i]));
memmove(data, DatumGetPointer(value[i]), data_length);
data += data_length;
break;
case sizeof(char):
*data = att[i]->attbyval ?
DatumGetChar(value[i]) : *((char *) value[i]);
data += sizeof(char);
break;
case sizeof(int16):
data = (char *) SHORTALIGN(data);
*(short *) data = (att[i]->attbyval ?
DatumGetInt16(value[i]) :
*((short *) value[i]));
data += sizeof(short);
break;
case sizeof(int32):
data = (char *) INTALIGN(data);
*(int32 *) data = (att[i]->attbyval ?
DatumGetInt32(value[i]) :
*((int32 *) value[i]));
data += sizeof(int32);
break;
default:
if (att[i]->attlen < sizeof(int32))
elog(WARN, "DataFill: attribute %d has len %d",
i, att[i]->attlen);
if (att[i]->attalign == 'd')
{
data = (char *) DOUBLEALIGN(data);
memmove(data, DatumGetPointer(value[i]),
att[i]->attlen);
data += att[i]->attlen;
}
else
{
data = (char *) LONGALIGN(data);
memmove(data, DatumGetPointer(value[i]),
att[i]->attlen);
data += att[i]->attlen;
}
break;
*(int32 *) data = (att[i]->attbyval ?
DatumGetInt32(value[i]) :
*((int32 *) value[i]));
data += sizeof(int32);
break;
default:
if (att[i]->attlen < sizeof(int32))
elog(WARN, "DataFill: attribute %d has len %d",
i, att[i]->attlen);
if (att[i]->attalign == 'd')
{
data = (char *) DOUBLEALIGN(data);
memmove(data, DatumGetPointer(value[i]),
att[i]->attlen);
data += att[i]->attlen;
}
else
{
data = (char *) LONGALIGN(data);
memmove(data, DatumGetPointer(value[i]),
att[i]->attlen);
data += att[i]->attlen;
}
break;
}
}
}
@@ -240,24 +240,24 @@ heap_attisnull(HeapTuple tup, int attnum)
else
switch (attnum)
{
case SelfItemPointerAttributeNumber:
case ObjectIdAttributeNumber:
case MinTransactionIdAttributeNumber:
case MinCommandIdAttributeNumber:
case MaxTransactionIdAttributeNumber:
case MaxCommandIdAttributeNumber:
case ChainItemPointerAttributeNumber:
case AnchorItemPointerAttributeNumber:
case MinAbsoluteTimeAttributeNumber:
case MaxAbsoluteTimeAttributeNumber:
case VersionTypeAttributeNumber:
break;
case SelfItemPointerAttributeNumber:
case ObjectIdAttributeNumber:
case MinTransactionIdAttributeNumber:
case MinCommandIdAttributeNumber:
case MaxTransactionIdAttributeNumber:
case MaxCommandIdAttributeNumber:
case ChainItemPointerAttributeNumber:
case AnchorItemPointerAttributeNumber:
case MinAbsoluteTimeAttributeNumber:
case MaxAbsoluteTimeAttributeNumber:
case VersionTypeAttributeNumber:
break;
case 0:
elog(WARN, "heap_attisnull: zero attnum disallowed");
case 0:
elog(WARN, "heap_attisnull: zero attnum disallowed");
default:
elog(WARN, "heap_attisnull: undefined negative attnum");
default:
elog(WARN, "heap_attisnull: undefined negative attnum");
}
return (0);
@@ -277,38 +277,38 @@ heap_attisnull(HeapTuple tup, int attnum)
int
heap_sysattrlen(AttrNumber attno)
{
HeapTupleData *f = NULL;
HeapTupleData *f = NULL;
switch (attno)
{
case SelfItemPointerAttributeNumber:
return sizeof f->t_ctid;
case ObjectIdAttributeNumber:
return sizeof f->t_oid;
case MinTransactionIdAttributeNumber:
return sizeof f->t_xmin;
case MinCommandIdAttributeNumber:
return sizeof f->t_cmin;
case MaxTransactionIdAttributeNumber:
return sizeof f->t_xmax;
case MaxCommandIdAttributeNumber:
return sizeof f->t_cmax;
case ChainItemPointerAttributeNumber:
return sizeof f->t_chain;
case MinAbsoluteTimeAttributeNumber:
return sizeof f->t_tmin;
case MaxAbsoluteTimeAttributeNumber:
return sizeof f->t_tmax;
case VersionTypeAttributeNumber:
return sizeof f->t_vtype;
case SelfItemPointerAttributeNumber:
return sizeof f->t_ctid;
case ObjectIdAttributeNumber:
return sizeof f->t_oid;
case MinTransactionIdAttributeNumber:
return sizeof f->t_xmin;
case MinCommandIdAttributeNumber:
return sizeof f->t_cmin;
case MaxTransactionIdAttributeNumber:
return sizeof f->t_xmax;
case MaxCommandIdAttributeNumber:
return sizeof f->t_cmax;
case ChainItemPointerAttributeNumber:
return sizeof f->t_chain;
case MinAbsoluteTimeAttributeNumber:
return sizeof f->t_tmin;
case MaxAbsoluteTimeAttributeNumber:
return sizeof f->t_tmax;
case VersionTypeAttributeNumber:
return sizeof f->t_vtype;
case AnchorItemPointerAttributeNumber:
elog(WARN, "heap_sysattrlen: field t_anchor does not exist!");
return 0;
case AnchorItemPointerAttributeNumber:
elog(WARN, "heap_sysattrlen: field t_anchor does not exist!");
return 0;
default:
elog(WARN, "sysattrlen: System attribute number %d unknown.", attno);
return 0;
default:
elog(WARN, "sysattrlen: System attribute number %d unknown.", attno);
return 0;
}
}
@@ -321,48 +321,48 @@ heap_sysattrlen(AttrNumber attno)
bool
heap_sysattrbyval(AttrNumber attno)
{
bool byval;
bool byval;
switch (attno)
{
case SelfItemPointerAttributeNumber:
byval = false;
break;
case ObjectIdAttributeNumber:
byval = true;
break;
case MinTransactionIdAttributeNumber:
byval = true;
break;
case MinCommandIdAttributeNumber:
byval = true;
break;
case MaxTransactionIdAttributeNumber:
byval = true;
break;
case MaxCommandIdAttributeNumber:
byval = true;
break;
case ChainItemPointerAttributeNumber:
byval = false;
break;
case AnchorItemPointerAttributeNumber:
byval = false;
break;
case MinAbsoluteTimeAttributeNumber:
byval = true;
break;
case MaxAbsoluteTimeAttributeNumber:
byval = true;
break;
case VersionTypeAttributeNumber:
byval = true;
break;
default:
byval = true;
elog(WARN, "sysattrbyval: System attribute number %d unknown.",
attno);
break;
case SelfItemPointerAttributeNumber:
byval = false;
break;
case ObjectIdAttributeNumber:
byval = true;
break;
case MinTransactionIdAttributeNumber:
byval = true;
break;
case MinCommandIdAttributeNumber:
byval = true;
break;
case MaxTransactionIdAttributeNumber:
byval = true;
break;
case MaxCommandIdAttributeNumber:
byval = true;
break;
case ChainItemPointerAttributeNumber:
byval = false;
break;
case AnchorItemPointerAttributeNumber:
byval = false;
break;
case MinAbsoluteTimeAttributeNumber:
byval = true;
break;
case MaxAbsoluteTimeAttributeNumber:
byval = true;
break;
case VersionTypeAttributeNumber:
byval = true;
break;
default:
byval = true;
elog(WARN, "sysattrbyval: System attribute number %d unknown.",
attno);
break;
}
return byval;
@@ -372,57 +372,57 @@ heap_sysattrbyval(AttrNumber attno)
* heap_getsysattr
* ----------------
*/
char *
char *
heap_getsysattr(HeapTuple tup, Buffer b, int attnum)
{
switch (attnum)
{
case SelfItemPointerAttributeNumber:
return ((char *) &tup->t_ctid);
case ObjectIdAttributeNumber:
return ((char *) (long) tup->t_oid);
case MinTransactionIdAttributeNumber:
return ((char *) (long) tup->t_xmin);
case MinCommandIdAttributeNumber:
return ((char *) (long) tup->t_cmin);
case MaxTransactionIdAttributeNumber:
return ((char *) (long) tup->t_xmax);
case MaxCommandIdAttributeNumber:
return ((char *) (long) tup->t_cmax);
case ChainItemPointerAttributeNumber:
return ((char *) &tup->t_chain);
case AnchorItemPointerAttributeNumber:
elog(WARN, "heap_getsysattr: t_anchor does not exist!");
break;
case SelfItemPointerAttributeNumber:
return ((char *) &tup->t_ctid);
case ObjectIdAttributeNumber:
return ((char *) (long) tup->t_oid);
case MinTransactionIdAttributeNumber:
return ((char *) (long) tup->t_xmin);
case MinCommandIdAttributeNumber:
return ((char *) (long) tup->t_cmin);
case MaxTransactionIdAttributeNumber:
return ((char *) (long) tup->t_xmax);
case MaxCommandIdAttributeNumber:
return ((char *) (long) tup->t_cmax);
case ChainItemPointerAttributeNumber:
return ((char *) &tup->t_chain);
case AnchorItemPointerAttributeNumber:
elog(WARN, "heap_getsysattr: t_anchor does not exist!");
break;
/*
* For tmin and tmax, we need to do some extra work. These don't
* get filled in until the vacuum cleaner runs (or we manage to
* flush a page after setting the value correctly below). If the
* vacuum cleaner hasn't run yet, then the times stored in the
* tuple are wrong, and we need to look up the commit time of the
* transaction. We cache this value in the tuple to avoid doing
* the work more than once.
*/
/*
* For tmin and tmax, we need to do some extra work. These
* don't get filled in until the vacuum cleaner runs (or we
* manage to flush a page after setting the value correctly
* below). If the vacuum cleaner hasn't run yet, then the
* times stored in the tuple are wrong, and we need to look up
* the commit time of the transaction. We cache this value in
* the tuple to avoid doing the work more than once.
*/
case MinAbsoluteTimeAttributeNumber:
if (!AbsoluteTimeIsBackwardCompatiblyValid(tup->t_tmin) &&
TransactionIdDidCommit(tup->t_xmin))
tup->t_tmin = TransactionIdGetCommitTime(tup->t_xmin);
return ((char *) (long) tup->t_tmin);
case MaxAbsoluteTimeAttributeNumber:
if (!AbsoluteTimeIsBackwardCompatiblyReal(tup->t_tmax))
{
if (TransactionIdDidCommit(tup->t_xmax))
tup->t_tmax = TransactionIdGetCommitTime(tup->t_xmax);
else
tup->t_tmax = CURRENT_ABSTIME;
}
return ((char *) (long) tup->t_tmax);
case VersionTypeAttributeNumber:
return ((char *) (long) tup->t_vtype);
default:
elog(WARN, "heap_getsysattr: undefined attnum %d", attnum);
case MinAbsoluteTimeAttributeNumber:
if (!AbsoluteTimeIsBackwardCompatiblyValid(tup->t_tmin) &&
TransactionIdDidCommit(tup->t_xmin))
tup->t_tmin = TransactionIdGetCommitTime(tup->t_xmin);
return ((char *) (long) tup->t_tmin);
case MaxAbsoluteTimeAttributeNumber:
if (!AbsoluteTimeIsBackwardCompatiblyReal(tup->t_tmax))
{
if (TransactionIdDidCommit(tup->t_xmax))
tup->t_tmax = TransactionIdGetCommitTime(tup->t_xmax);
else
tup->t_tmax = CURRENT_ABSTIME;
}
return ((char *) (long) tup->t_tmax);
case VersionTypeAttributeNumber:
return ((char *) (long) tup->t_vtype);
default:
elog(WARN, "heap_getsysattr: undefined attnum %d", attnum);
}
return (NULL);
}
@@ -444,15 +444,15 @@ heap_getsysattr(HeapTuple tup, Buffer b, int attnum)
* the same attribute descriptor will go much quicker. -cim 5/4/91
* ----------------
*/
char *
char *
fastgetattr(HeapTuple tup,
int attnum,
TupleDesc tupleDesc,
bool * isnull)
{
char *tp; /* ptr to att in tuple */
bits8 *bp = NULL; /* ptr to att in tuple */
int slow; /* do we have to walk nulls? */
char *tp; /* ptr to att in tuple */
bits8 *bp = NULL; /* ptr to att in tuple */
int slow; /* do we have to walk nulls? */
AttributeTupleForm *att = tupleDesc->attrs;
/* ----------------
@@ -526,7 +526,7 @@ fastgetattr(HeapTuple tup,
*/
{
register int i = 0; /* current offset in bp */
register int i = 0; /* current offset in bp */
for (i = 0; i < attnum && !slow; i++)
{
@@ -554,7 +554,7 @@ fastgetattr(HeapTuple tup,
}
else if (!HeapTupleAllFixed(tup))
{
register int j = 0;
register int j = 0;
for (j = 0; j < attnum && !slow; j++)
if (att[j]->attlen < 1)
@@ -569,8 +569,8 @@ fastgetattr(HeapTuple tup,
*/
if (!slow)
{
register int j = 1;
register long off;
register int j = 1;
register long off;
/*
* need to set cache for some atts
@@ -587,30 +587,30 @@ fastgetattr(HeapTuple tup,
{
switch (att[j]->attlen)
{
case -1:
off = (att[j]->attalign == 'd') ?
DOUBLEALIGN(off) : INTALIGN(off);
break;
case sizeof(char):
break;
case sizeof(short):
off = SHORTALIGN(off);
break;
case sizeof(int32):
off = INTALIGN(off);
break;
default:
if (att[j]->attlen < sizeof(int32))
{
elog(WARN,
"fastgetattr: attribute %d has len %d",
j, att[j]->attlen);
}
if (att[j]->attalign == 'd')
off = DOUBLEALIGN(off);
else
off = LONGALIGN(off);
break;
case -1:
off = (att[j]->attalign == 'd') ?
DOUBLEALIGN(off) : INTALIGN(off);
break;
case sizeof(char):
break;
case sizeof(short):
off = SHORTALIGN(off);
break;
case sizeof(int32):
off = INTALIGN(off);
break;
default:
if (att[j]->attlen < sizeof(int32))
{
elog(WARN,
"fastgetattr: attribute %d has len %d",
j, att[j]->attlen);
}
if (att[j]->attalign == 'd')
off = DOUBLEALIGN(off);
else
off = LONGALIGN(off);
break;
}
att[j]->attcacheoff = off;
@@ -622,9 +622,9 @@ fastgetattr(HeapTuple tup,
}
else
{
register bool usecache = true;
register int off = 0;
register int i;
register bool usecache = true;
register int off = 0;
register int i;
/*
* Now we know that we have to walk the tuple CAREFULLY.
@@ -648,28 +648,28 @@ fastgetattr(HeapTuple tup,
}
switch (att[i]->attlen)
{
case -1:
off = (att[i]->attalign == 'd') ?
DOUBLEALIGN(off) : INTALIGN(off);
break;
case sizeof(char):
break;
case sizeof(short):
off = SHORTALIGN(off);
break;
case sizeof(int32):
off = INTALIGN(off);
break;
default:
if (att[i]->attlen < sizeof(int32))
elog(WARN,
"fastgetattr2: attribute %d has len %d",
i, att[i]->attlen);
if (att[i]->attalign == 'd')
off = DOUBLEALIGN(off);
else
off = LONGALIGN(off);
break;
case -1:
off = (att[i]->attalign == 'd') ?
DOUBLEALIGN(off) : INTALIGN(off);
break;
case sizeof(char):
break;
case sizeof(short):
off = SHORTALIGN(off);
break;
case sizeof(int32):
off = INTALIGN(off);
break;
default:
if (att[i]->attlen < sizeof(int32))
elog(WARN,
"fastgetattr2: attribute %d has len %d",
i, att[i]->attlen);
if (att[i]->attalign == 'd')
off = DOUBLEALIGN(off);
else
off = LONGALIGN(off);
break;
}
if (usecache && att[i]->attcacheoff > 0)
{
@@ -687,47 +687,47 @@ fastgetattr(HeapTuple tup,
switch (att[i]->attlen)
{
case sizeof(char):
off++;
break;
case sizeof(int16):
off += sizeof(int16);
break;
case sizeof(int32):
off += sizeof(int32);
break;
case -1:
usecache = false;
off += VARSIZE(tp + off);
break;
default:
off += att[i]->attlen;
break;
case sizeof(char):
off++;
break;
case sizeof(int16):
off += sizeof(int16);
break;
case sizeof(int32):
off += sizeof(int32);
break;
case -1:
usecache = false;
off += VARSIZE(tp + off);
break;
default:
off += att[i]->attlen;
break;
}
}
switch (att[attnum]->attlen)
{
case -1:
off = (att[attnum]->attalign == 'd') ?
DOUBLEALIGN(off) : INTALIGN(off);
break;
case sizeof(char):
break;
case sizeof(short):
off = SHORTALIGN(off);
break;
case sizeof(int32):
off = INTALIGN(off);
break;
default:
if (att[attnum]->attlen < sizeof(int32))
elog(WARN, "fastgetattr3: attribute %d has len %d",
attnum, att[attnum]->attlen);
if (att[attnum]->attalign == 'd')
off = DOUBLEALIGN(off);
else
off = LONGALIGN(off);
break;
case -1:
off = (att[attnum]->attalign == 'd') ?
DOUBLEALIGN(off) : INTALIGN(off);
break;
case sizeof(char):
break;
case sizeof(short):
off = SHORTALIGN(off);
break;
case sizeof(int32):
off = INTALIGN(off);
break;
default:
if (att[attnum]->attlen < sizeof(int32))
elog(WARN, "fastgetattr3: attribute %d has len %d",
attnum, att[attnum]->attlen);
if (att[attnum]->attalign == 'd')
off = DOUBLEALIGN(off);
else
off = LONGALIGN(off);
break;
}
return ((char *) fetchatt(&(att[attnum]), tp + off));
}
@@ -742,7 +742,7 @@ fastgetattr(HeapTuple tup,
HeapTuple
heap_copytuple(HeapTuple tuple)
{
HeapTuple newTuple;
HeapTuple newTuple;
if (!HeapTupleIsValid(tuple))
return (NULL);
@@ -772,15 +772,15 @@ heap_deformtuple(HeapTuple tuple,
Datum values[],
char nulls[])
{
int i;
int natts;
int i;
int natts;
Assert(HeapTupleIsValid(tuple));
natts = tuple->t_natts;
for (i = 0; i < natts; i++)
{
bool isnull;
bool isnull;
values[i] = (Datum) heap_getattr(tuple,
InvalidBuffer,
@@ -819,14 +819,14 @@ heap_formtuple(TupleDesc tupleDescriptor,
Datum value[],
char nulls[])
{
char *tp; /* tuple pointer */
HeapTuple tuple; /* return tuple */
int bitmaplen;
long len;
int hoff;
bool hasnull = false;
int i;
int numberOfAttributes = tupleDescriptor->natts;
char *tp; /* tuple pointer */
HeapTuple tuple; /* return tuple */
int bitmaplen;
long len;
int hoff;
bool hasnull = false;
int i;
int numberOfAttributes = tupleDescriptor->natts;
len = sizeof *tuple - sizeof tuple->t_bits;
@@ -885,14 +885,14 @@ heap_modifytuple(HeapTuple tuple,
char replNull[],
char repl[])
{
int attoff;
int numberOfAttributes;
Datum *value;
char *nulls;
bool isNull;
HeapTuple newTuple;
int madecopy;
uint8 infomask;
int attoff;
int numberOfAttributes;
Datum *value;
char *nulls;
bool isNull;
HeapTuple newTuple;
int madecopy;
uint8 infomask;
/* ----------------
* sanity checks
@@ -936,7 +936,7 @@ heap_modifytuple(HeapTuple tuple,
if (repl[attoff] == ' ')
{
char *attr;
char *attr;
attr =
heap_getattr(tuple,
@@ -1001,10 +1001,10 @@ heap_addheader(uint32 natts, /* max domain index */
int structlen, /* its length */
char *structure) /* pointer to the struct */
{
register char *tp; /* tuple data pointer */
HeapTuple tup;
long len;
int hoff;
register char *tp; /* tuple data pointer */
HeapTuple tup;
long len;
int hoff;
AssertArg(natts > 0);

18
src/backend/access/common/heapvalid.c
View File

@@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/common/Attic/heapvalid.c,v 1.17 1997/09/07 04:37:36 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/access/common/Attic/heapvalid.c,v 1.18 1997/09/08 02:19:51 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -36,9 +36,9 @@ heap_keytest(HeapTuple t,
int nkeys,
ScanKey keys)
{
bool isnull;
Datum atp;
int test;
bool isnull;
Datum atp;
int test;
for (; nkeys--; keys++)
{
@@ -101,11 +101,11 @@ heap_tuple_satisfies(ItemId itemId,
int nKeys,
ScanKey key)
{
HeapTuple tuple,
result;
bool res;
TransactionId old_tmin,
old_tmax;
HeapTuple tuple,
result;
bool res;
TransactionId old_tmin,
old_tmax;
if (!ItemIdIsUsed(itemId))
return NULL;

190
src/backend/access/common/indextuple.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/common/indextuple.c,v 1.16 1997/09/07 04:37:37 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/access/common/indextuple.c,v 1.17 1997/09/08 02:19:54 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -26,8 +26,8 @@
#include <string.h>
#endif
static Size IndexInfoFindDataOffset(unsigned short t_info);
static char *
static Size IndexInfoFindDataOffset(unsigned short t_info);
static char *
fastgetiattr(IndexTuple tup, int attnum,
TupleDesc att, bool * isnull);
@@ -45,15 +45,15 @@ index_formtuple(TupleDesc tupleDescriptor,
Datum value[],
char null[])
{
register char *tp; /* tuple pointer */
IndexTuple tuple; /* return tuple */
Size size,
hoff;
int i;
unsigned short infomask = 0;
bool hasnull = false;
char tupmask = 0;
int numberOfAttributes = tupleDescriptor->natts;
register char *tp; /* tuple pointer */
IndexTuple tuple; /* return tuple */
Size size,
hoff;
int i;
unsigned short infomask = 0;
bool hasnull = false;
char tupmask = 0;
int numberOfAttributes = tupleDescriptor->natts;
if (numberOfAttributes > MaxIndexAttributeNumber)
elog(WARN, "index_formtuple: numberOfAttributes of %d > %d",
@@ -133,16 +133,16 @@ index_formtuple(TupleDesc tupleDescriptor,
* the same attribute descriptor will go much quicker. -cim 5/4/91
* ----------------
*/
static char *
static char *
fastgetiattr(IndexTuple tup,
int attnum,
TupleDesc tupleDesc,
bool * isnull)
{
register char *tp; /* ptr to att in tuple */
register char *bp = NULL; /* ptr to att in tuple */
int slow; /* do we have to walk nulls? */
register int data_off; /* tuple data offset */
register char *tp; /* ptr to att in tuple */
register char *bp = NULL; /* ptr to att in tuple */
int slow; /* do we have to walk nulls? */
register int data_off; /* tuple data offset */
AttributeTupleForm *att = tupleDesc->attrs;
/* ----------------
@@ -212,11 +212,11 @@ fastgetiattr(IndexTuple tup,
* ----------------
*/
{
register int i = 0; /* current offset in bp */
register int mask; /* bit in byte we're looking at */
register char n; /* current byte in bp */
register int byte,
finalbit;
register int i = 0; /* current offset in bp */
register int mask; /* bit in byte we're looking at */
register char n; /* current byte in bp */
register int byte,
finalbit;
byte = attnum >> 3;
finalbit = attnum & 0x07;
@@ -256,7 +256,7 @@ fastgetiattr(IndexTuple tup,
}
else if (!IndexTupleAllFixed(tup))
{
register int j = 0;
register int j = 0;
for (j = 0; j < attnum && !slow; j++)
if (att[j]->attlen < 1)
@@ -272,8 +272,8 @@ fastgetiattr(IndexTuple tup,
if (!slow)
{
register int j = 1;
register long off;
register int j = 1;
register long off;
/*
* need to set cache for some atts
@@ -297,26 +297,26 @@ fastgetiattr(IndexTuple tup,
switch (att[j]->attlen)
{
case -1:
off = (att[j]->attalign == 'd') ?
DOUBLEALIGN(off) : INTALIGN(off);
break;
case sizeof(char):
break;
case sizeof(short):
off = SHORTALIGN(off);
break;
case sizeof(int32):
off = INTALIGN(off);
break;
default:
if (att[j]->attlen > sizeof(int32))
case -1:
off = (att[j]->attalign == 'd') ?
DOUBLEALIGN(off) : LONGALIGN(off);
else
elog(WARN, "fastgetiattr: attribute %d has len %d",
j, att[j]->attlen);
break;
DOUBLEALIGN(off) : INTALIGN(off);
break;
case sizeof(char):
break;
case sizeof(short):
off = SHORTALIGN(off);
break;
case sizeof(int32):
off = INTALIGN(off);
break;
default:
if (att[j]->attlen > sizeof(int32))
off = (att[j]->attalign == 'd') ?
DOUBLEALIGN(off) : LONGALIGN(off);
else
elog(WARN, "fastgetiattr: attribute %d has len %d",
j, att[j]->attlen);
break;
}
@@ -329,9 +329,9 @@ fastgetiattr(IndexTuple tup,
}
else
{
register bool usecache = true;
register int off = 0;
register int i;
register bool usecache = true;
register int off = 0;
register int i;
/*
* Now we know that we have to walk the tuple CAREFULLY.
@@ -361,31 +361,31 @@ fastgetiattr(IndexTuple tup,
att[i]->attcacheoff = off;
switch (att[i]->attlen)
{
case sizeof(char):
off++;
break;
case sizeof(short):
off = SHORTALIGN(off) +sizeof(short);
break;
case sizeof(int32):
off = INTALIGN(off) + sizeof(int32);
break;
case -1:
usecache = false;
off = (att[i]->attalign == 'd') ?
DOUBLEALIGN(off) : INTALIGN(off);
off += VARSIZE(tp + off);
break;
default:
if (att[i]->attlen > sizeof(int32))
case sizeof(char):
off++;
break;
case sizeof(short):
off = SHORTALIGN(off) +sizeof(short);
break;
case sizeof(int32):
off = INTALIGN(off) + sizeof(int32);
break;
case -1:
usecache = false;
off = (att[i]->attalign == 'd') ?
DOUBLEALIGN(off) + att[i]->attlen :
LONGALIGN(off) + att[i]->attlen;
else
elog(WARN, "fastgetiattr2: attribute %d has len %d",
i, att[i]->attlen);
DOUBLEALIGN(off) : INTALIGN(off);
off += VARSIZE(tp + off);
break;
default:
if (att[i]->attlen > sizeof(int32))
off = (att[i]->attalign == 'd') ?
DOUBLEALIGN(off) + att[i]->attlen :
LONGALIGN(off) + att[i]->attlen;
else
elog(WARN, "fastgetiattr2: attribute %d has len %d",
i, att[i]->attlen);
break;
break;
}
}
@@ -395,27 +395,27 @@ fastgetiattr(IndexTuple tup,
*/
switch (att[attnum]->attlen)
{
case -1:
off = (att[attnum]->attalign == 'd') ?
DOUBLEALIGN(off) : INTALIGN(off);
break;
case sizeof(char):
break;
case sizeof(short):
off = SHORTALIGN(off);
break;
case sizeof(int32):
off = INTALIGN(off);
break;
default:
if (att[attnum]->attlen < sizeof(int32))
elog(WARN, "fastgetattr3: attribute %d has len %d",
attnum, att[attnum]->attlen);
if (att[attnum]->attalign == 'd')
off = DOUBLEALIGN(off);
else
off = LONGALIGN(off);
break;
case -1:
off = (att[attnum]->attalign == 'd') ?
DOUBLEALIGN(off) : INTALIGN(off);
break;
case sizeof(char):
break;
case sizeof(short):
off = SHORTALIGN(off);
break;
case sizeof(int32):
off = INTALIGN(off);
break;
default:
if (att[attnum]->attlen < sizeof(int32))
elog(WARN, "fastgetattr3: attribute %d has len %d",
attnum, att[attnum]->attlen);
if (att[attnum]->attalign == 'd')
off = DOUBLEALIGN(off);
else
off = LONGALIGN(off);
break;
}
return (fetchatt(&att[attnum], tp + off));
@@ -461,14 +461,14 @@ FormRetrieveIndexResult(ItemPointer indexItemPointer,
*
* Change me if adding an attribute to IndexTuples!!!!!!!!!!!
*/
static Size
static Size
IndexInfoFindDataOffset(unsigned short t_info)
{
if (!(t_info & INDEX_NULL_MASK))
return ((Size) sizeof(IndexTupleData));
else
{
Size size = sizeof(IndexTupleData);
Size size = sizeof(IndexTupleData);
if (t_info & INDEX_NULL_MASK)
{
@@ -485,8 +485,8 @@ IndexInfoFindDataOffset(unsigned short t_info)
void
CopyIndexTuple(IndexTuple source, IndexTuple * target)
{
Size size;
IndexTuple ret;
Size size;
IndexTuple ret;
size = IndexTupleSize(source);
if (*target == NULL)

10
src/backend/access/common/indexvalid.c
View File

@@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/common/Attic/indexvalid.c,v 1.15 1997/09/07 04:37:38 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/access/common/Attic/indexvalid.c,v 1.16 1997/09/08 02:19:55 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -24,7 +24,7 @@
* index scan key qualification code
* ----------------------------------------------------------------
*/
int NIndexTupleProcessed;
int NIndexTupleProcessed;
/* ----------------
* index_keytest
@@ -40,9 +40,9 @@ index_keytest(IndexTuple tuple,
int scanKeySize,
ScanKey key)
{
bool isNull;
Datum datum;
int test;
bool isNull;
Datum datum;
int test;
IncrIndexProcessed();

78
src/backend/access/common/printtup.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.16 1997/09/07 04:37:39 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.17 1997/09/08 02:19:56 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -35,7 +35,7 @@
Oid
typtoout(Oid type)
{
HeapTuple typeTuple;
HeapTuple typeTuple;
typeTuple = SearchSysCacheTuple(TYPOID,
ObjectIdGetDatum(type),
@@ -52,7 +52,7 @@ typtoout(Oid type)
Oid
gettypelem(Oid type)
{
HeapTuple typeTuple;
HeapTuple typeTuple;
typeTuple = SearchSysCacheTuple(TYPOID,
ObjectIdGetDatum(type),
@@ -73,13 +73,13 @@ gettypelem(Oid type)
void
printtup(HeapTuple tuple, TupleDesc typeinfo)
{
int i,
j,
k;
char *outputstr,
*attr;
bool isnull;
Oid typoutput;
int i,
j,
k;
char *outputstr,
*attr;
bool isnull;
Oid typoutput;
/* ----------------
* tell the frontend to expect new tuple data
@@ -158,8 +158,8 @@ printatt(unsigned attributeId,
void
showatts(char *name, TupleDesc tupleDesc)
{
int i;
int natts = tupleDesc->natts;
int i;
int natts = tupleDesc->natts;
AttributeTupleForm *attinfo = tupleDesc->attrs;
puts(name);
@@ -175,11 +175,11 @@ showatts(char *name, TupleDesc tupleDesc)
void
debugtup(HeapTuple tuple, TupleDesc typeinfo)
{
register int i;
char *attr,
*value;
bool isnull;
Oid typoutput;
register int i;
char *attr,
*value;
bool isnull;
Oid typoutput;
for (i = 0; i < tuple->t_natts; ++i)
{
@@ -209,11 +209,11 @@ debugtup(HeapTuple tuple, TupleDesc typeinfo)
void
printtup_internal(HeapTuple tuple, TupleDesc typeinfo)
{
int i,
j,
k;
char *attr;
bool isnull;
int i,
j,
k;
char *attr;
bool isnull;
/* ----------------
* tell the frontend to expect new tuple data
@@ -254,7 +254,7 @@ printtup_internal(HeapTuple tuple, TupleDesc typeinfo)
#endif
for (i = 0; i < tuple->t_natts; ++i)
{
int32 len = typeinfo->attrs[i]->attlen;
int32 len = typeinfo->attrs[i]->attlen;
attr = heap_getattr(tuple, InvalidBuffer, i + 1, typeinfo, &isnull);
if (!isnull)
@@ -269,7 +269,7 @@ printtup_internal(HeapTuple tuple, TupleDesc typeinfo)
pq_putnchar(VARDATA(attr), len);
#ifdef IPORTAL_DEBUG
{
char *d = VARDATA(attr);
char *d = VARDATA(attr);
fprintf(stderr, "length %d data %x%x%x%x\n",
len, *d, *(d + 1), *(d + 2), *(d + 3));
@@ -281,25 +281,25 @@ printtup_internal(HeapTuple tuple, TupleDesc typeinfo)
/* fixed size */
if (typeinfo->attrs[i]->attbyval)
{
int8 i8;
int16 i16;
int32 i32;
int8 i8;
int16 i16;
int32 i32;
pq_putint(len, sizeof(int32));
switch (len)
{
case sizeof(int8):
i8 = DatumGetChar(attr);
pq_putnchar((char *) &i8, len);
break;
case sizeof(int16):
i16 = DatumGetInt16(attr);
pq_putnchar((char *) &i16, len);
break;
case sizeof(int32):
i32 = DatumGetInt32(attr);
pq_putnchar((char *) &i32, len);
break;
case sizeof(int8):
i8 = DatumGetChar(attr);
pq_putnchar((char *) &i8, len);
break;
case sizeof(int16):
i16 = DatumGetInt16(attr);
pq_putnchar((char *) &i16, len);
break;
case sizeof(int32):
i32 = DatumGetInt32(attr);
pq_putnchar((char *) &i32, len);
break;
}
#ifdef IPORTAL_DEBUG
fprintf(stderr, "byval length %d data %d\n", len, attr);

64
src/backend/access/common/tupdesc.c
View File

@@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/common/tupdesc.c,v 1.20 1997/09/07 04:37:41 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/access/common/tupdesc.c,v 1.21 1997/09/08 02:19:56 momjian Exp $
*
* NOTES
* some of the executor utility code such as "ExecTypeFromTL" should be
@@ -42,8 +42,8 @@
TupleDesc
CreateTemplateTupleDesc(int natts)
{
uint32 size;
TupleDesc desc;
uint32 size;
TupleDesc desc;
/* ----------------
* sanity checks
@@ -77,7 +77,7 @@ CreateTemplateTupleDesc(int natts)
TupleDesc
CreateTupleDesc(int natts, AttributeTupleForm * attrs)
{
TupleDesc desc;
TupleDesc desc;
/* ----------------
* sanity checks
@@ -105,9 +105,9 @@ CreateTupleDesc(int natts, AttributeTupleForm * attrs)
TupleDesc
CreateTupleDescCopy(TupleDesc tupdesc)
{
TupleDesc desc;
int i,
size;
TupleDesc desc;
int i,
size;
desc = (TupleDesc) palloc(sizeof(struct tupleDesc));
desc->natts = tupdesc->natts;
@@ -139,10 +139,10 @@ CreateTupleDescCopy(TupleDesc tupdesc)
TupleDesc
CreateTupleDescCopyConstr(TupleDesc tupdesc)
{
TupleDesc desc;
TupleConstr *constr = tupdesc->constr;
int i,
size;
TupleDesc desc;
TupleConstr *constr = tupdesc->constr;
int i,
size;
desc = (TupleDesc) palloc(sizeof(struct tupleDesc));
desc->natts = tupdesc->natts;
@@ -158,7 +158,7 @@ CreateTupleDescCopyConstr(TupleDesc tupdesc)
}
if (constr)
{
TupleConstr *cpy = (TupleConstr *) palloc(sizeof(TupleConstr));
TupleConstr *cpy = (TupleConstr *) palloc(sizeof(TupleConstr));
cpy->has_not_null = constr->has_not_null;
@@ -201,7 +201,7 @@ CreateTupleDescCopyConstr(TupleDesc tupdesc)
void
FreeTupleDesc(TupleDesc tupdesc)
{
int i;
int i;
for (i = 0; i < tupdesc->natts; i++)
pfree(tupdesc->attrs[i]);
@@ -210,7 +210,7 @@ FreeTupleDesc(TupleDesc tupdesc)
{
if (tupdesc->constr->num_defval > 0)
{
AttrDefault *attrdef = tupdesc->constr->defval;
AttrDefault *attrdef = tupdesc->constr->defval;
for (i = tupdesc->constr->num_defval - 1; i >= 0; i--)
{
@@ -223,7 +223,7 @@ FreeTupleDesc(TupleDesc tupdesc)
}
if (tupdesc->constr->num_check > 0)
{
ConstrCheck *check = tupdesc->constr->check;
ConstrCheck *check = tupdesc->constr->check;
for (i = tupdesc->constr->num_check - 1; i >= 0; i--)
{
@@ -258,8 +258,8 @@ TupleDescInitEntry(TupleDesc desc,
int attdim,
bool attisset)
{
HeapTuple tuple;
TypeTupleForm typeForm;
HeapTuple tuple;
TypeTupleForm typeForm;
AttributeTupleForm att;
/* ----------------
@@ -378,7 +378,7 @@ TupleDescInitEntry(TupleDesc desc,
*/
if (attisset)
{
Type t = type("oid");
Type t = type("oid");
att->attlen = tlen(t);
att->attbyval = tbyval(t);
@@ -411,7 +411,7 @@ TupleDescMakeSelfReference(TupleDesc desc,
char *relname)
{
AttributeTupleForm att;
Type t = type("oid");
Type t = type("oid");
att = desc->attrs[attnum - 1];
att->atttypid = TypeShellMake(relname);
@@ -439,17 +439,17 @@ TupleDescMakeSelfReference(TupleDesc desc,
TupleDesc
BuildDescForRelation(List * schema, char *relname)
{
int natts;
AttrNumber attnum;
List *p;
TupleDesc desc;
AttrDefault *attrdef = NULL;
TupleConstr *constr = (TupleConstr *) palloc(sizeof(TupleConstr));
char *attname;
char *typename;
int attdim;
int ndef = 0;
bool attisset;
int natts;
AttrNumber attnum;
List *p;
TupleDesc desc;
AttrDefault *attrdef = NULL;
TupleConstr *constr = (TupleConstr *) palloc(sizeof(TupleConstr));
char *attname;
char *typename;
int attdim;
int ndef = 0;
bool attisset;
/* ----------------
* allocate a new tuple descriptor
@@ -465,8 +465,8 @@ BuildDescForRelation(List * schema, char *relname)
foreach(p, schema)
{
ColumnDef *entry;
List *arry;
ColumnDef *entry;
List *arry;
/* ----------------
* for each entry in the list, get the name and type